const fsPromises = require('fs').promises

/**
 * 判断路径是否存在/是否是文件夹
 * @param {String} path 文件地址 + 名称 + 后缀名
 * @return {Array[Boolean, Boolean]} 返回数组[是否存在, 是否是文件夹]
 */
async function pathType(path) {
  try {
    const stat = await fsPromises.stat(path)
    const isDir = await stat.isDirectory()
    return [true, isDir]
  } catch(error) {
    return [false, error]
  }
}

const fsPromises = require('fs').promises

/**
 * 删除文件/文件夹
 * @param {String} targetPath 文件地址 + 名称 + 后缀名
 */
async function removeFileOrDir(target) {
  try {
    await fsPromises.rm(target, { recursive: true, force: true })
    return [true]
  } catch(error) {
    return [false, error]
  }
}

/**
 * 解析一个文件路径，得到想要的
 * @param {string} filePath 文件路径
 * @returns {string[]} 文件全名、去掉后缀名的名称、后缀名
 */
export function parsePathInfo(filePath: string): string[] {
  const slashIndex = Math.max(filePath.lastIndexOf('/'), filePath.lastIndexOf('\\'))
  let fileFullName = filePath.substring(slashIndex + 1)
  const dotIndex = fileFullName.lastIndexOf('.')
  let fileBaseName = '', fileExtension = ''
  if (dotIndex > -1) {
    fileBaseName = fileFullName.substring(0, dotIndex)
    fileExtension = fileFullName.substring(dotIndex)
  }
  return [fileFullName, fileBaseName, fileExtension]
}

const fsPromises = require('fs').promises

/**
 * 写入文件
 * @param {String} path 文件地址 + 名称 + 后缀名
 * @param {String} content 内容
 */
async function writeFile(path, content) {
  let lastPath = path.substring(0, path.lastIndexOf('/'))
  // 先创建文件夹们
  try {
    await fsPromises.mkdir(lastPath, {recursive: true})
  } catch(error) {
    return [false, error]
  }
  // 写入文件
  try {
    await fsPromises.writeFile(path, content)
    return [true]
  } catch(error) {
    return [false, error]
  }
}

const fsPromises = require('fs').promises

/**
 * 读取文件内容
 * @param {String} path 文件地址 + 名称 + 后缀名
 */
async function readFile(path) {
  try {
    const result = (await fsPromises.readFile(path, { encoding: 'utf-8' })).toString()
    return [true, result]
  } catch(error) {
    return [false, error]
  }
}

const fsPromises = require('fs').promises

// 读取路径下的文件夹、文件名称数组
async function readdir(path) {
  try {
    let dirArr = await fsPromises.readdir(path)
    return [true, dirArr]
  } catch(error) {
    return [false, error]
  }
}

const fsPromises = require('fs').promises

// 移动、重命名文件
async function move(from, to) {
  try {
    await fsPromises.rename(from, to)
    return [true]
  } catch(error) {
    return [false, error]
  }
}

const fsPromises = require('fs').promises

// 复制文件
async function copy(from, to) {
  try {
    // await fsPromises.copyFile(from, to)
    await fsPromises.cp(from, to, { recursive: true })
    return [true]
  } catch(error) {
    return [false, error]
  }
}

const fsPromises = require('fs').promises

// 创建文件夹
async function creatDir(dirPath) {
  try {
    // recursive: 没有路径则自动创建路径
    await fsPromises.mkdir(dirPath, { recursive: true })
    return [true]
  } catch(error) {
    return [false, error]
  }
}

const exec = require('child_process').exec

// 执行终端命令，string：要执行的指令
function toExec(string) {
  return new Promise(resolve => {
    exec(string, (error, stdout) => {
      if (error) return resolve([false, error])
      return resolve([true, stdout])
    })
  })
}

// ./getDirFiles.js
const fsPromises = require('fs').promises

// 过滤用的方法，不传则默认使用这个方法，此方法返回true则保留，否则忽略
// 注意，如果项是方法，则传给方法的info.children是null，免得消耗性能获取了children，结果这个文件夹名字被过滤了。
const filterHandler = (info) => {
  // 要忽略的文件、文件夹名称
  let ignoreNameArr = [
    '.git',
    'node_modules',
    '.DS_Store',
    '.vscode',
    '.idea',
  ];

  if (ignoreNameArr.includes(info.fullName)) return false
  return true
}

