import { getConnection,closeConnection, HttpResponse } from "noomi";
import { EntityManager, getEntityManager, Query } from "relaen";
import { __Util } from "../__base/__util";
import { __AmDataConfig } from "./__amdataconfig";
import { NFEngine } from "noomiflow";
import xlsx from 'node-xlsx'

export class __AmCondServiceBase {
    /**
     * 实体名
     */
    private entityName:string;
    /**
     * 主键名
     */
    private idName:string;

    private fields:string[];

    constructor(fields){
        this.entityName = __AmDataConfig.cond.entity;
        this.idName = __AmDataConfig.cond.id;
        this.fields = fields;
        if(!this.fields.includes(this.idName)){
            this.fields.unshift(this.idName);
        }
    }

    /**
     * 查询
     * @param conditions     条件
     * @param pageNo        页号
     * @param pageSize      页面大小
     * @returns 
     */
    async query(conditions:any,pageNo?:number,pageSize?:number){
        const conn = await getConnection();
        const em:EntityManager = await getEntityManager();
        const query:Query = em.createQuery(this.entityName);
        // 处理key，格式：amDataImport.amUser.amCompany.companyId|1|amTarget.targetId|3
        if(conditions.key){
            let a = conditions.key.split('|');
            if(a.length>0){
                for(let i=0;i<a.length;i++){
                    conditions[a[i]] = a[++i];
                }
            }
            delete conditions.key;
        }
        
        let start = 0;
        if(pageNo>0 && pageSize>0){
            start = (pageNo-1) * pageSize;
        }

        const rows = await query.select(this.fields.slice(0)).where(conditions).getResultList(start,pageSize);
        const total = await em.getCount(this.entityName,conditions);
        await em.close();
        await closeConnection();
        return{rows:rows ,total: total};
    }

    
    /**
     * 通过id删除
     * @param ids 
     * @returns 
     */
    async delete(ids){
        const arr = ids.split(',');
        const em:EntityManager = await getEntityManager();
        const query:Query = em.createQuery(this.entityName);
        const param = {};
        param[this.idName] = {rel:'in',value:arr};
        await query.delete().where(param).getResult();
        await em.close();
    }

    /**
     * 导出条件数据
     * @param condId 
     */
    async exportCondData(response:HttpResponse,condId:number){
        const condEntity = __AmDataConfig.cond.entity;
        const em:EntityManager = await getEntityManager();
        //条件
        let query:Query = em.createQuery(condEntity);
        let  param = {};
        param[__AmDataConfig.cond.id] = condId;
        const cond = await query.select(this.fields.slice(0)).where(param).getResult();
        let sheets = [];
        //条件字段
        let sheet = {name:__AmDataConfig.cond.showName,data:await this.genCondData(cond,this.fields)}
        sheets.push(sheet);
        
        //状态
        sheet = {name:'状态',data:[]};
        let statusData = [];
        const condProp = condEntity.substring(0,1).toLowerCase() + condEntity.substring(1);
        //状态字段
        for(let status of __AmDataConfig.status){
            query = em.createQuery(status.entity);
            param = {};
            param[condProp] = condId;
            const rows = await query.select('*').where(param).getResultList() as [];
            if(rows.length>0){
                let title = ['Id'];
                for(let f of status.fields){
                    title.push(f.zh);
                }
                sheet.data.push(title);
                for(let r of rows){
                    let data = [r[status.id]];
                    for(let f of status.fields){
                        data.push(r[f.en]);
                    }
                    sheet.data.push(data);
                    //保留，取数据时使用
                    statusData.push({
                        entity:status.entity,
                        id:r[status.id]
                    });
                }
            }
        }
        sheets.push(sheet);
        //数据
        sheets = sheets.concat(await this.getStatusData(statusData));
        await em.close();
        
        //写文件
        const fsMdl = require('fs');
        const pathMdl = require('path');
        let path = pathMdl.resolve('tmp');
        if(!fsMdl.existsSync(path)){
            fsMdl.mkdirSync(path);
        }
        path = pathMdl.resolve(path,require('crypto').randomUUID() + '.xlsx');
        fsMdl.writeFileSync(path,xlsx.build(sheets),'binary');
        return path;
    }

    /**
     * 获取状态数据
     * @param statusData  状态数据 [{entity:状态entity,id:状态id值},...]
     * @returns     数据数组
     */
    async getStatusData(statusData):Promise<any[]>{
        let arr = [];
        const em:EntityManager = await getEntityManager();
        let query:Query;
        //数据字段
        if(statusData.length > 0){
            let sheet;
            for(let status of statusData){
                for(let dataCfg of __AmDataConfig.datas){
                    if(dataCfg.status === status.entity){
                        const statusProp = status.entity.substring(0,1).toLowerCase() + status.entity.substring(1);
                        query = em.createQuery(dataCfg.entity);
                        let param = {};
                        param[statusProp] = status.id;
                        const rows = await query.select('*').where(param).getResultList() as [];
                        if(rows.length>0){
                            sheet = arr.find(item=>item.name === dataCfg.showName);
                            if(!sheet){
                                sheet = {name:dataCfg.showName,data:[]};
                                let title = ['状态id'];
                                for(let f of dataCfg.fields){
                                    title.push(f.zh);
                                }
                                sheet.data.push(title);
                                arr.push(sheet);
                            }

                            for(let r of rows){
                                let data = [status.id];
                                for(let f of dataCfg.fields){
                                    data.push(r[f.en]);
                                }
                                sheet.data.push(data);
                            }
                            
                        }
                    }
                }
            }
        }
        await em.close();
        return arr;
    }

    /**
     * 产生条件数据
     * @param fields 
     */
    async genCondData(data:any,fields:string[]){
        const em:EntityManager = await getEntityManager();
        let datas = [];
        for(let field of fields){
            const d = await genOne(data,field);
            if(d){
                datas.push(d);    
            }
        }
        await em.close();
        return datas;

        /**
         * 产生一个数据
         * @param data 
         * @param field 
         * @returns 
         */
        async function genOne(data,field){
            let param;
            //外键
            if(field.indexOf('.') !== -1){
                let fa = field.split('.');
                for(let f of fa){
                    if(!data){
                        break;
                    }
                    data = data[f];
                }
                if(data){
                    let ent = fa[fa.length-2];
                    ent = ent.substring(0,1).toUpperCase() + ent.substring(1);
                    param = {
                        'amModel.modelName':'Mdl' + ent,
                        propName:fa[fa.length-1]
                    };
                }
            }else{
                let ent = __AmDataConfig.cond.entity;
                ent = ent.substring(0,1).toUpperCase() + ent.substring(1);
                param = {
                    'amModel.modelName':'Mdl' + ent,
                    propName:field
                };
                ;
            }
            if(!data || !param){
                return;
            }
            const query:Query = em.createQuery('AmProperty');
            const prop = await query.select(['showName','editOption']).where(param).getResult() as any;
            if(prop && prop.editOption){
                const opt = JSON.parse(prop.editOption);
                if(opt.type === 'datetime'){
                    data = new Date(data).toUTCString();
                }
                return [prop.showName,data];
            }
        }
    }

}