'use strict';

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

const Ledger = require('./ledger');

class Settle {
    constructor (ctx) {
        this.ctx = ctx;
        this.settleStatus = ctx.service.settle.settleStatus;
    }

    async _loadLatestStageData() {
        this.settle.latestStage = await this.ctx.service.stage.getLastestCompleteStage(this.settle.tid);
        this.ledgerColumn = [
            'id', 'tender_id', 'ledger_id', 'ledger_pid', 'level', 'order', 'full_path', 'is_leaf',
            'code', 'b_code', 'name', 'unit', 'unit_price',
            'quantity', 'total_price', 'memo', 'drawing_code', 'node_type'];
        const ledgerData = await this.ctx.service.ledger.getAllDataByCondition({ columns: this.ledgerColumn, where: { tender_id: this.settle.tid } });
        const endLedgerData = await this.ctx.service.stageBillsFinal.getAllDataByCondition({ where: { sid: this.settle.latestStage.id } });
        this.ctx.helper.assignRelaData(ledgerData, [
            { data: endLedgerData, fields: ['contract_qty', 'contract_tp', 'qc_qty', 'qc_tp', 'qc_minus_qty'], prefix: 'settle_', relaId: 'lid' },
        ]);

        this.posColumn = ['id', 'tid', 'lid', 'name', 'position', 'porder', 'quantity', 'add_stage_order', 'drawing_code'];
        const posData = await this.ctx.service.pos.getAllDataByCondition({ columns: this.posColumn, where: { tid: this.settle.tid } });
        const endPosData = await this.ctx.service.stagePosFinal.getAllDataByCondition({ where: { sid: this.settle.latestStage.id } });
        this.ctx.helper.assignRelaData(posData, [
            { data: endPosData, fields: ['contract_qty', 'qc_qty', 'qc_minus_qty'], prefix: 'settle_', relaId: 'pid' },
        ]);

        this.stageTree = new Ledger.billsTree(this.ctx, {
            id: 'ledger_id', pid: 'ledger_pid', order: 'order', level: 'level', rootId: -1,
            calcFields: ['total_price', 'settle_gather_tp', 'settle_contract_tp', 'settle_qc_tp']
        });
        this.stageTree.loadDatas(ledgerData);
        this.stageTree.calculateAll();

        this.stagePos = new Ledger.pos({ id: 'id', ledgerId: 'lid' });
        this.stagePos.loadDatas(posData);
    }

    async _loadSettleSelect() {
        const select = await this.ctx.service.settleSelect.getAllDataByCondition({ where: { settle_id: this.settle.id } });
        for (const s of select) {
            if (s.pid) {
                const sp = this.stagePos.getPos(s.pid);
                if (!sp) continue;
                sp.is_settle = true;
                sp.selected = true;
                sp.is_org_settle = 1;
                const sb = this.stageTree.nodes.find(x => { return x.id === sp.lid });
                sb.is_settle = true;
                const parents = this.stageTree.getAllParents(sb);
                parents.forEach(p => { p.is_settle = true; });
            }
            if (s.lid) {
                const sb = this.stageTree.nodes.find(x => { return x.id === s.lid });
                sb.is_settle = true;
                sb.selected = true;
                sb.is_org_settle = 1;
                const parents = this.stageTree.getAllParents(sb);
                parents.forEach(p => { p.is_settle = true; });
                const posterity = this.stageTree.getPosterity(sb);
                for (const p of posterity) {
                    p.is_settle = true;
                    const pos = this.stagePos.getLedgerPos(p.id);
                    if (pos && pos.length > 0) pos.forEach(x => { x.is_settle = true; });
                }
            }
        }
    }

    async _loadStageChange() {
        this.stageChange = await this.ctx.service.stageChangeFinal.getUnSettleChangeData(this.settle.latestStage);
        for (const change of this.stageChange) {
            const sb = this.stageTree.datas.find(x => { return x.id === change.gcl_id });
            if (sb) sb.undoneChange = true;
            if (change.mx_id) {
                const sp = this.stagePos.getPos(change.mx_id);
                if (sp) sp.undoneChange = true;
            }
        }
    }