/**
 * 提供文件夹路径，这里递归遍历文件夹，得到所有递归文件信息
 * @returns
 * dirPath: 所在文件夹路径
 * path: 所在文件夹路径+名称+后缀名
 * fullName: 名字+后缀名，也就是下面的 [name].[suffix]
 * name: 纯名称不带后缀名
 * suffix: 后缀名
 * isDir: 是否是文件夹
 * paraent: 父级目录信息
 * children: 子文件数组
 */
const getDirFiles = (() => {
  // 读取路径下的文件夹、文件名称数组
  async function readdir(path) {
    try {
      let dirArr = await fsPromises.readdir(path)
      return [true, dirArr]
    } catch(error) {
      return [false, error]
    }
  }
  
  /**
   * 判断路径是否存在/是否是文件夹
   * @param {String} path 文件地址 + 名称 + 后缀名
   * @return {Array[Boolean, Boolean]} 返回数组[是否存在, 是否是文件夹]
   */
  async function pathType(path) {
    try {
      const stat = await fsPromises.stat(path)
      const isDir = stat.isDirectory()
      return [true, isDir]
    } catch(error) {
      return [false, error]
    }
  }
  
  return async (dirPath, _filterHandler = filterHandler) => {
    async function one(tempPath, paraent = null) {
      // 获取文件夹内部直接子文件、文件夹的名称字符串数组
      let [success, data] = await readdir(tempPath)
      let fileNameArr = []
      if (success) fileNameArr = data || []
      let children = []
      for (let fullName of fileNameArr) {
        let filePath = `${tempPath}/${fullName}`
        const typeInfo = await pathType(filePath)
        if (!typeInfo) continue
        let info = {
          dirPath: tempPath, // 所在文件夹路径
          path: filePath, // 所在文件夹路径+名称+后缀名
          fullName, // 名字+后缀名，也就是下面的 [name].[suffix]
          name: '', // 纯名称不带后缀名
          suffix: null, // 后缀名
          isDir: typeInfo[1], // 是否是文件夹
          paraent, // 父级目录信息
          children: null, // 子文件数组
        }
        // 是文件夹
        if (info.isDir) {
          info.name = fullName
          // 过滤文件是否要忽略
          const needKeep = _filterHandler(info)
          if (!needKeep) continue
          info.children = await one(filePath, info) || []
        } else {
          let name = fullName.substring(0, fullName.lastIndexOf('.'))
          info.name = name || fullName
          info.suffix = fullName.substring(fullName.lastIndexOf('.') + 1)
          info.children = null
          // 过滤文件是否要忽略
          const needKeep = _filterHandler(info)
          if (!needKeep) continue
        }
        children.push(info)
      }
      return children
    }
  
    const dirInfo = await one(dirPath, null)
    return dirInfo
  }
})();

module.exports = getDirFiles;

// ./getDirFiles.js
import { promises as fsPromises } from 'fs'

type DirInfo = {
  dirPath: string | null, // 所在文件夹路径
  path: string, // 所在文件夹路径+名称+后缀名
  fullName: string, // 名字+后缀名，也就是下面的 [name].[suffix]
  name: string, // 纯名称不带后缀名
  suffix: null | string, // 后缀名
  isDir: boolean, // 是否是文件夹
  paraent: DirInfo | null, // 父级目录信息
  children: null | DirInfo[], // 子文件数组
}

// 过滤用的方法，不传则默认使用这个方法，此方法返回true则保留，否则忽略
// 注意，如果项是方法，则传给方法的info.children是null，免得消耗性能获取了children，结果这个文件夹名字被过滤了。
const filterHandler = (info: DirInfo) => {
  // 要忽略的文件、文件夹名称
  let ignoreNameArr = [
    '.git',
    'node_modules',
    '.DS_Store',
    '.vscode',
    '.idea',
  ];

  if (ignoreNameArr.includes(info.fullName)) return false
  return true
}

