import { AMModelManager } from "./modelmanager";
import { AmUtil } from "./util";
import {AMProp} from "./types";
import * as fsMdl from 'fs';
import * as pathMdl from 'path';

export class AMDataTypeGenerator{
    /**
     * 基础存储路径
     */
    private baseSavePath:string;

    /**
     * dataconfig对象
     * {
     *      cond:{entity,id,showName,fields}
     *      status:[{entity,id,showName}]
     *      datas:[{entity,id,showName,status,fields}]
     * }
     */
    private dataConfig:any;
    
    /**
     * 构造器
     * @param savePath 元数据存储路径
     */
    constructor(savePath:string){
        this.baseSavePath = savePath;
        //目录不存在则创建目录
        if(!fsMdl.existsSync(savePath)){
            fsMdl.mkdirSync(savePath,{recursive:true});
        }
    }
 
    /**
     * 创建元数据
     */
    public genData(){
        //数据实体名数组
        let dataEntities:string[] = [];
        // 数据模型数组
        let dataModels:any[] = [];
        //条件模型类
        let condCls;
        //条件对象
        let condObj;
        let statusArr = [];
        let dataTypeArr = [];
        for(let [name,cls] of AMModelManager.modelMap){
            if(cls.isCond){  //条件模型
                let id = AMModelManager.getIdProp(<string>name);
                condObj = {entity:cls.ref,id:id.name,showName:cls.showName,fields:this.getCondFields(cls)};
                condCls = cls;
            }else if(cls.isData) {
                dataEntities.push(<string>cls.ref);
                dataModels.push(cls);
                this.getTypeCfg(cls,statusArr,dataTypeArr);
                this.genDataGrid(cls);
            }
        }
        //保存dataconfig
        this.genDataConfig(condObj,statusArr,dataTypeArr);
        this.genStateConfig(statusArr,dataTypeArr);
        this.genImport(condCls);
        this.genDetail();
        // this.genOrgMode(condCls);
        this.genCondGrid();
    }

    /**
     * 产生条件字段
     * @param cls   cond class
     * @returns     
     */
    private getCondFields(cls){
        let fields = ['*'];
        for(let prop of cls.props){
            if(prop.ref){
                let f = prop.ref.substring(3);
                f = f.substring(0,1).toLowerCase() + f.substring(1);
                fields.push(f + '.*');
            }
        }
        //添加 数据import
        fields.push("amDataImport.amUser.*");
        return fields;
    }

    /**
     * 生成状态、数据配置
     * @param cls           data类
     * @param statusArr     状态数组
     * @param typeArr       数据类型数组
     * @returns     {cls:条件实体model类,prop:属性名}
     */
    private getTypeCfg(cls,statusArr,typeArr):any{
        let arr:{en:string,zh:string,type:string,width:number}[] = [];
        let statusName;
        for(let prop of cls.props){
            //不生成id属性
            if(prop.isId){
                continue;
            }
            if(prop.ref){ //状态
                const cls1 = AMModelManager.getModel(prop.ref);
                if(cls1.isCond){
                    continue;
                }
                const id = AMModelManager.getIdProp(cls1.name);
                cls1.isStatus = true;
                statusName = cls1.ref;
                if(!statusArr.find(item=>item.entity === cls1.ref)){
                    statusArr.push({entity:cls1.ref,id:id.name,showName:cls1.showName,fields:this.getStatusFields(cls1)});
                    //生成state grid
                    this.genStatusGrid(cls1);
                }
            }else if(AmUtil.getTsType(prop.type) === 'number'){
                arr.push({en:prop.name,zh:prop.showName,type:prop.type,width:prop.width});
            }
        }
        //数据类型id
        const id = AMModelManager.getIdProp(cls.name);
        //添加到数据类型数组
        typeArr.push({entity:cls.ref,id:id.name,showName:cls.showName,status:statusName,fields:arr});
    }

    /**
     * 获取状态非引用字段
     * @param cls   状态类
     * @returns 
     */
    private getStatusFields(cls){
        let arr:{en:string,zh:string,type:string,width:number}[] = [];
        for(let prop of cls.props){
            if(prop.ref || prop.isId){
                continue;
            }
            arr.push({en:prop.name,zh:prop.showName,type:prop.type,width:prop.width});
        }
        return arr;
    }