    async _loadPreSettle() {
        if (this.settle.settle_order <= 1) return;
        const prePos = await this.ctx.service.settlePos.getAllDataByCondition({ where: { tid: this.settle.tid, settle_order: this.settle.settle_order - 1 } });
        for (const pp of prePos) {
            const sp = this.stagePos.getPos(pp.pid);
            if (sp) {
                sp.pre_settle = true;
                sp.pre_contract_qty = pp.end_contract_qty;
                sp.pre_qc_qty = pp.end_qc_qty;
                sp.pre_qc_minus_qty = pp.end_qc_minus_qty;
                sp.settle_status = pp.settle_status;
                sp.settle_done_order = pp.settle_done_order;
                sp.is_org_settle = pp.is_org_settle;
            }
        }
        const preBills = await this.ctx.service.settleBills.getAllDataByCondition({ where: { tid: this.settle.tid, settle_order: this.settle.settle_order - 1 } });
        for (const pb of preBills) {
            const sb = this.stageTree.nodes.find(x => { return x.id === pb.lid });
            if (sb) {
                sb.pre_settle = true;
                sb.pre_contract_qty = pb.end_contract_qty;
                sb.pre_contract_tp = pb.end_contract_tp;
                sb.pre_qc_qty = pb.end_qc_qty;
                sb.pre_qc_tp = pb.end_qc_tp;
                sb.pre_qc_minus_qty = pb.end_qc_minus_qty;
                sb.settle_status = pb.settle_status;
                sb.settle_done_order = pb.settle_done_order;
                sb.is_org_settle = pb.is_org_settle;
            }
        }
        // this.stageTree.initNodeData('settle_status', this.settleStatus.non, values => { return values.length === 1 ? values[0] : this.settleStatus.part});
    }

    calculateSettle() {
        const helper = this.ctx.helper;
        const settle = this.settle;
        const settleStatus = this.settleStatus;
        this.stagePos.calculateAll(function(p) {
            if (p.is_settle && !p.pre_settle) {
                p.cur_contract_qty = p.settle_contract_qty;
                p.cur_qc_qty = p.settle_qc_qty;
                p.cur_qc_minus_qty = p.settle_qc_minus_qty;
            }
            if (p.is_settle || p.pre_settle) {
                p.end_contract_qty = helper.add(p.cur_contract_qty, p.pre_contract_qty);
                p.end_qc_qty = helper.add(p.cur_qc_qty, p.pre_qc_qty);
                p.end_qc_minus_qty = helper.add(p.cur_qc_minus_qty, p.pre_qc_minus_qty);
            }
            if (helper.numEqual(p.end_contract_qty, p.quantity)) {
                p.settle_status = settleStatus.finish;
                p.settle_done_order = p.settle_done_order || settle.settle_order;
            }
        });
        const self = this, decimal = this.ctx.tender.info.decimal;
        this.stageTree.calculateAll(function(b) {
            if (b.children && b.children.length > 0) return;

            if (b.is_settle) {
                const posRange = self.stagePos.getLedgerPos(b.id);
                if (posRange && posRange.length > 0) {
                    posRange.forEach(p => {
                        b.cur_contract_qty = helper.add(b.cur_contract_qty, p.cur_contract_qty);
                        b.cur_qc_qty = helper.add(b.cur_qc_qty, p.cur_qc_qty);
                        b.cur_qc_minus_qty = helper.add(b.cur_qc_minus_qty, p.cur_qc_minus_qty);
                    });
                } else {
                    if (!b.pre_settle) {
                        b.cur_contract_qty = b.settle_contract_qty;
                        b.cur_qc_qty = b.settle_qc_qty;
                        b.cur_qc_minus_qty = b.settle_qc_minus_qty;
                    }
                }
                b.cur_contract_tp = helper.mul(b.unit_price, b.cur_contract_qty, decimal.tp);
                b.cur_qc_tp = helper.mul(b.unit_price, b.cur_qc_qty, decimal.tp);
            }
            if (b.is_settle || b.pre_settle) {
                b.end_contract_qty = helper.add(b.cur_contract_qty, b.pre_contract_qty);
                b.end_contract_tp = helper.add(b.cur_contract_tp, b.pre_contract_tp);
                b.end_qc_qty = helper.add(b.cur_qc_qty, b.pre_qc_qty);
                b.end_qc_tp = helper.add(b.cur_qc_tp, b.pre_qc_tp);
                b.end_qc_minus_qty = helper.add(b.cur_qc_minus_qty, b.pre_qc_minus_qty);
            }
            if (!b.end_contract_qty) {
                if (helper.numEqual(b.end_contract_tp, b.total_price)) {
                    b.settle_status = settleStatus.finish;
                    b.settle_done_order = b.settle_done_order || settle.settle_order;
                } else {
                    b.settle_status = settleStatus.part;
                }
            } else {
                if (helper.numEqual(b.end_contract_qty, b.quantity)) {
                    b.settle_status = settleStatus.finish;
                    b.settle_done_order = b.settle_done_order || settle.settle_order;
                } else {
                    b.settle_status = settleStatus.part;
                }
            }
        });
        this.stageTree.initNodeData('settle_status', this.settleStatus.non, values => { return values.length === 1 ? values[0] : this.settleStatus.part});
    }

