import { AMModelManager } from "./modelmanager";

/**
 * 产生各种数据sql，包括：菜单、数据类型等
 */
export class AMDataGenerator{
    /**
     * 基础存储路径
     */
    private baseSavePath:string;

    /**
     * 构造器
     * @param savePath  保存路径
     */
    constructor(savePath:string){
        const fsMdl = require('fs');
        this.baseSavePath = savePath;
        //目录不存在则创建目录
        if(!fsMdl.existsSync(this.baseSavePath)){
            fsMdl.mkdirSync(this.baseSavePath,{recursive:true});
        }

        let path = require('path').resolve(this.baseSavePath,'data.sql');
        
        let sqlArr:string[] = [];
        sqlArr = sqlArr.concat(this.genUser());
        // sqlArr = sqlArr.concat(this.genMenu(menuPath));
        sqlArr = sqlArr.concat(this.genDataType());
        sqlArr = sqlArr.concat(this.genModelData());
        sqlArr = sqlArr.concat(this.genOrgCond());
        sqlArr = sqlArr.concat(this.genResource());
        //写文件
        fsMdl.writeFileSync(path, sqlArr.join('\r\n'),'utf8');
    }

    /**
     * 生成用户数据sql
     * @returns 
     */
    public genUser():string[]{
        let sqlArr:string[] = [];
        sqlArr.push('###user');
        // sqlArr.push("DELETE FROM AM_GROUP WHERE GROUP_ID=1;");
        // sqlArr.push("DELETE FROM AM_USER WHERE USER_ID=1;");
        sqlArr.push("INSERT INTO AM_GROUP(GROUP_ID,GROUP_NAME) values (1,'admin');");
        sqlArr.push("INSERT INTO AM_USER(USER_ID,USER_NAME,PWD) values (1,'admin','123456');");
        sqlArr.push("INSERT INTO AM_GROUP_USER(ID_,GROUP_ID,USER_ID) values(1,1,1);");
        sqlArr.push("INSERT INTO AM_AUTHORITY(AUTHORITY_ID,AUTHORITY) values(1,'ROLE_ADMIN');");
        return sqlArr;
    }

    /**
     * 生成菜单数据sql
     * @param path 
     * @returns 
     */
    public genMenu(path:string):string[]|undefined{
        const fsMdl = require('fs');
        let sqlArr:string[] = [];
        //删除>10的menu（自动产生）
        sqlArr.push("###menudata");
        // sqlArr.push("DELETE FROM AM_MENU WHERE MENU_ID > 10;");
        //生成menu从11开始
        let menuId = 11;
        // form生成
        if(!fsMdl.existsSync(path)){
            return;
        }
        let config = JSON.parse(require('fs').readFileSync(path));
        gen(config.menus);

        return sqlArr;
        
        /**
         * 创建菜单
         * @param config    配置项或子菜单
         * @param id        菜单id
         */
        function gen(menus,id?){
            for(let menu of menus){
                if(menu.url){
                    sqlArr.push(`INSERT INTO AM_MENU(MENU_ID,MENU_NAME,MENU_URL,PARENT_ID) values(${menuId++},'${menu.menu}','${menu.mdl}',${id||'NULL'});`);
                }else{
                    sqlArr.push(`INSERT INTO AM_MENU(MENU_ID,MENU_NAME,MENU_URL,PARENT_ID) values(${menuId++},'${menu.menu}',NULL,${id||'NULL'});`);
                }
                
                if(menu.menus){
                    gen(menu.menus,menuId-1);
                }
            }
        }
    }

    /**
     * 创建数据类型相关数据
     * @returns 
     */
    public genDataType():string[]{
        let sqlArr:string[] = [];
        sqlArr.push('###datatype');
        // sqlArr.push("DELETE FROM AM_DATA_TYPE;");
        let index = 1;
        //页面代码
        for(let mdl of AMModelManager.modelMap){
            if(!mdl[1].isData){
                continue;
            }
            sqlArr.push(`INSERT INTO AM_DATA_TYPE(DATA_TYPE_ID,TYPE_NAME,REF_ENTITY) values (${index++},'${mdl[1].showName}','${mdl[0].substring(3)}');`);
        }
        return sqlArr;
    }

