'use strict';

/**
 *
 *
 * @author Mai
 * @date
 * @version
 */

const timesLen = require('../const/audit').stage.timesLen;
const payConst = require('../const/deal_pay');
const auditConst = require('../const/audit');

module.exports = app => {
    class StagePay extends app.BaseService {
        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            this.tableName = 'stage_pay';
        }

        /**
         * 查询 某期 某轮审批 某审核人数据
         *
         * @param {Number} pid - 合同支付id
         * @param {Number} sid - 期id
         * @param {Number} times - 期第几轮审批
         * @param {Number} order - 审核人顺序
         * @param {Number|Array|Null} pid - 部位明细id - 为空则查询全部
         * @returns {Promise<*>}
         */
        async getAuditorStagePay(pid, sid, times, order) {
            const pidSql = pid instanceof Array ? ' And SP.`pid` in (' + pid.join(',') + ')' : 'And SP.`pid` = ' + pid;
            const sql = 'SELECT SP.*, P.`csorder`, P.`cstimes`, P.`csaorder`, P.`order`, P.uid, P.minus, P.ptype, P.sprice, P.sexpr, P.rprice, P.rexpr, P.is_yf, P.dl_type, P.dl_count, P.dl_tp_type, P.dl_tp ' +
                '  FROM ' + this.tableName + ' As SP ' +
                '  LEFT JOIN ' + this.ctx.service.pay.tableName + ' As P ' +
                '  ON SP.pid = P.id' +
                '  WHERE SP.`sid` = ? AND SP.`stimes` = ? AND SP.`sorder` = ? AND SP.`pid` = P.`id` AND P.`valid`' + pidSql +
                '  ORDER BY P.`order`';
            const sqlParam = [sid, times, order, pid];
            if (pid instanceof Array) {
                return await this.db.query(sql, sqlParam);
            } else {
                return await this.db.queryOne(sql, sqlParam);
            }
        }

        /**
         * 查询 某期 某轮审批 某审核人数据
         * @param {Number} sid - 期id
         * @param {Number} times - 期第几轮审批
         * @param {Number} order - 审核人顺序
         * @param {Number|Array|Null} pid - 部位明细id - 为空则查询全部
         * @returns {Promise<*>}
         */
        async getAuditorStageData(sid, times, order) {
            const sql = 'SELECT SP.*,' +
                '    P.`csorder`, P.`cstimes`, P.`csaorder`, P.`order`, P.uid, P.minus, P.ptype, P.sprice, P.sexpr,' +
                '    P.rprice, P.rexpr, P.is_yf, P.dl_type, P.dl_count, P.dl_tp_type, P.dl_tp, P.name as pName ' +
                '  FROM ' + this.tableName + ' As SP ' +
                '  LEFT JOIN ' + this.ctx.service.pay.tableName + ' As P ' +
                '  ON SP.pid = P.id' +
                '  WHERE SP.`sid` = ? AND SP.`stimes` = ? AND SP.`sorder` = ? AND SP.`pid` = P.`id` AND P.`valid`' +
                '  ORDER BY P.`order`';
            const sqlParam = [sid, times, order];
            return await this.db.query(sql, sqlParam);
        }

        /**
         * 新增期时，初始化 期--合同支付 数据
         * @param {Object} stage - 新增的期
         * @param transaction - 事务
         * @returns {Promise<void>}
         */
        async addInitialStageData(stage, transaction) {
            const basesReg = new RegExp(payConst.calcBase.map(x => {return '(' + x.code + ')'}).join('|'));
            if (!stage) {
                throw '初始化期合同支付数据失败';
            }
            let pays = await this.ctx.service.pay.getAllDataByCondition({where: { tid: this.ctx.tender.id } });
            // 兼容旧项目，无初始化合同支付数据
            if (!pays || pays.length === 0) {
                const result = await this.ctx.service.pay.addDefaultPayData(this.ctx.tender.id, transaction);
                if (!result) {
                    throw '初始化合同支付数据失败';
                }
                pays = await transaction.select(this.ctx.service.pay.tableName, {where: { tid: this.ctx.tender.id } });
            }
            const stagePays = [];
            // 获取截止上期数据
            if (stage.order > 1) {
                const preStage = await this.ctx.service.stage.getDataByCondition({tid: stage.tid, order: stage.order - 1});
                if (!preStage) {
                    throw '标段数据有误';
                }
                const prePays = await this.getStageLastestPays(preStage.id);
                for (const pp of prePays) {
                    const p = this._.find(pays, {id: pp.pid});
                    stagePays.push({
                        tid: p.tid, sid: stage.id, pid: p.id,
                        stimes: stage.times, sorder: 0,
                        name: pp.name,
                        expr: (p.ptype === payConst.payType.normal || p.ptype === payConst.payType.sf)
                            ? (basesReg.test(pp.expr) ? pp.expr : null)
                            : (p.type === payConst.wc ? pp.expr : null),
                        pause: pp.pause,
                        pre_tp: pp.end_tp,
                        pre_used: pp.pre_used || !this.ctx.helper.checkZero(pp.tp),
                        pre_finish: pp.pre_finish || (pp.rprice ? pp.end_tp === pp.rprice : false),
                        start_stage_order: pp.start_stage_order,
                    });
                }
            } else {
                for (const p of pays) {
                    stagePays.push({
                        tid: p.tid, sid: stage.id, pid: p.id,
                        stimes: stage.times, sorder: 0, expr: p.expr, name: p.name,
                    });
                }
            }
            let result;
            if (transaction) {
                result = await transaction.insert(this.tableName, stagePays);
            } else {
                result = await this.db.insert(this.tableName, stagePays);
            }
            return result.affectedRows === stagePays.length;
        }

        async getStagePay(stage, pid) {
            return await this.getAuditorStagePay(pid, stage.id, stage.curTimes, stage.curOrder);
        }

        /**
         * 获取某期合同支付数据
         *
         * @param {Object} stage - 期数据(通过StageController._getStageData()获取)
         * @returns {Promise<*>}
         */
        async getStagePays(stage) {
            return await this.getAuditorStageData(stage.id, stage.curTimes, stage.curOrder);
        }

        /**
         * 获取某期最后数据(不限制该期是否已经审批通过)
         *
         * @param {Number} sid - 期id
         * @returns {Promise<*>}
         */
        async getStageLastestPays(sid) {
            const sql = 'SELECT SP.*, P.`order`, P.uid, P.minus, P.ptype, P.sprice, P.sexpr, P.rprice, P.rexpr, P.is_yf, P.dl_type, P.dl_count, P.dl_tp_type, P.dl_tp ' +
                '  FROM ' + this.tableName + ' As SP' +
                '  INNER JOIN ' + this.ctx.service.pay.tableName + ' As P ON SP.pid = P.id' +
                '  INNER JOIN ( ' +
                '    SELECT MAX(`stimes` * ' + timesLen + ' + `sorder`) As `sprogress` ' +
                '      FROM ' + this.tableName +
                '      WHERE `sid` = ? ' +
                '      GROUP BY `sid`) As M ON (SP.`stimes` * ' + timesLen + ' + SP.`sorder`) = M.`sprogress`' +
                '  WHERE SP.`sid` = ? AND P.`valid` = true' +
                '  ORDER BY P.`order`';
            const sqlParam = [sid, sid];
            return await this.db.query(sql, sqlParam);
        }

        /**
         * 同步新增 (仅供合同支付新增时调用)
         * @param {Object} pay - 合同支付项数据
         * @param transaction - 新增合同支付的事务
         * @returns {Promise<{tid, sid: number|*, pid, stimes: number|*, sorder: number|*}>}
         */
        async syncAdd(pay, transaction) {
            const stagePay = {
                tid: pay.tid,
                sid: pay.csid,
                pid: pay.id,
                stimes: pay.cstimes,
                sorder: pay.csaorder,
            };
            const result = await transaction.insert(this.tableName, stagePay);
            if (result.affectedRows !== 1) {
                throw '新增数据失败';
            }
            stagePay.id = result.insertId;
            return stagePay;
        }

        /**
         * 保存本期金额/表达式
         * @param data
         * @returns {Promise<void>}
         */
        async save(saveData) {
            const datas = saveData instanceof Array ? saveData : [saveData], updateDatas = [];
            const stagePays = await this.getStagePay(this.ctx.stage, this._.map(datas, 'pid'));
            for (const data of datas) {
                const stagePay = stagePays.find(function (x) {
                    return x.pid === data.pid;
                });
                const updateData = {id: stagePay.id};
                if (data.name !== undefined) { updateData.name = data.name }
                if (data.expr !== undefined) { updateData.expr = data.expr }
                if (data.tp !== undefined) { updateData.tp = data.tp }
                if (data.pause !== undefined) { updateData.pause = data.pause }
                if (data.postil !== undefined) updateData.postil = data.postil;
                updateDatas.push(updateData);
            }
            const result = await this.db.updateRows(this.tableName, updateDatas);
            if (result.affectedRows !== updateDatas.length) {
                throw '保存数据失败';
            }
        }

        /**
         * 计算
         * @param stage
         * @param transaction
         * @returns {Promise<boolean>}
         */
        async calcAllStagePays(stage, transaction) {
            if (!stage || !transaction) {
                throw '计算数据错误';
            }
            const stagePays = await this.getStagePays(stage);
            const PayCalculator = require('../lib/pay_calc');
            const payCalculator = new PayCalculator(this.ctx, stage, this.ctx.tender.info);
            await payCalculator.calculateAll(stagePays);
            const srUpdate = [], update = [];
            for (const sp of stagePays) {
                update.push({
                    id: sp.id,
                    tp: sp.tp,
                    end_tp: sp.end_tp,
                    start_stage_order: sp.start_stage_order && sp.start_stage_order < stage.order
                        ? sp.start_stage_order
                        : (this.ctx.helper.checkZero(sp.tp) ? null : stage.order),
                });
                srUpdate.push({
                    id: sp.pid,
                    sprice: sp.sprice,
                    rprice: sp.rprice,
                });
            }
            await transaction.updateRows(this.tableName, update);
            if (srUpdate.length > 0) {
                await transaction.updateRows(this.ctx.service.pay.tableName, srUpdate);
            }
            const yf = this._.find(stagePays, {ptype: payConst.payType.yf});
            const sf = this._.find(stagePays, {ptype: payConst.payType.sf});
            return [yf, sf];
        }

        async getSpecialTotalPrice(stage) {
            if (!stage) throw '计算数据错误';
            const stagePays = await this.getStagePays(stage);
            const PayCalculator = require('../lib/pay_calc');
            const tenderInfo = await this.ctx.service.tenderInfo.getTenderInfo(stage.tid);
            const payCalculator = new PayCalculator(this.ctx, stage, tenderInfo);
            await payCalculator.calculateAll(stagePays);
            const yf = this._.find(stagePays, {ptype: payConst.payType.yf});
            const sf = this._.find(stagePays, {ptype: payConst.payType.sf});
            return { yf: yf ? yf.tp : 0, sf: sf ? sf.tp : 0 };
        }

        async getHistorySf(stage) {
            if (!stage) return 0;
            const stagePays = stage.status === auditConst.stage.status.checked
                ? await this.getStageLastestPays(stage.id)
                : await this.getStagePays(stage);
            const sf = this._.find(stagePays, {ptype: payConst.payType.sf});
            return sf;
        }

        /**
         * 拷贝上一操作人数据 为 下一操作人数据
         * @param stage - 期数据
         * @param times - 下一操作人 该期第几次
         * @param order - 下一操作人顺序
         * @param transaction - 事务
         * @returns {Promise<*>}
         */
        async copyAuditStagePays(stage, times, order, transaction) {
            if (!stage || !transaction || !times || order === undefined) {
                throw '数据错误';
            }
            const sql = 'INSERT INTO ?? (`tid`, `sid`, `pid`, `stimes`, `sorder`, `name`, `tp`, `expr`, `pause`,' +
                        '    `pre_tp`, `end_tp`, `pre_used`, `pre_finish`, `start_stage_order`, `postil`) ' +
                        '  SELECT SP.`tid`, SP.`sid`, SP.`pid`, ?, ?, SP.name, SP.`tp`, SP.`expr`, SP.`pause`,' +
                        '     SP.`pre_tp`, SP.`end_tp`, SP.`pre_used`, SP.`pre_finish`, SP.`start_stage_order`, SP.`postil` ' +
                        '  FROM ?? As SP' +
                        '  WHERE SP.`sid` = ? AND SP.`stimes` = ? AND SP.`sorder` = ?';
            const sqlParam = [this.tableName, times, order, this.tableName, stage.id, stage.curTimes, stage.curOrder];
            return await transaction.query(sql, sqlParam);
        }

        async getLastestPayId(id) {
            const info = await this.getDataById(id);
            const sql = 'SELECT SP.* FROM ?? As SP WHERE SP.`sid` = ? AND SP.`pid` = ? ORDER BY SP.`stimes` DESC, SP.`sorder` DESC';
            const sqlParam = [this.tableName, info.sid, info.pid];
            const lst = await this.db.queryOne(sql, sqlParam);
            if (!lst || !lst.id) throw '数据错误';
            return lst.id;
        }

        /**
         * 拷贝上一操作人数据 为 下一操作人数据
         * @param stage - 期数据
         * @param times - 下一操作人 该期第几次
         * @param order - 下一操作人顺序
         * @param transaction - 事务
         * @returns {Promise<*>}
         */
        async copyStagePays4DeleteTimes(stage, times, order, copyTimes, copyOrder, transaction) {
            const sql = 'INSERT INTO ?? (`tid`, `sid`, `pid`, `stimes`, `sorder`, `name`, `tp`, `expr`, `pause`,' +
                '    `pre_tp`, `end_tp`, `pre_used`, `pre_finish`, `start_stage_order`) ' +
                '  SELECT SP.`tid`, SP.`sid`, SP.`pid`, ?, ?, SP.name, SP.`tp`, SP.`expr`, SP.`pause`,' +
                '     SP.`pre_tp`, SP.`end_tp`, SP.`pre_used`, SP.`pre_finish`, SP.`start_stage_order` ' +
                '  FROM ?? As SP, ?? As P ' +
                '  WHERE SP.`sid` = ? AND SP.`stimes` = ? AND SP.`sorder` = ? And SP.`pid` = P.`id` And P.`valid`';
            const sqlParam = [this.tableName, times, order, this.tableName, this.ctx.service.pay.tableName,
                stage.id, copyTimes, copyOrder];
            return await transaction.query(sql, sqlParam);
        }
    }

    return StagePay;
};