import { AMProp } from "./types";
import { AMModelManager } from "./modelmanager";
import { AmUtil } from "./util";

/**
 * 模型生成器
 */
export class AMMetaGenerator {
    /**
     * 基础存储路径
     */
    private baseSavePath: string;

    /**
     * 构造器
     * @param savePath 元数据存储路径
     */
    constructor(savePath: string) {
        this.baseSavePath = savePath;
    }

    /**
     * 创建元数据
     */
    public genMeta() {
        const fsMdl = require('fs');
        const pathMdl = require('path');
        
        //菜单数据
        let menus:{menu?:string,url?:string,mdl?:string}[] = [];

        for (let mdl of AMModelManager.modelMap) {
            if (!mdl[1].isData) {
                if (mdl[1].manageable) {
                    //构建文件夹 meta/类名
                    let path = pathMdl.resolve(this.baseSavePath, mdl[0].substring(3).toLowerCase());
                    //目录不存在则创建目录
                    if (!fsMdl.existsSync(path)) {
                        fsMdl.mkdirSync(path, { recursive: true });
                    }
                    //form和grid
                    this.genOne(mdl[1]);
                    //数据统一管理，每种数据不单独菜单管理
                    let menu = this.genMenuMeta(mdl[1]);
                    menus.push(menu);
                }
            }
        }
        //menu 元数据
        fsMdl.writeFileSync(pathMdl.resolve(this.baseSavePath, 'menu.json'), AmUtil.formatJson(JSON.stringify({ menus })));
    }

    /**
     * 创建一个模型的元数据
     * @param cls   model class
     */
    public genOne(cls: any) {
        const fsMdl = require('fs');
        const pathMdl = require('path');
        let path = pathMdl.resolve(this.baseSavePath, cls.ref.toLowerCase());
        //目录不存在则创建目录
        if (!fsMdl.existsSync(path)) {
            fsMdl.mkdirSync(path, { recursive: true });
        }
        if (cls.editable) {
            //form 元数据
            let str = this.genFormMeta(cls);
            if (str) {
                fsMdl.writeFileSync(pathMdl.resolve(path, 'form.json'), AmUtil.formatJson(str));
            }
        }

        let str = this.genGridMeta(cls);
        if (str) {
            //grid 元数据
            fsMdl.writeFileSync(pathMdl.resolve(path, 'grid.json'), AmUtil.formatJson(str));
        }
    }

    /**
     * 产生form编辑信息
     * @param cls   处理类
     * @returns     form串
     */
    private genFormMeta(cls: any) {
        //不可编辑，不生成form代码
        if (!cls.editable) {
            return;
        }
        // 是否显示数据单位
        let hasUnit: boolean = false;
        let itemArr:{label:string,field:string,title:string,editOption:object}[] = [];
        for (let item of cls.props) {
            if (!item.editable) {
                continue;
            }
            addProp(item);
        }

        return JSON.stringify({
            title: cls.showName + '编辑',
            cols: cls.colsInRow || 2,
            editWidth:cls.editWidth,
            hasUnit: hasUnit,
            items: itemArr
        });

        /**
         * 添加一个属性
         * @param item 
         */
        function addProp(item: AMProp, pre?: string) {
            pre = pre || '';
            // 主键为关联对象，所有属性都需要添加进来
            if (item.isId && item.type === 'ref') {
                let clsName: string
                if (typeof (item.ref) == "object") {
                    clsName = item.ref.name;
                } else {
                    clsName = <string>item.ref;
                }
                let mdl = AMModelManager.getModel(clsName);
                pre = pre + item.name + '.'
                for (let item1 of mdl.props) {
                    if (!item1.editable) {
                        continue;
                    }
                    addProp(item1, pre);
                }
            } else {
                let prop: any = {
                    label: item.showName,
                    field: pre + item.name,
                    title: item.title,
                    editOption: item.editOption
                }

                if (item.unit) {
                    item.unit = item.unit.trim();
                    if (item.unit !== '') {
                        hasUnit = true;
                    }
                    prop.unit = item.unit;
                }
                prop.validator = item.validator;
                itemArr.push(prop);
            }
        }
    }

    /**
     * 产生grid列表信息
     * @param cls   处理类
     * @returns     form串
     */
    private genGridMeta(cls: any) {
        //不可管理，不生成form代码
        if (!cls.manageable) {
            return;
        }
        let itemArr:{title:string,width?:number,field?:string,type?:string,sortable?:boolean}[] = [];
        let lastWidth;
        for (let item of cls.props) {
            if (!item.showInGrid) {
                continue;
            }
            addProp(item);
        }
        //如果最后一个没配置width，则删除，实现表格的宽度自适应
        if (!lastWidth) {
            delete itemArr[itemArr.length - 1].width;
        }
        return JSON.stringify({
            title: cls.showName + '列表',
            gridLine: 'row',
            showDetail: true,
            showPagination: true,
            items: itemArr
        });

        function addProp(item: AMProp, pre?: string) {
            pre = pre || '';
            //不显示在grid中的项，直接跳过
            if (!item.showInGrid) {
                return;
            }

            if (item.type === 'ref' && item.isId) { //外键为主键
                let clsName: string
                if (typeof (item.ref) == "object") {
                    clsName = item.ref.name;
                } else {
                    clsName = <string>item.ref;
                }
                let mdl = AMModelManager.getModel(clsName);
                pre = pre + item.name + '.';
                for (let item1 of mdl.props) {
                    if (!item.showInGrid) {
                        continue;
                    }
                    addProp(item1, pre);
                }
            } else {
                if (item.type === 'ref') {
                    let clsName: string
                    if (typeof item.ref == "object") {
                        clsName = item.ref.name;
                    } else {
                        clsName = <string>item.ref;
                    }
                    let ref = AMModelManager.getModel(clsName);
                    let pa = ref.props.filter(item => item.showInRef);
                    if (pa.length > 0) {
                        for (let p of pa) {
                            itemArr.push({
                                title: p.showName + getUnit(item),
                                width: p.width || 100,
                                field: pre + item.name + '.' + p.name,
                                type: p.editOption && p.editOption['type'] === 'datetime' ? 'datetime' : 'normal',
                                sortable: true
                            });
                            lastWidth = p.width;
                        }
                    }
                } else {
                    itemArr.push({
                        title: item.showName + getUnit(item),
                        width: item.width || 100,
                        field: pre + item.name,
                        type: item.editOption && item.editOption['type'] === 'datetime' ? 'datetime' : 'normal',
                        sortable: true
                    })
                    lastWidth = item.width;
                }
            }
        }

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

    /**
     * 生成菜单和路由元数据
     * @param cls   model类
     * @returns     菜单路由对象
     */
    private genMenuMeta(cls: any): object {
        let pathName = cls.ref.toLowerCase();
        let menuName = cls.isData ? cls.showName : cls.showName + '管理';
        return {
            menu: menuName,
            url: pathName,
            mdl: pathName + '/' + pathName + 'main.js'
        }
    }
}