import * as path from 'path';
import * as fs from 'fs';
export class FileUtils
{
        
    //获取绝对路径
    static  getAbsolutePath(url) 
    {
        if (!path.isAbsolute(url)) {
            url = path.join(process.cwd(), url);
        }
        return path.normalize(url)
    }

    // 是否是文件夹
    static  isFile(url)
    {
        if(fs.existsSync(url))
        {
            var stat = fs.lstatSync(url);
            return stat.isFile();
        }
        return false;
    }

    // 是否是文件夹
    static  isDirectory(url)
    {
        if(fs.existsSync(url))
        {
            var stat = fs.lstatSync(url);
            return stat.isDirectory();
        }
        return false;
    }

    // 获取父级路径
    static  getDirPath(url)
    {
        if (!path.isAbsolute(url)) 
        {
            url = this.getAbsolutePath(url);
        }
        return path.dirname(url)
    }

    // 检查父级目录是否存在，不存在就创建
    static  checkDirPath(url)
    {
        var dirPath = this.getDirPath(url);
        if(!fs.existsSync(dirPath))
        {
            // console.log("mkdir", dirPath);
            fs.mkdirSync(dirPath, {recursive: true});
        }
    }

    // 创建目录
    static  mkdir(srcPath)
    {
        if(!fs.existsSync(srcPath))
        {
            // console.log("mkdir", srcPath);
            fs.mkdirSync(srcPath, {recursive: true});
        }
    }

    // 拷贝文件
    static  copy(srcPath, destPath, isOver=true, isIgnoreHide = true)
    {
        srcPath = this.getAbsolutePath(srcPath);
        destPath = this.getAbsolutePath(destPath);
        if(srcPath == destPath)
        {
            console.warn("拷贝路径一样", srcPath);
            return;
        }

        if(!fs.existsSync(srcPath))
        {
            console.warn("文件不存在:", srcPath);
            return;
        }


        var stat = fs.lstatSync(srcPath);
        if(stat.isFile())
        {
            this.copyFile(srcPath, destPath, isOver);
        }
        else
        {
            var paths = fs.readdirSync(srcPath); //同步读取当前目录
            for(var i = 0, len = paths.length; i < len; i ++)
            {
                var name = paths[i];
                if(isIgnoreHide)
                {
                    if(name.startsWith("."))
                    {
                        continue;
                    }
                }
                var itemSrc = path.join(srcPath, name);
                var itemDest = path.join(destPath, name);
                var stat = fs.lstatSync(itemSrc);
                if(stat.isFile())
                {

                    // console.log("file itemSrc", itemSrc, "    ", itemDest);
                    this.copyFile(itemSrc, itemDest, isOver);
                }
                else if(stat.isDirectory())
                {
                    if(itemDest.startsWith(itemSrc))
                    {
                        console.warn("拷贝路径嵌套死循环", itemSrc, "   ", itemDest);
                        continue;
                    }
                    this.copy(itemSrc, itemDest, isOver, isIgnoreHide);

                }

            }

        }

    }

    static  copyFile(srcPath, destPath, isOver)
    {
        if(isOver)
        {
            if(fs.existsSync(destPath))
            {
                fs.unlinkSync(destPath);
            }
            
            this.checkDirPath(destPath);
            fs.copyFileSync(srcPath, destPath);
        }
        else if(!fs.existsSync(destPath))
        {
            this.checkDirPath(destPath);
            fs.copyFileSync(srcPath, destPath);
        }
        // let  readable=fs.createReadStream(srcPath);//创建读取流
        // let  writable=fs.createWriteStream(destPath);//创建写入流
        // readable.pipe(writable);
    }

    // 删除文件或者目录
    static  deleteFileOrDir(srcPath)
    {
        
        if(!fs.existsSync(srcPath))
        {
            console.warn("文件不存在:", srcPath);
            return;
        }


        var stat = fs.lstatSync(srcPath);
        if(stat.isFile())
        {
            fs.unlinkSync(srcPath);
        }
        else if(stat.isDirectory())
        {
            var paths = fs.readdirSync(srcPath); //同步读取当前目录
            for(var i = 0, len = paths.length; i < len; i ++)
            {
                var name = paths[i];
                var itemSrc = path.join(srcPath, name);
                var stat = fs.lstatSync(itemSrc);
                if(stat.isFile())
                {
                    fs.unlinkSync(itemSrc);
                }
                else if(stat.isDirectory())
                {
                    this.deleteFileOrDir(itemSrc);
                }
            }
            fs.rmdirSync(srcPath);
        }
    }

