import cuid from "cuid";
import _ from "lodash";
import LogHelper from "./LogHelper.mjs";

class DataLogHelper {
    name = "";
    type = "";
    id = null;

    constructor({
        name,
        type
    }) {
        this.name = name;
        this.type = type;
    }

    async addDataLog({
        data
    }) {
        const {
            name,
            type
        } = this;
        if (name != "dataLog") {
            //  记录数据操作日志
            const {
                data: _dataLogData
            } = await LogHelper.addDataLog({
                tableName: name,
                type,
                data
            });

            this.id = _dataLogData.id;
        }
    }

    async modifyDataLogStatus() {
        const {
            name,
            id
        } = this;
        if (name != "dataLog" && id) {
            //  更新日志状态
            await LogHelper.modifyDataLogStatus({
                id
            });
        }
    }
}

// 它代表创建（Create）、更新（Update）、读取（Retrieve）和删除（Delete）操作。
export default class CURDHelper {
    /**
     * 读取列表数据
     * @param {*} param0 
     * @returns 
     */
    static async retrieveList({
        db,
        name,
        params
    }) {
        await db.read();
        /******************************参数过滤**********************************/
        const data = db.data[name].filter((item) => {
            let isMatch = true;
            for (let field in params) {
                if (["page", "pageSize"].includes(field)) {
                    continue;
                }

                if (typeof (item[field]) == "string") {
                    isMatch = item[field].indexOf(params[field]) > -1;
                } else if (typeof (item[field]) == "number") {
                    isMatch = item[field] == params[field];
                }
                else if (item[field] instanceof Array) {
                    //  数据为数组的情况进行比较
                    isMatch = item[field].includes(params[field]);
                }

                if (!isMatch)
                    break;
            }
            return isMatch;
        });
        /******************************参数过滤**********************************/

        /******************************分页过滤**********************************/
        const {
            page,
            pageSize
        } = params;
        let batchData = data;
        if (page && pageSize) {
            batchData = data.slice((page - 1) * pageSize, page * pageSize);
        }
        /******************************分页过滤**********************************/

        return {
            code: 0,
            data: batchData.sort((a, b) => {
                return a.sort - b.sort;
            }) || [],
            total: data.length
        };
    }

    /**
     * 读取单条数据
     * @param {*} param0 
     */
    static async retrieveSingle({
        db,
        name,
        params
    }) {
        await db.read();
        const data = db.data[name];
        const query = params;

        let detail = {};
        if (query.id && data) {
            detail = data.find((item) => {
                return item.id == query.id;
            });
        }

        return {
            code: 0,
            data: detail || {}
        };
    }

    /**
     * 修改数据
     * @param {*} param0 
     */
    static async update({
        db,
        name,
        data
    }) {
        await db.read();

        // You can also use this syntax if you prefer
        if (!db.data[name])
            db.data[name] = [];

        const dataList = db.data[name];

        const id = data.id;

        if (id && dataList) {
            const currentDetail = dataList.find(item => item.id == id);
            if (currentDetail) {
                _.merge(currentDetail, data);
            }

            const dLH = new DataLogHelper({
                name,
                type: "upd"
            });

            await dLH.addDataLog({
                data: currentDetail
            });

            // Write db.data content to db.json
            await db.write()

            await dLH.modifyDataLogStatus();
        }

        return {
            code: 0,
        };
    }

    /**
     * 创建数据
     * @param {*} param0 
     */
    static async create({
        db,
        name,
        data
    }) {
        await db.read();

        if (!db.data[name])
            db.data[name] = [];

        const dataList = db.data[name];

        data.id = cuid();
        data.createTime = new Date();
        dataList.push(data)

        const dLH = new DataLogHelper({
            name,
            type: "add"
        });

        await dLH.addDataLog({
            data
        });

        // Write db.data content to db.json
        await db.write()

        await dLH.modifyDataLogStatus();

        return {
            code: 0,
            data
        };
    }

    /**
     * 删除数据
     * @param {*} param0 
     * @returns 
     */
    static async delete({
        db,
        name,
        data
    }) {
        await db.read();

        // You can also use this syntax if you prefer
        if (!db.data[name])
            db.data[name] = [];

        const dataList = db.data[name];
        const ids = data.ids;

        if (ids.length > 0 && dataList) {
            let id = null;
            const delDataList = [];

            for (let i = 0; i < ids.length; i++) {
                id = ids[i];
                const idx = dataList.findIndex(item => item.id == id);
                if (idx != -1) {
                    delDataList.push(dataList[idx]);
                    dataList.splice(idx, 1);
                }
            }

            const dLH = new DataLogHelper({
                name,
                type: "del"
            });

            await dLH.addDataLog({
                data: delDataList
            });

            // Write db.data content to db.json
            await db.write()

            await dLH.modifyDataLogStatus();
        }

        return {
            code: 0,
        };
    }
}