const path = require("path")
const shelljs = require("shelljs")
const fs = require("fs-extra") 

/**
 *  
 *  匹配指定路径或文件名称
 *  
 *  const matcher = fileMatcher([
 *    "<pattern>",          // 匹配正则表达式字符串
 *    "!<pattern>",         // 以!开头代表否定匹配
 *    /正则表达式/ 
 *  ],{
 *      basePath:"<指定一个基准目录，所有不是以此开头的均视为不匹配>",
 *      defaultPatterns:["<默认排除的模式>","<默认排除的模式>","<默认排除的模式>"],
 *      debug:<true/>false,是否输出调试信息,当=true时，.test()方法返回[<true/false>,pattern]      *      
 *  })
 * 
 * 
 * 
 * 
 * @param {*} patterns 
 * @param {*} basePath          如果指定basePath，则所有不是以basePath开头的文件都排除
 * @param {*} defaultPatterns    默认的匹配模式
 * @param {*} debug              是否输出调试信息
 */

 function fileMatcher(patterns,{basePath,defaultPatterns=[],debug=true}={}) {
    if(basePath) {
        basePath = path.normalize(basePath)
    }    
    //[[pattern,exclude],[pattern,false],[pattern,true]]
    let finalPatterns = []
    let inputPatterns =  Array.isArray(patterns) ? patterns : (patterns ? [patterns] : [])

    // 默认排除模式
    if(defaultPatterns.length===0){        
        finalPatterns.push([/.*\/node_modules\/.*/,true])
        finalPatterns.push([/.*\/languages\/.*/,true])           // 默认排除语言文件
        finalPatterns.push([/\.babelrc/,true])
        finalPatterns.push([/babel\.config\.js/,true])
        finalPatterns.push([/package\.json$/,true])
        finalPatterns.push([/vite\.config\.js$/,true])
        finalPatterns.push([/^plugin-vue:.*/,true])    
    }

    inputPatterns.forEach(pattern=>{
        if(typeof pattern === "string"){    
            pattern.replaceAll("**",".*")
            pattern.replaceAll("?","[^\/]?")
            pattern.replaceAll(/(?<!\.)\*/g,"[^\/]*")            
            // 以!开头的表示排除
            if(pattern.startsWith("!")){
                finalPatterns.unshift([new RegExp(pattern.substring(1),"g"),true])
            }else{
                finalPatterns.push([new RegExp(pattern,"g"),false])
            }
        }else{
            finalPatterns.push([pattern,false])
        }
    })

    return {        
        patterns:finalPatterns,
        basePath,
        test: (filename) => {
            let isMatched = false
            let file = filename
            // 如果指定basePath，则文件名称必须是以basePath开头
            if(basePath){
                if(path.isAbsolute(file)){
                    if(!path.normalize(file).startsWith(basePath)){
                        return  debug ? [false,`!^${basePath}`] : false
                    }else{
                        isMatched = true
                    }   
                }   
            }            
            if(finalPatterns.length===0){
                return debug ? [true,"*"] : true
            }else{                
                for(const pattern of finalPatterns){
                    pattern[0].lastIndex = 0
                    if(pattern[1]===true){
                        if(pattern[0].test(file)) return debug ? [false,pattern[0].toString()] : false
                    }else{
                        if(pattern[0].test(file)) return  debug ? [true,pattern[0].toString()] : true
                    }
                }
            }
            return debug ? [isMatched,"*"] : isMatched
        }
    }
}

/**
 * 以floder为基准向上查找文件package.json，并返回package.json所在的文件夹
 * @param {*} folder          起始文件夹，如果没有指定，则取当前文件夹
 * @param {*} exclueCurrent   如果=true，则folder的父文件夹开始查找
 * @returns 
 */