    /**
     * 创建数据config对象
     * @param cond      条件
     * @param status    状态数组
     * @param type      数据类型数组
     */
    private genDataConfig(cond,status,type){
        //写dataconfig文件
        const prettier = require('prettier');
        this.dataConfig = {
            cond:cond,
            status:status,
            datas:type
        }
        //美化
        let str = prettier.format('export const __AmDataConfig = ' + JSON.stringify(this.dataConfig),{tabWidth: 4, parser: "typescript",trailingComma:'none'});
        //写文件
        fsMdl.writeFileSync(pathMdl.resolve(this.baseSavePath,'__amdataconfig.js'), str);
        fsMdl.writeFileSync(pathMdl.resolve(this.baseSavePath,'__amdataconfig.ts'), str);
    }
    /**
     * 创建导入配置
     * @returns 
     */
    private genImport(condCls):any{
        //曲线轴坐标数据
        if(!condCls){
            return;
        }
        
        //放到其它参数中的条件字段串
        let otherFields:string[] = [];
        //条件非外键字段
        let condFields:string[] = [];
        //grid模块属组
        let gridArr:{title:string,cls:string}[] = [];
        // 表格外键条件属组
        let gridConds = {};
        
        for(let prop of condCls.props){
            if(!prop.editable){
                continue;
            }
            if(!prop.ref){
                otherFields.push(this.genInputStr(prop));
                condFields.push(prop.name);
            }else{  //外键
                const cls1 = AMModelManager.getModel(prop.ref);
                if(cls1){
                    gridArr.push({
                        title: cls1.showName,
                        cls:cls1.ref
                    });
                    gridConds[`M${prop.ref.substring(3)}Grid`] = {
                        title:prop.showName,
                        field:`${prop.name}.${AMModelManager.getIdProp(prop.ref).name}`,
                        notNull:prop.validator&&prop.validator.includes('require')
                    }
                }
            }
        }
        //外键字段，需要传给baseimport
        gridConds['MAmImportTemplateGrid'] = {
            title:'导入模版',
            field:'amImportTemplate.importTemplateId',
            notNull:true
        }

        //添加导入模版
        gridArr.push({title:'导入模版',cls:'AmImportTemplate'});
        //import 串
        let importStr = '';
        //表格相关模版串
        let gridTmpStr = '';
        let moduleArr:string[] = [];
        for(let g of gridArr){
            importStr += `import{M${g.cls}Grid} from '../../${g.cls.toLowerCase()}/${g.cls.toLowerCase()}grid.js';`;
            gridTmpStr += `
                <div class='import-item'>
                    <div class='title'>${g.title}</div>
                    <M${g.cls}Grid single/>
                </div>
            `
            moduleArr.push('M' + g.cls + 'Grid');
        }

        let template = `
            <div class='import'>
                ${gridTmpStr}
                <div class='import-item'>
                    <div class='title'>其它信息</div>
                    <ui-form x-model='other'>
                        ${otherFields.join('\r\n')}
                        <div class="ui-row">
                            <ui-form-item label="数据文件" field="file" require="true">
                                <ui-file
                                    width='200px'
                                    height="37.5px"
                                    field="file"
                                    value-field="fileId"
                                    display-field="fileName"
                                    url-field="downPath"
                                    upload-name="file"
                                    delete-url="/__file/delete"
                                    upload-url="/__file/upload" />
                            </ui-form-item>
                        </div>

                        <div class="ui-row">
                            <ui-form-item label="资源文件" field="resFile">
                                <ui-file
                                    height="37.5px"
                                    width='200px'
                                    field="resFile"
                                    value-field="fileId"
                                    display-field="fileName"
                                    url-field="downPath"
                                    upload-name="file"
                                    multiple='true'
                                    delete-url="/__file/delete"
                                    upload-url="/__file/upload"/>
                            </ui-form-item>
                        </div>
                        <div class='ui-row'>
                            <ui-form-item label='密级' field='publishType'>
                                <ui-radiogroup field='publishType'>
                                    <ui-radio value='1' title='公开' />
                                    <ui-radio value='2' title='机构内部公开' />
                                    <ui-radio value='3' title='不公开' />
                                </ui-radiogroup>
                            </ui-form-item>
                        </div>
                        <div class='ui-row'>
                            <ui-form-item label='备注' field='remarks'>
                                <textarea x-field='remarks' />
                            </ui-form-item>
                        </div>
                    </ui-form>
                </div>
            
                <ui-button-group>
                    <if cond={{__imported}}>
                        <ui-button title="上一步" e-click="prevStep" />
                        <ui-button title="取消" e-click="cancel" />
                        <ui-button theme="active" title="保存" e-click="save" />
                    </if>
                    <else>
                        <ui-button theme="active" title="导入数据" e-click="doImport" />
                    </else>
                </ui-button-group>
            </div>
        `;
        //格式化
        template = AmUtil.formatHtml(template);
        
        let s = `
        ${importStr}
        import { MAmBaseImport } from "./__baseimport.js";
        import { __AmDataConfig } from "./__amdataconfig.js";
        
        export class MAmDataImport extends MAmBaseImport{
            modules=[${moduleArr.join(",")}];
            constructor(){
                super(["${condFields.join('","')}"],${JSON.stringify(gridConds)});
            }
            template(){
                return \`
                ${template}\`
            }
            data(){
                return {
                    other: { publishType: 1},
                    __imported: false,
                    file: [],
                }
            }
        }
        `
        //写文件
        fsMdl.writeFileSync(pathMdl.resolve(this.baseSavePath,'__dataimport.js'), AmUtil.formatTs(s));
    }