    getSettleData() {
        const settleBills = [];
        const sum = {};
        for (const node of this.stageTree.nodes) {
            if (!node.is_settle && !node.pre_settle) continue;
            settleBills.push({
                tid: this.settle.tid, settle_id: this.settle.id, settle_order: this.settle.settle_order,
                lid: node.id, tree_id: node.ledger_id, tree_pid: node.ledger_pid, tree_full_path: node.full_path,
                tree_is_leaf: node.is_leaf, tree_level: node.level, tree_order: node.order,
                code: node.code || '', b_code: node.b_code || '', name: node.name || '', unit: node.unit || '',
                unit_price: node.unit_price || 0, quantity: node.quantity || 0, total_price: node.total_price || 0,
                drawing_code: node.drawing_code || '', memo: node.memo || '', node_type: node.node_type || 0,
                cur_contract_qty: node.cur_contract_qty || 0, cur_contract_tp: node.cur_contract_tp || 0,
                cur_qc_qty: node.cur_qc_qty || 0, cur_qc_tp: node.cur_qc_tp || 0, cur_qc_minus_qty: node.cur_qc_minus_qty || 0,
                pre_contract_qty: node.pre_contract_qty || 0, pre_contract_tp: node.pre_contract_tp || 0,
                pre_qc_qty: node.pre_qc_qty || 0, pre_qc_tp: node.pre_qc_tp || 0, pre_qc_minus_qty: node.pre_qc_minus_qty || 0,
                end_contract_qty: node.end_contract_qty || 0, end_contract_tp: node.end_contract_tp || 0,
                end_qc_qty: node.end_qc_qty || 0, end_qc_tp: node.end_qc_tp || 0, end_qc_minus_qty: node.end_qc_minus_qty || 0,
                is_settle: node.is_settle ? 1 : 0, is_org_settle: node.is_org_settle || 0, pre_settle: node.pre_settle ? 1 : 0,
                settle_status: node.settle_status || this.settleStatus.non, settle_done_order: node.settle_done_order || 0,
            });
            sum.contract_tp = this.ctx.helper.add(sum.contract_tp, node.cur_contract_tp);
            sum.qc_tp = this.ctx.helper.add(sum.qc_tp, node.cur_qc_tp);
        }
        sum.tp = this.ctx.helper.add(sum.contract_tp, sum.qc_tp);
        const settlePos = [];
        for (const pos of this.stagePos.datas) {
            if (!pos.is_settle && !pos.pre_settle) continue;
            settlePos.push({
                tid: this.settle.tid, settle_id: this.settle.id, settle_order: this.settle.settle_order,
                lid: pos.lid, pid: pos.id,
                name: pos.name || '', drawing_code: pos.drawing_code || '', position: pos.position || '', porder: pos.porder || 1,
                cur_contract_qty: pos.cur_contract_qty || 0, cur_qc_qty: pos.cur_qc_qty || 0, cur_qc_minus_qty: pos.cur_qc_minus_qty || 0,
                pre_contract_qty: pos.pre_contract_qty || 0, pre_qc_qty: pos.pre_qc_qty || 0, pre_qc_minus_qty: pos.pre_qc_minus_qty || 0,
                end_contract_qty: pos.end_contract_qty || 0, end_qc_qty: pos.end_qc_qty || 0, end_qc_minus_qty: pos.end_qc_minus_qty || 0,
                is_settle: pos.is_settle ? 1 : 0, is_org_settle: pos.is_org_settle || 0, pre_settle: pos.pre_settle ? 1 : 0,
                settle_status: pos.settle_status || this.settleStatus.non, settle_done_order: pos.settle_done_order || 0,
            });
        }
        return [settleBills, settlePos, sum];
    }

