'use strict';

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

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

        async getData(spid) {
            const data = await this.getAllDataByCondition({where: { spid }, orders: [['push_order', 'asc']]});
            return data;
        }

        async _addDatas(data) {
            const spid = this.ctx.subProject.id;
            const datas = data instanceof Array ? data : [data];
            const insertData = [];
            for (const d of datas) {
                if (!d.push_order) throw '提交的数据错误';
                const nd = {
                    id: this.uuid.v4(),
                    spid: this.ctx.subProject.id,
                    user_id: this.ctx.session.sessionUser.accountId,
                    update_user_id: this.ctx.session.sessionUser.accountId,
                    push_order: d.push_order,
                };
                if (d.push_date !== undefined) nd.push_date = d.push_date;
                if (d.push_content !== undefined) nd.push_content = d.push_content;
                if (d.memo !== undefined) nd.memo = d.memo;
                insertData.push(nd);
            }
            const push_order = this.ctx.helper._.min(insertData.map(x => { return x.push_order}));

            const conn = await this.db.beginTransaction();
            try {
                await conn.query(`UPDATE ${this.tableName} SET push_order = push_order + ? WHERE spid = ? AND push_order >= ?`, [insertData.length, spid, push_order]);
                await conn.insert(this.tableName, insertData);
                await conn.commit();
            } catch(err) {
                await conn.rollback();
                throw err;
            }
            const add = await this.getAllDataByCondition({ where: { spid: this.ctx.subProject.id, id: this.ctx.helper._.map(insertData, 'id') } });
            const update = await this.db.query(`SELECT * FROM ${this.tableName} WHERE spid = ? AND push_order >= ?`, [spid, push_order + insertData.length]);
            return { add, update };
        }

        async _delDatas (data) {
            const spid = this.ctx.subProject.id;
            const datas = data instanceof Array ? data : [data];
            const orgDatas = await this.getAllDataByCondition({ where: { id: datas }});
            const push_order = this.ctx.helper._.min(orgDatas.map(x => { return x.push_order}));

            const conn = await this.db.beginTransaction();
            try {
                await conn.delete(this.tableName, {id: datas});
                await conn.update(this.ctx.service.subProjFile.tableName, { is_deleted: 1}, { where: { spid: this.ctx.subProject.id, type: 'push', rela_id: datas } });
                await conn.query(`UPDATE ${this.tableName} SET push_order = push_order - ? WHERE spid = ? AND push_order >= ?`, [datas.length, spid, push_order + datas.length]);
                await conn.commit();
            } catch(err) {
                await conn.rollback();
                throw err;
            }
            const update = await this.db.query(`SELECT * FROM ${this.tableName} WHERE spid = ? AND push_order >= ?`, [spid, push_order]);
            return { del: datas, update };
        }

        async _updateDatas (data) {
            const datas = data instanceof Array ? data : [data];

            const uDatas = [];
            for (const d of datas) {
                const nd = { id: d.id };
                if (d.push_order !== undefined) nd.push_order = d.push_order;
                if (d.push_date !== undefined) nd.push_date = d.push_date;
                if (d.push_content !== undefined) nd.push_content = d.push_content;
                if (d.memo !== undefined) nd.memo = d.memo;
                uDatas.push(nd);
            }
            if (uDatas.length > 0) {
                await this.db.updateRows(this.tableName, uDatas);
                return uDatas;
            } else {
                return [];
            }
        }

        async updateDatas(data) {
            const result = {add: [], del: [], update: []};
            try {
                if (data.add) {
                    const addResult = await this._addDatas(data.add);
                    result.add.push(...addResult.add);
                    result.update.push(...addResult.update);
                }
                if (data.update) {
                    result.update = await this._updateDatas(data.update);
                }
                if (data.del) {
                    const delResult = await this._delDatas(data.del);
                    result.del.push(...delResult.del);
                    result.update.push(...delResult.update);
                }
                return result;
            } catch (err) {
                if (err.stack) {
                    throw err;
                } else {
                    result.err = err.toString();
                    return result;
                }
            }
        }
    }

    return SubProjPush;
};