/**
 * Created by jimiz on 2017/4/1.
 */
let mongoose = require("mongoose");
let db = require("../db/project_db");
let subSchema = require("./bills_sub_schemas");
let Schema = mongoose.Schema;
let deleteSchema = require('../../../public/models/delete_schema');
let async = require("async");
let counter = require("../../../public/counter/counter.js");
let consts = require('./project_consts');
let projectConsts = consts.projectConst;
let commonConsts = consts.commonConst;
let quantity_detial = require('../facade/quantity_detail_facade');

var rationAssItemSchema = mongoose.Schema({
    name: String,
    assistID: Number,
    assistCode: String,
    stdValue: Number,
    actualValue:Number,
    stepValue: String,
    decimal: Number,
    carryBit: String,
    minValue: String,
    maxValue: String
}, { _id: false });

let rationSchema = new Schema({
    ID: Number,
    projectID: Number,
    billsItemID: Number,
    serialNo: Number,
    libID: Number,
    code: String,
    name: String,
    maskName: String,
    caption: String,
    unit: String,
    quantity: String, // Decimal
    marketUnitFee: String,
    marketTotalFee: String,
    isFromDetail:{type: Number,default:0},  //1 true 2 false
    programID: Number,
    adjustState: String,
    content: String,
    rationProjName: String,
    // 说明
    comments: String,
    // 费用字段
    fees: [subSchema.feesSchema],
    // 标记字段
    flags: [subSchema.flagsSchema],
    deleteInfo: deleteSchema,
    rationAssList: [rationAssItemSchema],
    // 工作内容
    content: String,
    // 计算规则
    ruleText: String
});

let ration = db.model("ration", rationSchema, "ration");
let baseModel = require('./base_model');

class rationModel extends baseModel {
    constructor () {
        super(ration);
    }

    getData (projectID, callback) {
        ration.find({'$or': [{projectID: projectID, deleteInfo: null}, {projectID: projectID, 'deleteInfo.deleted': {$in: [null, false]}}]}, '-_id', function(err, datas){
            if (!err) {
                callback(0, projectConsts.RATION, datas);
            } else {
                callback(1, '', null);
            }
        });
    };

    save (user_id, datas, callback) {
        let functions = [];
        let data;

        function saveOne(doc) {
            return function (cb) {
                switch (doc.updateType) {
                    case commonConsts.UT_UPDATE:
                        ration.update({projectID: doc.updateData.projectID, ID: doc.updateData.ID, deleteInfo: null}, doc.updateData, cb);
                        break;
                    case commonConsts.UT_CREATE:
                        ration.create(doc.updateData, cb);
                        break;
                    case commonConsts.UT_DELETE:
                        doc.updateData.deleteInfo = {deleted: true, deleteDateTime: new Date(), deleteBy: user_id};
                        ration.update({projectID: doc.updateData.projectID, ID: doc.updateData.ID}, doc.updateData,{multi: true},cb);
                        break;
                }
            }
        }


        for (let i = 0; i < datas.length; i++){
            data = datas[i];
            functions.push(saveOne(data));
            quantity_detial.quantityEditChecking(data,'ration',functions);
        }
        async.parallel(functions, callback);
    };

    getItemTemplate (callback) {
        let data = new ration;
        /* to do: 需要根据标准配置库填充fees和flags字段，是否需要更多的参数？ */
        callback(0, '', data);
    };

    allocIDs (IDstep, callback) {
        counter.counterDAO.getIDAfterCount(counter.moduleName.ration, IDStep, function(err, highID){
            let lowID = highID - IDStep + 1;
            callback(0, '', {lowID: lowID, highID: highID});
        });
    };
};

module.exports = new rationModel();