import { Instance } from "noomi";
import { EntityManager, getEntityManager, NativeQuery, Query } from "relaen";
import { AmModel } from "../../dao/entity/base/ammodel";
import { AmImportRes } from "../../dao/entity/base/amimportres";
import { __AmDataConfig } from "./__amdataconfig";
import { AmOrgCond } from "../../dao/entity/base/amorgcond";
import { AmProperty } from "../../dao/entity/base/amproperty";
import { AmQueryConfig } from "../../dao/entity/base/amqueryconfig";
import { __Util } from "../__base/__util";
import { NFEngine} from "noomiflow";
import { AmDataImport } from "../../dao/entity/base/amdataimport";
import { AmDataType } from "../../dao/entity/base/amdatatype";

@Instance()
export class __AmDataService {
    /**
     * 获取状态列表
     * @param condId    状态id 
     */
    public async getStatusList(condId:number){
        const em: EntityManager = await getEntityManager();
        let query: Query;
        let mdls = <AmModel[]>await AmModel.findMany({isStatus:1});
        let datas = [];
        for(let mdl of mdls){
            query =  em.createQuery(mdl.refEntity);
            const data = await query.select(['*']).where({
                'testCond.testCondId':condId
            }).getResultList() as [];

            if(data.length>0){
                datas.push({
                    title:mdl.showName,
                    entity:mdl.refEntity,
                    data:data
                });
            }
        }
        await em.close();
        return datas;
    }
    /**
     * 获取统计数据
     */
    public async getStatData(){
        const dataTypes = <AmDataType[]>await AmDataType.findMany();
        const em: EntityManager = await getEntityManager();
        const arr = [];
        for(const type of dataTypes){
            const query:NativeQuery = em.createNativeQuery(`SELECT count(*) FROM ${type.refEntity}`);
            const count = await query.getResult();
            arr.push({
                name:type.typeName,
                value:count
            });
        }
        em.close();
        return arr;
    }
    /**
     * 获取数据
     * @param entity    实体
     * @param statusId  状态id 
     * @returns 
     */
    public async getDataList(model){
        const statusId = model.statusId;
        const mdls = __AmDataConfig.datas.filter(item=>item.status === model.entity);
        const em: EntityManager = await getEntityManager();
        let datas = [];
        for(let mdl of mdls){
            let query =  em.createQuery(mdl.entity);
            let param = {};
            let pName = model.entity.substring(0,1).toLowerCase() + model.entity.substring(1);
            param[pName] = statusId;
            try{
                const data = await query.select(['*']).where(param).getResultList() as [];
                if(data.length>0){
                    datas.push({
                        title:mdl.showName,
                        entity:mdl.entity,
                        data:data
                    });
                }
            }catch(e){
                console.log(e);
            }
        }
        await em.close();
        return datas;
    }

    /**
     * 获取资源文件
     * @param model 
     */
     async getRes(model){
        let em: EntityManager = await getEntityManager();
        let query: Query = em.createQuery(__AmDataConfig.cond.entity);
        let param = {}
        param[__AmDataConfig.cond.id] = { rel: "in", value: model.ids.split(",") };
        //查到导入批次
        let dis = await query
            .select(["amDataImport.dataImportId"])
            .where(param)
            .getResultList(null,null,false) as any[];

        let arr = [];
        query = em.createQuery(AmImportRes.name);
        for(let d of dis){
            param = {amDataImport:d.amDataImport.dataImportId};
            const rows = await query.select(['amFile.*']).where(param).getResultList() as any[];
            for(let r of rows){
                arr.push(r.amFile);
            }
        }
        await em.close();
        return arr;
    }

    /**
     * 获取所有条件属性
     */
    async getCondFields(){
        //获取orgcond
        const em:EntityManager = await getEntityManager();
        const lstCond:AmOrgCond[] = <AmOrgCond[]>await AmOrgCond.findMany();
        
        const condEn = __AmDataConfig.cond.entity.substring(0,1).toLowerCase() + __AmDataConfig.cond.entity.substring(1);
        let fieldsArr = [];
        //外键信息
        for(let cond of lstCond){
            const mdlName = 'Mdl' + cond.entity;
            let param = {isId:false,"amModel.refEntity":cond.entity};
            const props:AmProperty[] = <AmProperty[]> await AmProperty.findMany(param);
            for(let p of props){
                if(!p.refModel){
                    fieldsArr.push({
                        fieldName:condEn + '.' + cond.relName + '.' + p.propName,
                        fieldType:p.propType,
                        showName:p.showName + '(' + cond.showName + ')'
                    });
                }
            }
        }
        //导入批次信息
        let param = {isId:false,"amModel.refEntity":'AmDataImport'};
        let props:AmProperty[] = <AmProperty[]> await AmProperty.findMany(param);
        for(let p of props){
            if(!p.refModel){
                fieldsArr.push({
                    fieldName:condEn + '.amDataImport.' + p.propName,
                    fieldType:p.propType,
                    showName:p.showName
                });
            }
        }

        //条件
        param = {isId:false,"amModel.refEntity":__AmDataConfig.cond.entity};
        props = <AmProperty[]> await AmProperty.findMany(param);
        for(let p of props){
            if(!p.refModel){
                fieldsArr.push({
                    fieldName:condEn + '.' + p.propName,
                    fieldType:p.propType,
                    showName:p.showName
                });
            }
        }
        
        await em.close();
        return fieldsArr;
    }