/**
 * 提供文件夹路径，这里递归遍历文件夹，得到所有递归文件信息
 * @returns
 * dirPath: 所在文件夹路径
 * path: 所在文件夹路径+名称+后缀名
 * fullName: 名字+后缀名，也就是下面的 [name].[suffix]
 * name: 纯名称不带后缀名
 * suffix: 后缀名
 * isDir: 是否是文件夹
 * paraent: 父级目录信息
 * children: 子文件数组
 */
const getDirFiles = (() => {
  // 读取路径下的文件夹、文件名称数组
  async function readdir(path: string): Promise<[boolean, string[] | any]> {
    try {
      let dirArr = await fsPromises.readdir(path)
      return [true, dirArr]
    } catch(error) {
      return [false, error]
    }
  }
  
  /**
   * 判断路径是否存在/是否是文件夹
   * @param {String} path 文件地址 + 名称 + 后缀名
   * @return {Array[Boolean, Boolean]} 返回数组[是否存在, 是否是文件夹]
   */
  async function pathType(path: string): Promise<[boolean, boolean | any]> {
    try {
      const stat = await fsPromises.stat(path)
      const isDir = stat.isDirectory()
      return [true, isDir]
    } catch(error) {
      return [false, error]
    }
  }
  
  return async (dirPath: string, _filterHandler = filterHandler): Promise<DirInfo[]> => {
    async function one(tempPath: string, paraent: DirInfo | null = null): Promise<DirInfo[]> {
      // 获取文件夹内部直接子文件、文件夹的名称字符串数组
      let [success, data] = await readdir(tempPath)
      let fileNameArr = []
      if (success) fileNameArr = data || []
      let children = []
      for (let fullName of fileNameArr) {
        let filePath = `${tempPath}/${fullName}`
        const typeInfo = await pathType(filePath)
        if (!typeInfo) continue
        let info: DirInfo = {
          dirPath: tempPath, // 所在文件夹路径
          path: filePath, // 所在文件夹路径+名称+后缀名
          fullName, // 名字+后缀名，也就是下面的 [name].[suffix]
          name: '', // 纯名称不带后缀名
          suffix: null, // 后缀名
          isDir: typeInfo[1], // 是否是文件夹
          paraent, // 父级目录信息
          children: null, // 子文件数组
        }
        // 是文件夹
        if (info.isDir) {
          info.name = fullName
          // 过滤文件是否要忽略
          const needKeep = _filterHandler(info)
          if (!needKeep) continue
          info.children = await one(filePath, info) || []
        } else {
          let name = fullName.substring(0, fullName.lastIndexOf('.'))
          info.name = name || fullName
          info.suffix = fullName.substring(fullName.lastIndexOf('.') + 1)
          info.children = null
          // 过滤文件是否要忽略
          const needKeep = _filterHandler(info)
          if (!needKeep) continue
        }
        children.push(info)
      }
      return children
    }
  
    const dirInfo = await one(dirPath, null)
    return dirInfo
  }
})();

export default getDirFiles

// 使用示例
const getDirFiles = require('./getDirFiles.js')

// 先获取文件夹信息
getDirFiles('/Users/username/Desktop/sdf').then((dirList) => {
  async function handle(list) {
    for (let index = 0; index < list.length; index++) {
      const info = list[index]
      const {
        dirPath, // 所在文件夹路径
        path, // 所在文件夹路径+名称+后缀名
        fullName, // 名字+后缀名，也就是下面的 [name].[suffix]
        name, // 纯名称不带后缀名
        suffix, // 后缀名
        isDir, // 是否是文件夹
        paraent, // 父级目录信息
        children, // 子文件数组
      } = info
  
      // 处理的代码 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
      console.log(path)
  
      // 递归处理文件夹
      if (info.isDir) handle(info.children)
    }
  }
  handle(dirList)
})

import os from 'os';

function getIPAddress() {
  let IPAddress = "";
  let interfaces = os.networkInterfaces();
  for (let devName in interfaces) {
    let iface = interfaces[devName];
    if (iface) {
      for (let i = 0; i < iface.length; i++) {
        let alias = iface[i];
        if (alias.family === "IPv4" && alias.address !== "127.0.0.1" && !alias.internal) {
          IPAddress = alias.address;
        }
      }
    }
  }
  return IPAddress;
}