    // 写入文件
    static  write(srcPath, body,  flag="w", encoding="utf8")
    {
        this.checkDirPath(srcPath);
        fs.writeFileSync(srcPath, body, {flag: flag, encoding:<any>encoding});
    }

    // 读取文件
    static  read(srcPath, encoding="utf8", flag="a", )
    {
        if(!fs.existsSync(srcPath))
        {
            return "";
        }
        return fs.readFileSync(srcPath,  { encoding: <any>encoding, flag: flag })
    }

    // 重命名
    static  rename(srcPath, destPath, isOver = true)
    {
        if(!fs.existsSync(srcPath))
        {
            console.error("文件不存在 srcPath:", srcPath);
            return;
        }
        
        if(!isOver)
        {
            if(fs.existsSync(destPath))
            {
                console.error("目标文件已经存在 destPath:", destPath);
                return;
            }
        }
        
        this.checkDirPath(destPath);
        fs.renameSync(srcPath, destPath);
    }

    static contrastCleaningAskHas: boolean = false;
    static contrastCleaningAskResult: boolean = false;

    static async checkContrastCleaningAsk(filePath?: string): Promise<Boolean>
    {
        return new Promise((resolve)=>{
            if(this.contrastCleaningAskHas)
            {
                resolve( this.contrastCleaningAskResult);
                return;
            }
    
            process.stdout.write("有可能删除过fgui组件，是否清理代码？\n");
            if(filePath) process.stdout.write(filePath + "\n");
            process.stdout.write("确认执行吗(y/n)？");
            process.stdin.on('data',(input)=>
            {
                this.contrastCleaningAskHas = true;
                var inputStr = input.toString().trim();
                if (['Y', 'y', 'YES', 'yes'].indexOf(inputStr) > -1)
                {
                    this.contrastCleaningAskResult = true;
                    resolve( this.contrastCleaningAskResult);
                }
                else
                {
                    this.contrastCleaningAskResult = false;
                    resolve( this.contrastCleaningAskResult);
                    // process.exit(0);
                }
            })
        })
        
    }

    // 对比清理，清理的是srcPath
    static async contrastCleaning(srcPath, destPath, isIgnoreHide = true, isAsk=false)
    {

        srcPath = this.getAbsolutePath(srcPath);
        destPath = this.getAbsolutePath(destPath);
        if(srcPath == destPath)
        {
            console.warn("清理路径一样", srcPath);
            return;
        }

        if(!fs.existsSync(srcPath))
        {
            console.warn("文件不存在:", srcPath);
            return;
        }


        var stat = fs.lstatSync(srcPath);
        if(stat.isFile())
        {
            console.warn("文件不能对比清理:", srcPath);
        }
        else
        {
            var paths = fs.readdirSync(srcPath); //同步读取当前目录
            for(var i = 0, len = paths.length; i < len; i ++)
            {
                var name = paths[i];
                if(isIgnoreHide)
                {
                    if(name.startsWith("."))
                    {
                        continue;
                    }
                }

                var itemSrc = path.join(srcPath, name);
                var itemDest = path.join(destPath, name);
                var stat = fs.lstatSync(itemSrc);
                if(stat.isFile())
                {
                    // dest文件不存在，就删除src文件
                    if(!fs.existsSync(itemDest))
                    {
                        if(isAsk)
                        {
                            var  isContinue = await this.checkContrastCleaningAsk(itemSrc);
                            if(!isContinue)
                            {
                                return;
                            }
                        }
                        console.log('删除', itemSrc);
                        fs.unlinkSync(itemSrc);
                    }
                }
                else if(stat.isDirectory())
                {
                    if(itemDest.startsWith(itemSrc))
                    {
                        console.warn("清理路径嵌套死循环", itemSrc, "   ", itemDest);
                        continue;
                    }
                    await this.contrastCleaning(itemSrc, itemDest, isIgnoreHide, isAsk);
                    if(isAsk && this.contrastCleaningAskHas && !this.contrastCleaningAskResult)
                    {
                        return;
                    }
                }

            }

            
            var paths = fs.readdirSync(srcPath); //同步读取当前目录
            if(paths.length == 0)
            {
                fs.rmdirSync(srcPath);
            }

        }

    }
}