/**
 * 通过excel生产model的生成器
 */
export class ExcelModelGenerator{
    pathMdl:string;
    /**
     * 生成方法
     * @param excelPath -   excel路径   
     * @param dst -         目标路径
     */
    public gen(excelPath:string,dst:string){
        //读excel
        const xlsx = require('node-xlsx');
        const sheets = xlsx.parse(excelPath);
        if(!sheets ||sheets.length === 0){
            return;
        }
        this.parse(sheets,dst);
    }

    private parse(sheets,dst){
        const modelMap = new Map<string,{model,props,id}>();
        // 模型匹配对象
        const modelMatch = {
            "模型":"modelName",
            "显示名":"showName",
            "是否需要管理":"manageable",
            "是否需要编辑":"editable",
            "是否为条件":"isCond",
            "是否为数据":"isData",
            "lable宽度":"labelWidth",
            "每行列数":"colsInRow",
            "编辑项宽度":"editWidth"
        }

        /**
         * 属性匹配对象
         */
        const propMatch = {
            "属性":"propName",
            "显示名":"showName",
            "是否主键":'isId',
            "类型":"type",
            "是否可编辑":"editable",
            "编辑类型":"editType",
            "编辑项":"editOption",
            "数据校验":"validator",
            "数据单位":"unit",
            "默认值":"defaultValue",
            "表格显示宽度":"width",
            "是否在引用中显示":"showInRef",
            "是否在表格中显示":"showInGrid",
            "是否在详情中显示":"showInDetail",
            "是否作为查询项":"showInQuery",
            "加密方式":"encryption",
            "引用模型":"ref",
            "是否多选":"multi",
            "引用显示属性集合":"displayProp",
            "是否使用系统时间":"useSystemTime",
            "是否使用登录账户":"useLogonUser"
        }
        for(const sheet of sheets){
            //填表说明不处理
            if(sheet.name === '填表说明'){
                continue;
            }
            const mdlCfg = this.handleModel(sheet,modelMatch);
            const propCfg = this.handleProp(sheet,propMatch);
            if(!mdlCfg || !propCfg){
                continue;
            }
            //条件模型，增加 dataimport
            if(mdlCfg['isCond']){
                propCfg.props.push({
                    propName:'amDataImport',
                    showName: "导入批次",
                    showInGrid: false,
                    showInDetail: false,
                    editable: false,
                    type:'ref',
                    ref: "AmDataImport"
                })
            }
            if(!propCfg.id){
                throw new Error('主键不能为空');
            }
            if(propCfg.props.length === 0){
                throw new Error('属性不能为空');
            }
            modelMap.set(mdlCfg['modelName'],{model:mdlCfg,props:propCfg.props,id:propCfg.id['propName']});    
        }
        this.genModelStr(modelMap,dst);
    }

    /**
     * 处理模型
     * @param sheet -       excel sheet
     * @param modelMatch -  模型匹配项
     * @returns             模型配置项
     * 
     */
    private handleModel(sheet,modelMatch):object|undefined{
        let datas = sheet.data[0];
        if(!datas){
            return;
        }
        //处理配置项名
        const modelFields:any[] = [];
        for(let d of datas){
            d = d.trim();
            modelFields.push(modelMatch[d]);
        }
        datas = sheet.data[1];
        if(!datas){
            return;
        }
        const modelCfg = {};
        //处理配置项名
        for(let i=0;i<datas.length;i++){
            const fn = modelFields[i];
            let d = datas[i];
            if(!fn){
                continue;
            }

            if(typeof d === 'string'){
                d = d.trim();
            }
            if(d === undefined){
                continue;
            }
            modelCfg[<string>fn] = d;
        }
        if(!modelCfg['labelWidth']){
            modelCfg['labelWidth'] = 100;
        }
        return modelCfg;
    }

