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

/**
 * 服务端生成器
 */
export class AMServerGenerator{

    /**
     * 基础存储路径
     */
     private baseSavePath:string;

     /**
      * 基础元数据路径
      */
     private baseMetaPath:string;
 
     /**
      * 基础路由路径
      */
     private baseRoutePath:string;
 
     /**
      * 基础模块路径
      */
     private baseMdlPath:string;
    
     
    /**
     * 构造器
     * @param savePath  存储路径
     */
     constructor(savePath:string){
        this.baseSavePath = savePath;
    }

    /**
     * 产生代码
     */
    public genCode(){
        //页面代码
        for(let mdl of AMModelManager.modelMap){
            this.genOne(mdl[1]);
        }
    }
    /**
     * 生成一个
     * @param cls   model类 
     * @param path  元数据基础路径
     */
    public genOne(cls:any){
        const fsMdl = require('fs');
        const pathMdl = require('path');
        const fileBase = cls.ref.toLowerCase();
        
        let routeDir = pathMdl.resolve(this.baseSavePath,'module','route','gen');
        let serviceDir = pathMdl.resolve(this.baseSavePath,'module','service','gen');
        let modelDir = pathMdl.resolve(this.baseSavePath,'module','model','gen');
        //目录不存在则创建目录
        for(let p of [routeDir,serviceDir,modelDir]){
            if(!fsMdl.existsSync(p)){
                fsMdl.mkdirSync(p,{recursive:true});
            }
        }
        
        // model
        //写文件
        fsMdl.writeFileSync(pathMdl.resolve(modelDir,'m'+fileBase+'.ts'), AmUtil.formatTs(this.genModel(cls)));

        // route
        //美化
        //写文件
        fsMdl.writeFileSync(pathMdl.resolve(routeDir,fileBase+'route.ts'), AmUtil.formatTs(this.genRoute(cls)));

        // service
        //写文件
        fsMdl.writeFileSync(pathMdl.resolve(serviceDir,fileBase+'service.ts'), AmUtil.formatTs(this.genService(cls)));
    }

    /**
     * 产生路由
     * @param cls   AM模型类
     * @reutrns     model文件串或undefined
     */
    public genModel(cls:AMModel):string{
        let clsName = cls.ref;
        let arr:string[] = [];
        if(!cls.props){
            return '';
        }
        for(let prop of cls.props){
            const propArr:string[] = [];
            let type = prop.type;
            //ts类型
            let type1 = 'string';
            if(['float','double','number','numeric'].includes(<string>type)){
                type = 'float';
                type1 = 'number';
            }else if(type === 'ref'){
                type = 'object';
                type1 = 'object';
            }else if(type==='datetime'){
                type = 'int';
                type1 = 'number';
            }
            if(['float','int'].includes(<string>type)){
                type1 = 'number';
            }
            propArr.push(`type:'${type1}'`);
            
            let validStr = '';
            if(prop.validator){
                for(let p of prop.validator){
                    if(p === 'require'){
                        continue;
                    }else{
                        if(typeof p === 'string'){
                            let a = p.split(':');
                            validStr += `${a[0]}:[${a.slice(1).join(',')}]`
                        }
                    }
                }
            }
            if(validStr !== ''){
                propArr.push(`validator:{
                    ${validStr}
                }`)
            }
            arr.push(`
                @Prop({
                    ${propArr.join(',')}
                })
                ${prop.name}:${type1};
            `)   
        }
        return `
            import { Prop } from "noomi";
            import { __BaseModel } from "../__basemodel";
            export class M${clsName} extends __BaseModel{
                ${arr.join('\r\n')}
            }
        `;
    };
    /**
     * 产生路由代码
     * @param cls   AM模型类
     */
    public genRoute(cls:any):string{
        let clsName = cls.ref;
        let serviceName = clsName + 'Service';
        let modelName = 'M' + clsName;
        return `
            import { BaseRoute,Inject,DataModel,NullCheck,Router } from "noomi";
            import { ${serviceName} } from "../../service/gen/${serviceName.toLowerCase()}";
            import { ${modelName} } from "../../model/gen/${modelName.toLowerCase()}";
            @Router({
                namespace: '/${clsName.toLowerCase()}',
                path: '*'
            })
            @DataModel(${modelName})
            class ${clsName}Route extends BaseRoute{
                @Inject(${serviceName})
                service:${serviceName};
                /**
                 * 保存信息(新增和修改共用)
                 */
                public async save(){
                    try{
                        let r = await this.service.save(this.request,this.model);
                        return { "success": true, "result": r}
                    }catch(e){
                        return { "success": false, "message": e.message}
                    }
                    
                }

                /**
                 * 删除
                 */
                @NullCheck(['ids'])
                public async delete() {
                    try{
                        let r= await this.service.delete(this.model);
                        return { "success": true,"result": r};
                    }catch(e){
                        return { "success": false, "message":e.message}
                    }
                    
                }

                /**
                 * 通过id查询 
                 */
                public async findbyid(){
                    try{
                        let r = await this.service.findById(this.model);
                        return { success: true, result: r };
                    }catch(e){
                        return { "success": false, "message": e.message}
                    }
                    
                }

                /**
                 * 查询
                 */ 
                public async query(){
                    return await this.service.query(this.model);
                }
            }
        `;
    }

    /**
     * 产生业务层代码
     * @param cls   AM模型类
     */
    public genService(cls:any):string{
        let clsName = cls.ref;
        let spFields = {};
        for(let p of cls.props){
            let o = spFields[p.name]||{};
            const opt = p.editOption;
            let changed = false;
            //使用系统时间
            if(p.useSystemTime){
                o.useSystemTime = true;
                //时间是否需要更新
                if(typeof p.useSystemTime === 'object'){
                    o['update'] = p.useSystemTime.update;
                }
                changed = true;
            }else if(p.useLogonUser){ //使用登录账户
                o.useLogonUser=true;
                if(typeof p.useLogonUser === 'object'){
                    o['update'] = p.useLogonUser.update;
                }
                changed = true;
            }
            //加密方式
            if(p.encryption){
                o.encryption=p.encryption;
                changed = true;
            }
            //默认值
            if(p.defaultValue!==undefined){ 
                o.defaultValue = p.defaultValue;
                changed = true;
            }

            //manytomany
            if(opt){
                if(opt['type'] === 'transfer' || opt['option']&&opt['option'].multi){
                    o.manyToMany = true;
                    changed = true;
                }else if(opt['type'] === 'new'){
                    o.oneToMany = true;
                    changed = true;
                }
            }
            
            if(changed && spFields[p.name] !== o){
                spFields[p.name] = o;
            }
        }
        let spStr = '';
        //特殊属性不为空
        if(Object.keys(spFields).length>0){
            spStr = `
            constructor(){
                super(${JSON.stringify(spFields)});
            }`;
        }   
        return `
            import { Instance } from "noomi";
            import { __BaseService } from "../__base/__baseservice";
            
            @Instance()
            export class ${clsName}Service extends __BaseService{
                ${spStr}
            } 
        `
    }
}