    /**
     * 创建数据组织条件
     */
    public genOrgCond():string[]{
        let index = 1;
        let pArr:any[] = [];
        const sqlArr = ['###org cond'];

        for(let mdl of AMModelManager.modelMap){
            if(mdl[1].isCond){
                for(let p of mdl[1].props){
                    if(p.ref && !isManyToMany(p)){
                        genOne(AMModelManager.getModel(p.ref),p.name);
                    }
                }
                break;
            }
        }

        for(let a of pArr){
            if(['AmFile','AmFileType','AmDataImport'].includes(a[2])){
                continue;
            }
            sqlArr.push(`INSERT INTO AM_ORG_COND(ORG_COND_ID,SHOW_NAME,ENTITY,PROP_NAME,REL_NAME,IS_CASCADE) values (
                ${a[0]},'${a[1]}','${a[2]}','${a[3]}','${a[4]}',${a[5]});`);
        }

        return sqlArr;

        function genOne(cls,pName){
            if(['AmImportTemplate'].includes(cls.ref) || pArr.find(item=>item[2] === cls.ref)){
                return;
            }
            genSql(cls,pName);
            for(let p of cls.props){
                //外键，且有showName
                if(p.ref){
                    const cls1 = AMModelManager.getModel(p.ref);
                    if(p.ref === cls.name){  //外键即主键(1:1)
                        genSql(cls1,null,1);
                    }else{
                        if(!isManyToMany(p)){
                            genOne(cls1,pName +'.' + p.name);
                        }
                    }
                }
            }
        }

        /**
         * 创建sql
         * @param cls   类
         * @param type  是否为级联对象
         */
        function genSql(cls,pName,type?:number){
            if(!cls){
                return;
            }
            if(type){  //为1:1，增加isCascade属性
                let d:any = pArr.find(item=>item[2] === cls.ref);
                if(d){
                    d[5] = 1;
                }
            }else{
                const showProp = cls.props.find(item=>item.showInRef);
                if(showProp){
                    pArr.push([index++,cls.showName,cls.ref,showProp.name,pName,0]); 
                }
            }
        }

        /**
         * 是否多对多关心
         * @param prop 
         * @returns 
         */
        function isManyToMany(prop):boolean{
            const opt = prop.editOption;
            return opt && (opt.type === 'new' || opt.type === 'transfer' || opt.option && opt.option.multi);
        }
    }

    /**
     * 创建模型数据
     */
    public genModelData(){
        const sqlArr = ['###model and prop'];
        // sqlArr.push("DELETE FROM AM_MODEL;");
        // sqlArr.push("DELETE FROM AM_PROPERTY;");
        let modelId = 1;
        let propId = 1;

        //条件模型名
        let condName;
        for(let mdl of AMModelManager.modelMap){
            //实体
            sqlArr.push(`INSERT INTO AM_MODEL(MODEL_ID,MODEL_NAME,SHOW_NAME,REF_ENTITY,IS_DATA,IS_COND,IS_STATUS,EDITABLE,MANAGABLE) values (
                ${modelId},'${mdl[1].name}','${mdl[1].showName}','${mdl[1].ref}',
                ${mdl[1].isData?1:0},${mdl[1].isCond?1:0},${mdl[1].isStatus?1:0},${mdl[1].editable?1:0},${mdl[1].managable?1:0});`);
            //属性
            for(let p of mdl[1].props){
                let validatorStr;
                if(p.validator){
                    validatorStr = typeof p.validator === 'object'?JSON.stringify(p.validator):p.validator;
                }
                let editStr;
                if(p.editOption){
                    editStr = typeof p.editOption === 'object'?JSON.stringify(p.editOption):p.editOption;
                }
                
                sqlArr.push(`INSERT INTO AM_PROPERTY(PROP_ID,MODEL_ID,PROP_NAME,SHOW_NAME,
                    PROP_TYPE,REF_MODEL,IS_ID,EDITABLE,
                    USE_SYSTEM_TIME,USE_LOGON_USER,EDIT_OPTION,
                    VALIDATOR,WIDTH,SHOW_IN_REF,SHOW_IN_GRID,SHOW_IN_QUERY,
                    SHOW_IN_DETAIL,UNIT,DEFAULT_VALUE,ENCRYPTION) 
                    VALUES(
                        ${propId++},${modelId},'${p.name}','${p.showName}',
                        '${p.type}',${p.ref?"'"+p.ref+"'":null},${p.isId?1:0},${p.editable?1:0},
                        ${p.useSystemTime?1:0},${p.useLogonUser?1:0},${editStr?"'"+editStr+"'":null},
                        ${validatorStr?"'" + validatorStr + "'":null},${p.width||100},${p.showInRef?1:0},${p.showInGrid?1:0},${p.showInQuery?1:0},
                        ${p.showInDetail?1:0},${p.unit?"'"+p.unit+"'":null},${p.defaultValue?"'" + p.defaultValue + "'":null},${p.encryption?"'" + p.encryption + "'":null}
                    );
                `)
            }
            modelId++;
        }
        return sqlArr;
    }