    /**
     * 处理属性集合
     * @param sheet -       excel sheet
     * @param propMatch -   属性匹配项
     * @returns             主键和属性数组对象
     */
    private handleProp(sheet,propMatch):{id:object,props:object[]}|undefined{
        let datas = sheet.data[3];
        if(!datas){
            return;
        }
        //处理配置项名
        const propFields:string[] = [];
        for(let d of datas){
            d = d.trim();
            propFields.push(propMatch[d]);
        }
        let idProp;
        const props:object[] = [];
        let index=4;
        //处理配置项名
        while((datas = sheet.data[index++])){
            //数据项不足
            if(datas.length === 0 || datas[0] === '' || datas[0] === undefined){
                break;
            }
            const obj = {};
            for(let i=0;i<datas.length;i++){
                const fn = propFields[i];
                let d = datas[i];
                if(!fn){
                    continue;
                }

                if(typeof d === 'string'){
                    d = d.trim();
                }
                if(d === undefined){
                    continue;
                }
                obj[fn] = d;
            }
            if(Object.keys(obj).length === 0){
                continue;
            }
            if(obj['isId']){
                idProp = obj;
            }
            props.push(obj);
        }
        
        return {id:idProp,props:props};
    }

    /**
     * 构建并写模型文件
     * @param modelMap -    模型map
     * @param dstPath -     目标路径
     */
    private genModelStr(modelMap,dstPath:string){
        const fsMdl = require('fs');
        const pathMdl = require('path');
        const prettier = require('prettier');
        //目录不存在，则创建
        if(!fsMdl.existsSync(dstPath)){
            fsMdl.mkdirSync(dstPath,{recursive:true})
        }
        //写文件
        for(let [key,cfg] of modelMap){
            const mdlCfg = cfg.model;
            //保留模型名
            const mdlName = mdlCfg['modelName'];
            //设置模型ref
            mdlCfg['ref'] = mdlName;
            //删除多余配置项
            delete mdlCfg['modelName'];
            
            const propArr:string[] = [];
            for(let prop of cfg.props){
                const propName = prop['propName'];
                delete prop['propName'];
                if(!prop['type']){
                    prop['type'] = 'string';
                }
                if(prop['validator']){
                    prop['validator'] = prop['validator'].split('|')
                }

                let editOption;
                //TODO radio 时需要处理
                // if(prop['editType']) {
                //     editOption = {type:prop['editType']}
                // }else{
                    switch(prop['type']){
                        case 'int':
                            editOption = {type:"number"};
                            break;
                        case 'double':
                            editOption = {type:"number"};
                            break;
                        case 'float':
                            editOption = {type:"number"};
                            break;
                        case 'file': //文件
                            prop['type'] = 'ref';
                            prop['ref'] = 'MdlAmFile';
                            editOption = {
                                type: "file"
                            };
                            break;
                        case 'ref': //引用类型
                            if(!['AmFile','AmDataImport'].includes(prop['ref']) && !modelMap.has(prop['ref'])){
                                throw new Error('引用模型找不到');
                            }
                            const mdl = modelMap.get(prop['ref']);
                            if(mdl){
                                const valueProp = mdl.id;
                                editOption = {
                                    type:'select',
                                    option:{
                                        multi:prop['multi'], 
                                        refModel:'Mdl' + prop['ref'],
                                        valueProp:valueProp,
                                        displayProp:prop['displayProp']
                                    }
                                }
                            }
                            prop['type'] = 'ref';
                            prop['ref'] = 'Mdl' + prop['ref'];
                            delete prop['editType'];
                            delete prop['displayProp'];
                            delete prop['multi'];
                            break;
                        default:
                            editOption = {type:prop['editType']||"text"};
                    }
                // }
                //对editOption 进行处理
                if(prop['editOption']){
                    editOption.option = new Function(`return(${prop['editOption']})`)();
                }
                prop.editOption = editOption;
                propArr.push(`
                    @AMProp(${JSON.stringify(prop)})
                    public ${propName};
                `)
            }

            let modelStr = `
                import {AmModel,AmProp} from 'amcode';
                @AMModel(${JSON.stringify(mdlCfg)})
                export class Mdl${mdlName} {
                    ${propArr.join('\r\n')}
                }
            `;
            const path = pathMdl.resolve(dstPath,'mdl' + mdlName.toLowerCase() + '.ts');
            //美化
            modelStr = prettier.format(modelStr,{tabWidth: 4, parser: "typescript",trailingComma:'none'});
            //写文件
            fsMdl.writeFileSync(path,modelStr);
        }
    }
}