'use strict';

/**
 * Created by EllisRan on 2020/3/3.
 */

const BaseService = require('../base/base_service');
const contractConst = require('../const/contract');

module.exports = app => {

    class ContractPay extends BaseService {

        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            this.tableName = 'contract_pay';
            this.dataId = 'id';
        }

        async getPays(options, cid) {
            const sql = 'SELECT * FROM ?? WHERE ' + this.ctx.helper._getOptionsSql(options) + ' AND `cid` = ? ORDER BY `create_time` DESC';
            const sqlParams = [this.tableName, cid];
            const list = await this.db.query(sql, sqlParams);
            if (list.length > 0) {
                const userList = await this.ctx.service.projectAccount.getAllDataByCondition({ where: { id: list.map(item => item.uid) } });
                for (const l of list) {
                    const userInfo = userList.find(item => item.id === l.uid);
                    l.username = userInfo ? userInfo.name : '';
                    l.files = await this.ctx.service.contractPayAtt.getAtt(l.id);
                }
            }
            return list;
        }

        async add(options, cid, data) {
            const node = await this.ctx.service.contract.getDataById(cid);
            if (!node) {
                throw '合同不存在';
            }
            const transaction = await this.db.beginTransaction();
            try {
                const insertData = {
                    spid: options.spid || null,
                    tid: options.tid || null,
                    contract_type: options.contract_type,
                    cid,
                    uid: this.ctx.session.sessionUser.accountId,
                    pay_time: data.pay_time,
                    pay_price: data.pay_price,
                    debit_price: data.debit_price,
                    yf_price: data.yf_price,
                    sf_price: data.sf_price,
                    pay_type: data.pay_type,
                    remark: data.remark,
                    create_time: new Date(),
                };
                await transaction.insert(this.tableName, insertData);
                await this.calcContract(transaction, node);
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
            return { pays: await this.getPays(options, cid), node: { update: node } };
        }

        async save(options, cid, data) {
            if (!data.id) {
                throw '参数有误';
            }
            const node = await this.ctx.service.contract.getDataById(cid);
            if (!node) {
                throw '合同不存在';
            }
            const cpInfo = await this.getDataById(data.id);
            if (!cpInfo) {
                throw '合同' + contractConst.typeName[cpInfo.contract_type] + '不存在';
            }
            const transaction = await this.db.beginTransaction();
            try {
                await transaction.update(this.tableName, data);
                await this.calcContract(transaction, node);
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
            return { pays: await this.getPays(options, cid), node: { update: node } };
        }

        async del(options, cid, cpid) {
            if (!cpid) {
                throw '参数有误';
            }
            const node = await this.ctx.service.contract.getDataById(cid);
            if (!node) {
                throw '合同不存在';
            }
            const cpInfo = await this.getDataById(cpid);
            if (!cpInfo) {
                throw '合同' + contractConst.typeName[cpInfo.contract_type] + '不存在';
            }
            if (cpInfo.fpcid) {
                throw '该合同' + contractConst.typeName[cpInfo.contract_type] + '关联了资金支付明细，不能删除';
            }
            const transaction = await this.db.beginTransaction();
            try {
                await transaction.delete(this.tableName, { id: cpid });
                // 删除合同附件
                const attList = await this.ctx.service.contractPayAtt.getAllDataByCondition({ where: { cpid } });
                await this.ctx.helper.delFiles(attList);
                await transaction.delete(this.ctx.service.contractPayAtt.tableName, { cpid });
                await this.calcContract(transaction, node);
                await transaction.commit();
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
            return { pays: await this.getPays(options, cid), node: { update: node } };
        }

        async calcContract(transaction, node) {
            const paysList = await transaction.query('SELECT * FROM ?? WHERE `cid` = ?', [this.tableName, node.id]);
            let pay_price = 0;
            let debit_price = 0;
            let yf_price = 0;
            let sf_price = 0;
            for (const l of paysList) {
                pay_price = this.ctx.helper.add(pay_price, l.pay_price);
                debit_price = this.ctx.helper.add(debit_price, l.debit_price);
                yf_price = this.ctx.helper.add(yf_price, l.yf_price);
                sf_price = this.ctx.helper.add(sf_price, l.sf_price);
            }
            node.pay_price = pay_price;
            node.debit_price = debit_price;
            node.yf_price = yf_price;
            node.sf_price = sf_price;
            node.exist_pay = paysList.length === 0 ? 0 : 1;
            await transaction.update(this.ctx.service.contract.tableName, node);
        }

        async createContractPays(transaction, fpid, uid, times, pays) {
            const addPays = [];
            const contracts = await transaction.select(this.ctx.service.contract.tableName, { where: { id: this._.uniq(this._.map(pays, 'cid')) } });
            for (const p of pays) {
                const contract = contracts.find(c => c.id === p.cid);
                if (contract) {
                    addPays.push({
                        spid: contract.spid || null,
                        tid: contract.tid || null,
                        contract_type: contract.contract_type,
                        cid: p.cid,
                        uid,
                        fpid,
                        fpcid: p.id,
                        pay_time: times,
                        pay_price: p.pay_price || 0,
                        debit_price: 0,
                        yf_price: p.pay_price || 0,
                        sf_price: p.settle_price || 0,
                        pay_type: p.pay_type || '',
                        remark: '',
                        create_time: times,
                    });
                }
            }
            if (addPays.length > 0) {
                await transaction.insert(this.tableName, addPays);
                for (const c of contracts) {
                    await this.calcContract(transaction, c);
                }
            }
        }

        async removeContractPays(transaction, fpid, pays) {
            await transaction.delete(this.tableName, { fpid });
            const contracts = await transaction.select(this.ctx.service.contract.tableName, { where: { id: this._.uniq(this._.map(pays, 'cid')) } });
            if (contracts.length > 0) {
                for (const c of contracts) {
                    await this.calcContract(transaction, c);
                }
            }
        }
    }
    return ContractPay;
};