    async doSettle(settle) {
        this.settle = settle;

        await this._loadLatestStageData(settle);
        await this._loadSettleSelect();
        await this._loadPreSettle();
        this.calculateSettle();
        return this.getSettleData();
    }

    _initPosUndone(pos) {
        pos.undoneDeal = pos.quantity ? !this.ctx.helper.numEqual(pos.settle_contract_qty, pos.quantity) : false;
        pos.undone = !!pos.undoneDeal || !!pos.undoneChange;
    }

    _initNodeUndone(node) {
        if (node.undoneDeal === undefined) node.undoneDeal = false;
        if (node.undoneChange === undefined) node.undoneChange = false;
        if (node.children && node.children.length > 0) {
            for (const child of node.children) {
                this._initNodeUndone(child);
                if (child.undoneDeal) node.undoneDeal = true;
                if (child.undoneChange) node.undoneChange = true;
            }
            node.undone = !!node.undoneDeal || !!node.undoneChange;
        } else {
            const posRange = this.stagePos.getLedgerPos(node.id);
            if (posRange && posRange.length > 0) {
                for (const pos of posRange) {
                    this._initPosUndone(pos);
                    if (pos.undoneDeal) node.undoneDeal = true;
                    if (pos.undoneChange) node.undoneChange = true;
                }
                node.undone = !!node.undoneDeal || !!node.undoneChange;
            } else {
                node.undoneDeal = node.settle_contract_qty
                    ? !this.ctx.helper.numEqual(node.settle_contract_qty, node.quantity)
                    : !this.ctx.helper.numEqual(node.settle_contract_tp, node.total_price);
                node.undone = !!node.undoneDeal || !!node.undoneChange;
            }
        }
    }

    _checkNodeError(node) {
        const billsError = !!node.selected && node.undone;
        if (billsError) return billsError;
        const posRange = !node.children || node.children.length === 0 ? (this.stagePos.getLedgerPos(node.id) || []) : [];
        for (const pos of posRange) {
            if (!!pos.selected && pos.undone) return true;
        }
        return false;
    }

    checkAllSelect() {
        for (const node of this.stageTree.children) {
            this._initNodeUndone(node);
        }
        this.error = [];
        for (const node of this.stageTree.nodes) {
            if (this._checkNodeError(node)) this.error.push(node);
        }
        return this.error.length === 0;
    }

    async checkSettle(settle) {
        this.settle = settle;
        await this._loadLatestStageData(settle);
        await this._loadSettleSelect();
        await this._loadStageChange();
        return this.checkAllSelect();
    }
}

module.exports = Settle;