function getProjectRootFolder(folder="./",exclueCurrent=false){
    if(!path.isAbsolute(folder)){
        folder = path.join(process.cwd(),folder)
    }
    try{ 
        const pkgFile =exclueCurrent ? 
                        path.join(folder, "..", "package.json")
                        : path.join(folder, "package.json")
        if(fs.existsSync(pkgFile)){ 
            return path.dirname(pkgFile)
        }
        const parent = path.dirname(folder)
        if(parent===folder) return null
        return getProjectRootFolder(parent,false)
    }catch(e){
        return process.cwd()
    }
}


/**
 * 自动获取当前项目的languages
 * 
 * 1. 
 * 
 * @param {*} location 
 */
 function getProjectLanguageFolder(location="./"){
    // 绝对路径    
    if(!path.isAbsolute(location)){   
        location = path.join(process.cwd(),location)
    }    

    // 发现当前项目根目录
    const projectRoot = getProjectRootFolder(location)

    const searchFolders = [
        path.join(location,"src","languages"),
        path.join(location,"languages")
    ]

    for(let folder of searchFolders){
        if(fs.existsSync(folder)){
            return folder
        }
    }
 
    return null
}




/**
 * 根据当前输入的文件夹位置自动确定源码文件夹位置
 * 
 * - 如果没有指定，则取当前文件夹
 * - 如果指定是非绝对路径，则以当前文件夹作为base
 * - 查找pack
 * - 如果该文件夹中存在src，则取src下的文件夹
 * -
 * 
 * @param {*} location 
 * @returns 
 */
 function getProjectSourceFolder(location){
    if(!location) {
        location = process.cwd()
    }else{
        if(!path.isAbsolute(location)){
            location = path.join(process.cwd(),location)
        }
    }
    let projectRoot = getProjectRootFolder(location)
    // 如果当前工程存在src文件夹，则自动使用该文件夹作为源文件夹
    if(fs.existsSync(path.join(projectRoot,"src"))){
        projectRoot = path.join(projectRoot,"src")
    }
    return projectRoot
}


/**
 * 读取指定文件夹的package.json文件，如果当前文件夹没有package.json文件，则向上查找
 * @param {*} folder 
 * @param {*} exclueCurrent    = true 排除folder，从folder的父级开始查找
 * @returns 
 */
 function getCurrentPackageJson(folder,exclueCurrent=true){ 
    let projectFolder = getCurrentProjectRootFolder(folder,exclueCurrent)
    if(projectFolder){
       return fs.readJSONSync(path.join(projectFolder,"package.json"))
    }
}

/**
 * 
 * 返回当前项目的模块类型
 * 
 * 从当前文件夹开始向上查找package.json文件，并解析出语言包的类型
 * 
 * @param {*} folder 
 */
 function findModuleType(folder){
    let packageJson = getCurrentPackageJson(folder)
    try{ 
        return packageJson.type || "commonjs"
    }catch(e){
        return "esm"
    }
}

/**
 * 判断是否已经安装了依赖
 * 
 * isInstallDependent("@voerkai18n/runtime")
 * 
*/
function isInstallDependent(url){
    try{
        // 简单判断是否存在该文件夹node_modules/@voerkai18n/runtime
        let projectFolder =  getCurrentProjectRootFolder(process.cwd())
        if(fs.existsSync(path.join(projectFolder,"node_modules","@voerkai18n/runtime"))){
            return true
        }
        // 如果不存在，则尝试require
        require(url)
    }catch(e){
        return false
    }
}

/**
 * 判断是否是JSON对象
 * @param {*} obj 
 * @returns 
 */
function isPlainObject(obj){
    if (typeof obj !== 'object' || obj === null) return false;
    var proto = Object.getPrototypeOf(obj);
    if (proto === null) return true;
    var baseProto = proto;

    while (Object.getPrototypeOf(baseProto) !== null) {
        baseProto = Object.getPrototypeOf(baseProto);
    }
    return proto === baseProto; 
}

function isNumber(value){
    return !isNaN(parseInt(value))
}
 