    /**
     * 获取查询字段
     * @returns 
     */
    async getQueryFields(){
        return await AmQueryConfig.findMany();
    }

    async saveQueryFields(model){
        if(!model.queryFields){
            return;
        }
        // const queryFields = JSON.parse(model.queryFields);
        AmQueryConfig.deleteMany({});
        for(let d of model.queryFields){
            let qc = new AmQueryConfig();
            qc.fieldName = d.fieldName;
            qc.showName = d.showName;
            qc.fieldType = d.fieldType;
            await qc.save();
        }
    }

    /**
     * 获取条件
     * @param model 
     * @returns 
     */
    async queryStatus(model){
        const em: EntityManager = await getEntityManager();
        let cond = model.conditions;
        //重构结构
        for(let k of Object.keys(cond)){
            if(Array.isArray(cond[k]) && cond[k].length===2){
                cond[k] = {
                    rel:'between',
                    value:cond[k]
                }
            }else if(typeof cond[k] === 'string'){
                cond[k] = {
                    rel:'like',
                    value:cond[k]
                }
            }
        }
        const query: Query = em.createQuery(model.entity);
        const dataObj = __AmDataConfig.datas.find(item=>item.entity === model.entity);
        const statusObj = __AmDataConfig.status.find(item=>item.entity === dataObj.status);
        const statusEn = statusObj.entity.substring(0,1).toLowerCase() + statusObj.entity.substring(1);
        const rows = await query.select(statusEn+'.*').distinct().where(cond).getResultList() as any[];
        const arr = [];
        for(let r of rows){
            arr.push(r[statusEn]);
        }
        await em.close();
        return arr;
    }


    /**
     * 获取条件
     * @param model 
     * @returns 
     */
     async queryStatusData(model){
        const em: EntityManager = await getEntityManager();
        const query: Query = em.createQuery(model.entity);
        const dataObj = __AmDataConfig.datas.find(item=>item.entity === model.entity);
        const statusObj = __AmDataConfig.status.find(item=>item.entity === dataObj.status);
        const statusEn = statusObj.entity.substring(0,1).toLowerCase() + statusObj.entity.substring(1);
        const param = {};
        param[statusEn + '.' + statusObj.id] = model.statusId;
        const rows = await query.select('*').where(param).getResultList();
        await em.close();
        return rows;
    }

    /**
     * 自定义查询
     */
    async query(model){
        const em: EntityManager = await getEntityManager();
        const query: Query = em.createQuery(model.entity);
        const conditions = model.conditions;
        const fields = model.queryFields;
        let start = 0;
        let limit = model.pageSize;
        if(model.pageNo && limit){
            start = (model.pageNo-1) * model.pageSize;
        }
        const rows = await query.select(fields).where(conditions).getResultList(start,limit);
        const count = await em.getCount(model.entity,conditions);
        await em.close();
        return {rows:rows,total:count};
    }

    /**
     * 审核导入数据
     * @param request 
     * @param model 
     */
    async checkImport(request,model){
        let agree = 0;
        if(model.isAgree){
            agree = Number(model.isAgree);
        }
        const em:any = await getEntityManager();
        const query:Query = em.createQuery(__AmDataConfig.cond.entity);
        const param = {};
        param[__AmDataConfig.cond.id] = model.condId;
        const cond = await query.select('*').where(param).getResult() as any;
        const di = await cond.getAmDataImport() as AmDataImport;
        if(agree){  //通过则保存
            di.checkTime = new Date().getTime();
            di.enabled = 1;
            await di.save();
        }else{      //不通过则删除
            await di.delete();
        }
        await em.close();

        const uid = (await __Util.getLogonUser(request)).userId;
        const proc = await NFEngine.getInstance(model.processId);
        const vars = {
            userId:uid,
            agree:agree
        }
        if(model.reason){
            vars['reason'] = model.reason;
        }
        proc.setParams(vars);
        await proc.next({userId:uid,agree:agree});
        
    }
}