export class Model2Object{
    /**
     * 转换
     * @param modelPath -   模型路径
     * @returns             model 集合
     */
    public static gen(modelPath){
        const me = this;
        const fsMdl = require('fs');
        const pathMdl = require('path');
        
        const models = {};
        if(!fsMdl.existsSync(modelPath)){
            throw new Error('模型路径不存在')
        }
        handleDir(modelPath);
        return models;    
        /**
         * 处理目录
         * @param path 
         */
        function handleDir(path){
            let dirArr = fsMdl.readdirSync(path,{withFileTypes:true});
            for (const dirent of dirArr) {
                const p = pathMdl.resolve(modelPath,dirent.name);
                if(dirent.isDirectory()){
                    handleDir(p);
                }else if(dirent.name.endsWith('.ts')){  //只处理ts文件
                    const cfg = me.getModel(p);
                    if(cfg){
                        //TODO 通过export class 拾取
                        models['Mdl' + cfg['ref']] = cfg;
                    }
                }
            }
        }
    }

    /**
     * 处理一个模型文件
     * @param modelPath -   模型文件路径 
     * @returns             模型配置   
     */
    public static getModel(modelPath){
        const fsMdl = require('fs');
        let fileStr = fsMdl.readFileSync(modelPath,{encoding:'utf8'});
        //model判断正则式
        const modelReg = /@AMModel\s*\(\s*\{[\s\S]+?\}\s*\)/;
        
        //属性抽取正则式
        const propReg = /@AMProp\s*\(\s*\{[\s\S]+?\}\s*\)/;
        
        //不是model文件，则不处理
        let r = modelReg.exec(fileStr);
        if(!r){
            return;
        }
        //处理模型
        let modelCfg = this.handleModel(r[0]);
        modelCfg.props = [];
        fileStr = fileStr.substring(r.index + r[0].length);
        
        //处理属性
        while(fileStr !== ''){
            r = propReg.exec(fileStr);
            if(!r){
                break;
            }
            fileStr = fileStr.substring(r.index + r[0].length+1);
            if(r){
                const prop = this.handleProp(r[0],fileStr);
                if(prop.isId){
                    modelCfg.idProp = prop;
                }
                modelCfg.props.push(prop);
            }
        }
        return modelCfg;
    }

    /**
     * 处理模型
     * @param modelStr -    模型配置串
     * @retuns              模型配置
     */
    private static handleModel(modelStr){
        modelStr = modelStr.replace(/@AMModel\s*\(/,'');
        modelStr = modelStr.substring(0,modelStr.length-1);
        return require('json5').parse(modelStr);
    }

    /**
     * 处理属性
     * @param propStr -     属性串
     * @param fileStr -     文件串
     * @returns             属性配置
     */
    private static handleProp(propStr,fileStr){
        propStr = propStr.replace(/@AMProp\s*\(/,'');
        propStr = propStr.substring(0,propStr.length-1);
        // console.log(propStr);
        const cfg = require('json5').parse(propStr);
        const index = fileStr.indexOf('\n');
        if(index === -1){
            throw new Error('属性格式错误');
        }
        let a = fileStr.substring(0,index).trim().split(/\s+/);
        let name;
        if(a[a.length-1] === ';'){
            name = a[a.length-2];
        }else{
            name = a[a.length-1];
            name = name.replace(';','').trim();
        }
        cfg.name = name;
        return cfg;
    }
}