/**
 * 检测当前工程是否是git工程
 */
 function isGitRepo(){
    return shelljs.exec("git status", {silent: true}).code === 0;
}

/**
 * 简单进行对象合并
 * 
 * options={
 *    array:0 ,        // 数组合并策略，0-替换，1-合并，2-去重合并
 * }
 * 
 * @param {*} toObj 
 * @param {*} formObj 
 * @returns 合并后的对象
 */
function deepMerge(toObj,formObj,options={}){
    let results = Object.assign({},toObj)
    Object.entries(formObj).forEach(([key,value])=>{
        if(key in results){
            if(typeof value === "object" && value !== null){
                if(Array.isArray(value)){
                    if(options.array === 0){
                        results[key] = value
                    }else if(options.array === 1){
                        results[key] = [...results[key],...value]
                    }else if(options.array === 2){
                        results[key] = [...new Set([...results[key],...value])]
                    }
                }else{
                    results[key] = deepMerge(results[key],value,options)
                }
            }else{
                results[key] = value
            }
        }else{
            results[key] = value
        }
    })
    return results
}


/**
 * 获取指定变量类型名称
 * getDataTypeName(1) == Number
 * getDataTypeName("") == String
 * getDataTypeName(null) == Null
 * getDataTypeName(undefined) == Undefined
 * getDataTypeName(new Date()) == Date
 * getDataTypeName(new Error()) == Error
 * 
 * @param {*} v 
 * @returns 
 */
 function getDataTypeName(v){
	if (v === null)  return 'Null' 
	if (v === undefined) return 'Undefined'   
    if(typeof(v)==="function")  return "Function"
	return v.constructor && v.constructor.name;
};


 
/**
 * 在当前工程自动安装@voerkai18n/runtime
 * @param {*} srcPath 
 * @param {*} opts 
 */
 function installVoerkai18nRuntime(srcPath){
    const projectFolder =  getCurrentProjectRootFolder(srcPath || process.cwd())
    if(fs.existsSync("pnpm-lock.yaml")){
        shelljs.exec("pnpm add @voerkai18n/runtime")
    }else if(fs.existsSync("yarn.lock")){
        shelljs.exec("yarn add @voerkai18n/runtime")
    }else{
        shelljs.exec("npm install @voerkai18n/runtime")
    }
}   


/**
 * 在指定文件夹下创建package.json文件
 * @param {*} targetPath 
 * @param {*} moduleType 
 * @returns 
 */
function createPackageJsonFile(targetPath,moduleType="auto"){
    if(moduleType==="auto"){
        moduleType = findModuleType(targetPath)
    }
    const packageJsonFile = path.join(targetPath, "package.json")
    if(["esm","es","module"].includes(moduleType)){
        fs.writeFileSync(packageJsonFile,JSON.stringify({type:"module",license:"MIT"},null,4))
        if(moduleType==="module"){
            moduleType = "esm"
        }
    }else{
        fs.writeFileSync(packageJsonFile,JSON.stringify({license:"MIT"},null,4))
    }
    return moduleType
}


module.exports = {
    fileMatcher,                            // 文件名称匹配器
    getProjectRootFolder,                  // 查找获取项目根目录
    createPackageJsonFile,                  // 创建package.json文件
    getProjectSourceFolder,                 // 获取项目源码目录
    getCurrentPackageJson,                  // 查找获取当前项目package.json
    getProjectLanguageFolder,               // 获取当前项目的languages目录
    findModuleType,                         // 获取当前项目的模块类型 
    isInstallDependent,                     // 判断是否已经安装了依赖
    installVoerkai18nRuntime,               // 在当前工程自动安装@voerkai18n/runtime
    isPlainObject,                          // 判断是否是普通对象
    isNumber,                               // 判断是否是数字
    deepMerge,                              // 深度合并对象
    getDataTypeName,                        // 获取指定变量类型名称
    isGitRepo,                              // 判断当前工程是否是git工程
}