    /**
     * 创建校验串
     * @param prop  属性对象 
     * @returns 
     */
    genValidStr(prop){
        let validStr = '';
        if(prop.validator){
            for(let v of prop.validator){
                if(v === 'require'){
                    validStr += " require='true'";
                }else{
                    validStr += ` validator='${v}'`;
                }
            }
        }
        return validStr;
    }

    /**
     * 生成属性输入串
     * @param prop  属性对象
     * @returns 
     */
    genInputStr(prop){
        let type=AmUtil.getTsType(prop.type) === 'number'?'number':'text';
        return `
            <div class='ui-row'>
                <ui-form-item label='${prop.showName}' field='${prop.name}'>
                    <ui-input type='${type}' field='${prop.name}' ${this.genValidStr(prop)}/>
                </ui-form-item>
            </div>
        `
    }

    /**
     * 生成数据表格
     * @param cls   数据模型类
     */
    genDataGrid(cls){
        const clsName = cls.ref;
        let cols:string[] = [];
        for(let p of cls.props){
            if(p.ref || p.isId){
                continue;
            }
            cols.push(`
            <ui-grid-col width="${p.width||100}" title="${p.showName}" field="${p.name}">
                {{${p.name}}}
            </ui-grid-col>
            `)
        }
        let templateStr = AmUtil.formatHtml(`
            <ui-grid $data={{data}} row-alt fix-head>    
            ${cols.join('')}
            </ui-grid>
        `);
        let str = `
        import{Module} from "../../js/nodomui.js"
        export class M${clsName}Grid extends Module{
            template(){
                return \`
                ${templateStr}
                \`
            }
        }`;
        //写文件
        fsMdl.writeFileSync(pathMdl.resolve(this.baseSavePath,clsName.toLowerCase()+'grid.js'),AmUtil.formatTs(str));
    }

    /**
     * 生成状态表格
     * @param cls   状态模型类
     */
    genStatusGrid(cls){
        const clsName = cls.ref;
        let cols:string[] = [];
        for(let p of cls.props){
            if(p.ref || p.isId || !p.showInGrid){
                continue;
            }
            cols.push(`
            <ui-grid-col width="${p.width||100}" title="${p.showName}" field="${p.name}">
                {{${p.name}}}
            </ui-grid-col>
            `)
        }
        let templateStr = AmUtil.formatHtml(`
            <ui-grid $data={{data}} row-alt fix-head checkable single onSelectChange='change'>
            ${cols.join('')}
            </ui-grid>
        `);
        const str = `
        import{Module,GlobalCache} from "../../js/nodomui.js"
        export class M${clsName}Grid extends Module{
            template(){
                return \`
                ${templateStr}
                \`
            }
            change(model){
                const name = this.constructor.name;
                GlobalCache.set("changeStatus", {
                    data: model,
                    entity: name.substring(1, name.length - 4),
                    type:this.props.type
                });
            }
        }`;
        //写文件
        fsMdl.writeFileSync(pathMdl.resolve(this.baseSavePath,clsName.toLowerCase()+'grid.js'),AmUtil.formatTs(str));
    }

