/**
 * 版本管理业务逻辑模型
 *
 * @author CaiAoLin
 * @date 2017/7/28
 * @version
 */
import BaseModel from "../../common/base/base_model";
import VersionSchema from "./schemas/version";

class VersionModel extends BaseModel {

    /**
     * 允许的块
     *
     * @var {Array}
     */
    sectionList = ['bill', 'ration'];

    /**
     * 构造函数
     *
     * @return {void}
     */
    constructor() {
        let parent = super();
        parent.model = VersionSchema;
        parent.init();
    }

    /**
     * 获取版本列表
     *
     * @return {Promise}
     */
    async getVersionList() {
        // 筛选字段
        let field = {_id: 1, name: 1, "ration_valuation._id": 1, "ration_valuation.name": 1, "ration_valuation.enable": 1,
            "bill_valuation._id": 1, "bill_valuation.name": 1, "bill_valuation.enable": 1};
        let versionData = await this.findDataByCondition({name: {$ne: ''}}, field, false);

        return versionData === null ? [] : versionData;
    }

    /**
     * 设置场景
     *
     * @param {string} scene
     * @return {void}
     */
    setScene(scene = '') {
        switch (scene) {
            // 新增
            case 'add':
                this.model.schema.path('name').required(true);
                this.model.schema.path('creator').required(true);
                this.model.schema.path('create_time').required(true);
                break;
        }
    }

    /**
     * 新增版本
     *
     * @param {Object} data
     * @return {Promise}
     */
    async add(data) {
        let result = false;
        if (Object.keys(data).length <= 0) {
            return result;
        }

        this.setScene('add');
        data.create_time = new Date().getTime();
        result = this.db.create(data);
        return result;
    }

    /**
     * 新增计价规则
     *
     * @param {String} id
     * @param {String} section
     * @param {Object} data
     * @return {Promise}
     */
    async addValuation(id, section, data) {
        let condition = {_id: id};
        let versionData = await this.findDataByCondition(condition);
        if (versionData === null || versionData.name === undefined) {
            throw '没有找到对应的数据';
        }

        if (data.name === undefined || data.name === '') {
            throw '计价规则名称为空';
        }
        if (this.sectionList.indexOf(section) < 0) {
            throw '数据有误';
        }

        let insertData = {};
        insertData[section + '_valuation'] = data;
        let result = await this.db.addToSet(condition, insertData);

        return result.ok === undefined ? false : result.ok;
    }

    /**
     * 保存计价数据
     *
     * @param {String} valuationId
     * @param {Object} data
     * @return {Promise}
     */
    async saveValuation(valuationId, data) {
        data = this._filterValuationData(data);
        let sectionString = data.section + "_valuation";
        let condition = {};
        condition[sectionString + "._id"] = valuationId;

        let updateData = {};
        updateData[sectionString + ".$.bill_lib"] = data.bill_lib;
        updateData[sectionString + ".$.ration_lib"] = data.ration_lib;
        updateData[sectionString + ".$.name"] = data.name;
        updateData[sectionString + ".$.engineering"] = data.engineering;

        let result = await this.db.update(condition, updateData);

        return result !== null && result.ok === 1;
    };

    /**
     * 更改启用/禁用
     *
     * @param {String} valuationId
     * @param {String} section
     * @param {String} enable
     * @return {Promise}
     */
    async switchEnable(valuationId, section, enable) {
        let sectionString = section + "_valuation";
        let condition = {};
        condition[sectionString + "._id"] = valuationId;

        let updateData = {};
        updateData[sectionString + ".$.enable"] = enable === "true";

        let result = await this.db.update(condition, updateData);

        return result !== null && result.ok === 1;
    }

    /**
     * 过滤计价数据
     *
     * @param {Object} data
     * @return {Object}
     */
    _filterValuationData(data) {
        if (Object.keys(data).length <= 0) {
            throw '数据有误';
        }

        if (data.section === undefined || data.section === '' || this.sectionList.indexOf(data.section) < 0) {
            throw '类型错误';
        }

        // 判断名称
        if (data.name === undefined || data.name === '') {
            throw '名称不能为空';
        }
        // 判断工程专业
        if (data.engineering === undefined || data.engineering === '') {
            throw '名称不能为空';
        }
        data.engineering = parseInt(data.engineering);
        // 判断标准清单
        if (data.bill_lib === undefined || data.bill_lib === '') {
            throw '判断标准清单不能为空';
        }
        data.bill_lib = data.bill_lib instanceof Array ? data.bill_lib : [data.bill_lib];
        for(let tmp in data.bill_lib) {
            data.bill_lib[tmp] = JSON.parse(data.bill_lib[tmp]);
        }
        // 判断定额清单
        if (data.ration_lib === undefined || data.ration_lib === '') {
            throw '判断标准清单不能为空';
        }
        data.ration_lib = data.ration_lib instanceof Array ? data.ration_lib : [data.ration_lib];
        for(let tmp in data.ration_lib) {
            data.ration_lib[tmp] = JSON.parse(data.ration_lib[tmp]);
        }

        return data;
    }

    /**
     * 获取计价规则数据
     *
     * @param {String} versionId
     * @param {String} id
     * @param {String} section
     * @return {Promise|Array}
     */
    async getValuation(versionId, id, section) {
        if (this.sectionList.indexOf(section) < 0) {
            throw '数据有误';
        }
        let versionData = await this.findDataByCondition({_id: versionId});
        if (Object.keys(versionData).length <= 0) {
            throw '版本数据有误';
        }
        let result = {};
        let sectionString = section + '_valuation';

        for(let valuation of versionData[sectionString]) {
            if (valuation._id.toString() === id) {
                result = valuation;
                break;
            }
        }

        return [result, versionData[sectionString]];
        /* 数据库获取版本
        let condition = {_id: versionId};
        let childCondition = {};
        childCondition[sectionString] = {$elemMatch: {_id: id}};

        let result = await this.db.findOne(condition, childCondition);

        return result !== null && result.bill_valuation.length > 0 ? result.bill_valuation[0] : {};
        */
    }

    /**
     * 删除计价规则
     *
     * @param {String} versionId
     * @param {String} valuationId
     * @param {String} section
     * @return {Promise}
     */
    async deleteValuation(versionId, valuationId, section) {
        let condition = {_id: versionId};
        let sectionString = section + '_valuation';
        let deleteData = {};
        deleteData[sectionString] = {_id: valuationId};

        // 利用pull删除嵌套数据
        let result = await this.db.deleteSet(condition, deleteData);

        return result !== null && result.ok === 1;
    }

}

export default VersionModel;