    /**
     * 创建资源数据
     */
    genResource(){
        let sqlArr = ['###resource'];
        const infos:{t:string,url:string}[] = [];
        let id = 11;
        // sqlArr.push("DELETE FROM AM_RESOURCE WHERE RESOURCE_ID > 10;");
        for (let [name,cls] of AMModelManager.modelMap) {
            //数据和条件不处理
            if(cls.isData || cls.isCond){
                continue;
            }
            let arr:{t:string,u:string}[] = [];
            if(cls.editable){
                arr.push({
                    t:'编辑',
                    u:'save'
                });
                arr.push({
                    t:'查询详情',
                    u:'findbyid'
                });
                arr.push({
                    t:'综合查询',
                    u:'query'
                });
            }

            if(cls.manageable){
                arr.push({
                    t:'删除',
                    u:'delete'
                });
                //试验对象信息
                //  if(AMModelManager.getIdProp(cls.name).name === 'amTarget'){
                //     let name = cls.ref.toLowerCase();
                //     targets.push({
                //         t:cls.showName + '管理',
                //         url:`${name}/${name}main.js`
                //     });
                // }else 
                if(!cls.name.startsWith('MdlAm') && cls.name !== 'MdlNfDefProcess'){  //非am开头、流程、条件、数据
                    let name = cls.ref.toLowerCase();
                    infos.push({
                        t:cls.showName + '管理',
                        url:`${name}/${name}main.js`
                    });
                }
            }
            let url = '/' + cls.ref.toLowerCase() + '/';
            for(let d of arr){
                sqlArr.push(`INSERT INTO AM_RESOURCE(RESOURCE_ID,URL,TITLE) VALUES(
                    ${id},
                    '${url + d.u}',
                    '${cls.showName + d.t}'
                    );`
                );

                //所有资源给第一个权限（admin）
                sqlArr.push(`INSERT INTO AM_RESOURCE_AUTHORITY(RESOURCE_ID,AUTHORITY_ID) VALUES(
                    ${id},1
                );`);
                id++;
            }
        }
        sqlArr = sqlArr.concat(this.genBaseMenu(infos));
        return sqlArr;
    }

    /**
     * 生成菜单
     * @param targets   试验对象数组
     * @param infos     信息数组
     * @returns         菜单sql
     */
    genBaseMenu(infos){
        let menuArr:string[] = [];
        let menuId = 50;
        //一级菜单
        let firstMenu = [{t:'数据管理',menus:[
            {
                t:'数据概览',
                url:'__data/__base/__orgdatashow.js'
            },{
                t:'数据导入',
                url:'__data/__base/__dataimport.js'
            },{
                t:'模版管理',
                url:'amimporttemplate/amimporttemplatemain.js' 
            },{
                t:'概览管理',
                url:'amorgmode/amorgmodemain.js'
            },{
                t:'按类型查',
                url:'__data/__base/__amquery.js'
            },{
                t:'按条件查',
                url:'__data/__base/__amcondquery.js'
            }
        ]},{t:'通用配置',menus:[
            {
                t:'查询配置',
                url:'__base/amqueryconfig.js'
            },{
                t:'流程管理',
                url:'nfdefprocess/nfdefprocessmain.js'
            }
        ]},
        {t:'信息管理',menus:infos},
        {t:'安全管理',menus:[
            {
                t:'用户管理',
                url:'amuser/amusermain.js'
            },{
                t:'组管理',
                url:'amgroup/amgroupmain.js' 
            },{
                t:'权限管理',
                url:'amauthority/amauthoritymain.js' 
            },{
                t:'资源管理',
                url:'amresource/amresourcemain.js' 
            },{
                t:'菜单管理',
                url:'ammenu/ammenumain.js'
            }
        ]},{t:'其它',menus:[{
                t:'算法管理',
                url:'amalgorithm/amalgorithmmain.js' 
            },{
                t:'算法类型管理',
                url:'amalgorithmtype/amalgorithmtypemain.js' 
            },{
                t:'机构管理',
                url:'amcompany/amcompanymain.js'
            }
        ]}];
        for(let i=0;i<firstMenu.length;i++){
            menuArr.push(`INSERT INTO AM_MENU(MENU_ID,MENU_NAME) values('${i+1}','${firstMenu[i].t}');`);
            if(firstMenu[i].menus){
                for(let d of firstMenu[i].menus){
                    menuArr.push(`INSERT INTO AM_MENU(MENU_ID,MENU_NAME,MENU_URL,PARENT_ID) values(${menuId++},'${d.t}','${d.url}',${i+1});`);
                }
            }
        }
        return menuArr;
    }
}