    /**
     * 生成数据详情模块
     */
    genDetail(){
        let importArr = [
            `import { MDataDetailBase } from "./__datadetailbase.js"`,
            `import { MAmImportChart } from "./__importchart.js";`,
            `import { MAmImportResGrid } from "./__importresgrid.js";`,
            `import { MAmChart } from "./__chart.js";`
        ];
        let moduleArr = ['MAmChart','MAmImportResGrid'];

        for(let d of this.dataConfig.status){
            importArr.push(`import { M${d.entity}Grid } from "../${d.entity.toLowerCase()}grid.js";`);
            moduleArr.push('M' + d.entity + 'Grid');
        }
        for(let d of this.dataConfig.datas){
            importArr.push(`import { M${d.entity}Grid } from "../${d.entity.toLowerCase()}grid.js";`);
            moduleArr.push('M' + d.entity + 'Grid');
        }

        let str = `
            ${importArr.join('\r\n')}
            export class MAmDataDetail extends MDataDetailBase{
                modules = [${moduleArr.join(',')}]
            }
        `;
        fsMdl.writeFileSync(pathMdl.resolve(this.baseSavePath,'__datadetail.js'),AmUtil.formatTs(str));

        importArr.splice(0,1,`import { MAmQueryResultBase } from "./__queryresultbase.js";`)
        str = `
            ${importArr.join('\r\n')}
            export class MAmQueryResult extends MAmQueryResultBase {
                modules = [${moduleArr.join(',')}]
            }
        `;
        fsMdl.writeFileSync(pathMdl.resolve(this.baseSavePath,'__queryresult.js'),AmUtil.formatTs(str));
    }

    
    /**
     * 产生数据组织相关文件
     * @param dataModelArr  数据模型类数组
     * @param condCls       条件模型类对象
     */
    genOrgMode(condCls){
        //数据类型轴数据
        let fields:string[] = [];
        let cols:string[] = [];
        for(let prop of condCls.props){
            if(prop.ref){
                const cls = AMModelManager.getModel(prop.ref);
                if(cls){
                    for(let p of cls.props){
                        //全部新建和showInRef的属性进行展示
                        if(p.showInRef && !p.isId){
                            addField(p,cls.ref);
                        }
                    }
                }
            }else if(prop.isId){
                addField(prop);
            }
        }

        //写文件
        fsMdl.writeFileSync(pathMdl.resolve(this.baseSavePath,'__orgcondgrid.js'),AmUtil.formatTs(genCondGrid()));
        
        /**
         * 添加字段
         * @param prop          属性对象
         * @param entityName    实体名
         */
        function addField(prop:AMProp,entityName?:string){
            const field = entityName?(entityName.substring(0,1).toLowerCase() + entityName.substring(1) + '.' + prop.name):prop.name;
            cols.push(
                `<ui-grid-col width="${prop.width||100}" title="${prop.showName}" field="${field}">
                    {{${field}}}
                </ui-grid-col>`
            );
            //字段入库
            fields.push(<string>field);
        }

        /**
         * 产生条件表格
         * @returns     条件表格定义串
         */
        function genCondGrid():string{
            const gridTemplate = `
            <div>
                <ui-grid
                    $data={{rows}}
                    grid-line="row"
                    row-alt
                    fix-head>
                    <ui-grid-col width="100" title="操作">
                        <ui-button  title='\${btnTitle}' e-click='showData' theme='active' useDomModel/>
                    </ui-grid-col>
                    ${cols.join('\r\n')}
                </ui-grid>
                
                <ui-pagination
                    $total={{total}}
                    page-size='10'
                    page-no="1"
                    ps-array="[10,30,50,100]"
                    show-total="true"
                    show-jump="true"
                    show-num="10"
                    big-step="10"
                    onChange="changePage" />
            </div>
            `;
            return `
                import {Module,Nodom,GlobalCache} from "../../../js/nodomui.js";
                import { __AmDataConfig } from "./__amdataconfig.js";
                export class MOrgCondGrid extends Module{
                    template(props){
                        if(this.condKey !== props.condKey){
                            this.condKey = props.condKey;
                            setTimeout(()=>{this.changePage(1,30)},0);
                        }
                        const btnTitle = props.type === 'check'?'审核':'数据';
                        return \`${gridTemplate}\`;
                    }
                    data(){
                        return {
                            total:0,
                            rows:[]
                        }
                    }
                    changePage(pageNo,pageSize){
                        let params = {
                            pageNo: pageNo,
                            pageSize: pageSize
                        }
                        if(this.model.__params){
                            params.key = this.model.__params.key;
                        }
                        if(this.props.type === 'check'){
                            params.checkTime = 'is null';
                        }
                        Nodom.request({
                            url: "/__orgmode/getcondlist",
                            type:'json',
                            params: params
                        }).then((r) => {
                            if (r) {
                                this.model.rows = r.rows;
                                this.model.total = r.total;
                            }
                        });
                    }
                    showData(model){
                        const id = model[__AmDataConfig.cond.id];
                        GlobalCache.set('maintab.add',{
                            title:'数据' + id,
                            mdl:'/pages/module/__data/__base/__datadetail.js',
                            params:{condId:id},
                            __opened:true
                        });
                    }
                }
            `
        }
    }
    

    /**
     * 创建条件表格
     */
     public genCondGrid(){
        const fieldArr:any[][] = [];
        
        for(let mdl of AMModelManager.modelMap){
            if(mdl[1].isCond){
                for(let p of mdl[1].props){
                    if(p.ref){
                        if(!isManyToMany(p))
                        genOne(AMModelManager.getModel(p.ref),p.name,p.showName);
                    }else{
                        if(!p.isId){
                            fieldArr.push([p.name,p,p.showName]);
                        }
                    }
                }
                break;
            }
        }

        //列数组
        const colArr:string[] = [];
        //查询字段
        const fArr:string[] = [];
        for(const[name,prop,showName] of fieldArr){
            if(prop.isId){
                continue;
            }
            const style=prop.width?`width=${prop.width}`:'';
            const unit = getUnit(prop);
            let col;
            if(prop.editOption){
                switch(prop.editOption.type){
                    case 'datetime':
                        col = `
                        <ui-grid-col ${style} title='${showName + unit}' field='${name}'>
                            {{formatDate(${name})}}
                        </ui-grid-col>`;
                        break;
                }
            }
            
            if(!col){
                col = `
                <ui-grid-col ${style} title='${showName + unit}' field='${name}'>
                    {{${name}}}
                </ui-grid-col>
                `
            }
            colArr.push(col);
            fArr.push(name);
        }
        
        let template = `
            <div>
                <ui-grid $data={{gridData}} grid-line='rows' row-alt fix-head checkable \${props.singleSelect}>
                    ${colArr.join('')}
                </ui-grid>
                <ui-pagination 
                    $total={{total}}
                    page-size="30"
                    page-no="1"
                    ps-array="[10,30,50,100]"
                    show-total='true'
                    show-jump='true'
                    show-num="10"
                    big-step="10"
                    onChange="changePage"
                />
            </div>
        `;
        
        template = AmUtil.formatHtml(template);

        const clsStr = `
            import { Module,Nodom,Util} from "../../../js/nodomui.js";
            import { AmUtil } from "../../__base/util.js";
            export class MAmCondGrid extends Module{
                template(props){
                    return \`
        ${template}\`
                }
                data(){
                    return{
                        total:0
                    }
                }
            
                changePage(pageNo, pageSize) {
                    let params = {};
                    //通过props传递的参数
                    if (this.model.__params) {
                        for (let p of Object.keys(this.model.__params)) {
                            params[p] = this.model.__params[p];
                        }
                    }
                    if (
                        this.params &&
                        Util.compare(this.params, params) &&
                        this.pageNo &&
                        this.pageNo === pageNo &&
                        this.pageSize === pageSize
                    ) {
                        return;
                    }
            
                    this.params = params;
                    this.pageNo = pageNo;
                    this.pageSize = pageSize;
            
                    Nodom.request({
                        url: "/amcond/query",
                        type: "json",
                        params: {
                            pageNo: pageNo,
                            pageSize: pageSize,
                            conditions: JSON.stringify(AmUtil.getCleanObj(params))
                        }
                    }).then((r) => {
                        this.model["gridData"] = r.rows;
                        this.model["total"] = r.total;
                    });
                }

                formatDate(st){
                    return Util.formatDate(st,'yyyy-MM-dd hh:mm:ss');
                }
            }`
        
        fsMdl.writeFileSync(pathMdl.resolve(this.baseSavePath,'__condgrid.js'),AmUtil.formatTs(clsStr));

        //创建条件业务
        this.genCondService(fArr);
        /**
         * 产生一个
         * @param cls       对象
         * @param pName     属性前缀名
         * @returns 
         */
        function genOne(cls,pName,showName){
            if(['AmImportTemplate'].includes(cls.ref) || fieldArr.find(item=>item[0] === pName)){
                return;
            }
            addField(cls,pName,showName);
            for(let p of cls.props){
                //外键，且有showName
                if(p.ref){
                    const cls1 = AMModelManager.getModel(p.ref);
                    if(p.ref !== cls.name && !isManyToMany(p)){
                        genOne(cls1,pName +'.' + p.name,p.showName);
                    }
                }
            }
        }

        /**
         * 创建sql
         * @param cls   类
         * @param pName 属性全称（带前缀）
         * @param showName  显示名外键
         */
        function addField(cls,pName,showName){
            if(!cls){
                return;
            }
            
            const props = cls.props.filter(item=>item.showInCond||item.showInRef);
            for(let p of props){
                const sn = showName?p.showName + '(' + showName + ')':p.showName;
                fieldArr.push([pName + '.' + p.name,p,sn]);
            }
        }

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

        /**
         * 获取单位(unit)
         * @param item  prop 
         * @returns     单位内容
         */
         function getUnit(item) {
            if (item.unit) {
                item.unit = item.unit.trim();
                if (item.unit !== '') {
                    return '(' + item.unit + ')';
                }
            }
            return '';
        }
    }

    /**
     * 创建条件业务
     * @param fieldArr  查询条件字段数组
     */
    genCondService(fieldArr){
        const s = `
            import { Instance } from "noomi";
            import { __AmCondServiceBase } from "./__condservicebase";
            @Instance()
            export class __AmCondService extends __AmCondServiceBase{
                constructor(){
                    super(['${fieldArr.join("','")}'])
                }
            }`
            require('fs').writeFileSync(require('path').resolve(this.baseSavePath,'__condservice.ts'),AmUtil.formatTs(s));
    }

    /**
     * 生成state config 文件
     */
    genStateConfig(status,type){
        const arr = [];
        for(const t of status){
            arr.push(`import { ${t.entity} } from "../dao/entity/app/${t.entity.toLowerCase()}";`)
        }
        for(const t of type){
            arr.push(`import { ${t.entity} } from "../dao/entity/app/${t.entity.toLowerCase()}";`)
        }
        arr.push('export default [');
        for(const st of status){
            arr.push('{');
            arr.push(`entity:${st.entity},`);
            //字段
            arr.push('fields:[');
            for(const f of st.fields){
                arr.push(`{name:'${f.en}',label:'${f.zh}'},`);
            }
            arr.push('],');
            //关联数据表
            arr.push(`children:[`);
            for(const t of type){
                if(t.status === st.entity){
                    arr.push(`{entity:${t.entity},label:'${t.showName}'},`)
                }
            }
            arr.push(']'),
            arr.push('},');
        }
        arr.push(']');
        const path = pathMdl.resolve(process.cwd(),'server','module','data');
        if(!fsMdl.existsSync(path)){
            fsMdl.mkdirSync(path,{recursive:true});
        }
        fsMdl.writeFileSync(pathMdl.resolve(path,'stateconfig.ts'),AmUtil.formatTs(arr.join('')));
    }
}