import {ApiCall} from 'tsrpc';
import {ReqAddHuoDong} from '../../monopoly/protocols/PtlAddHuoDong';
import {ActionLog} from '../../public/actionLog/actionLog';
import {HuoDongFun} from '../../public/huodongfun';
import {PataFun} from '../../public/pata';
import {PayFun} from '../../public/pay';
import {ZhanLingTasks} from '../../public/zhanling';
import {jijinType} from '../../shared/protocols/event/jijin/PtlOpen';
import {hongdianKey, hongdianVal} from '../../shared/protocols/hongdian/PtlGet';
import {payLog} from '../../shared/protocols/pay/PtlGetList';
import {PublicShared} from '../../shared/public/public';
import {clslDb} from '../conglinshoulie/ApiOpen';
import {getVal} from '../event/jijin/ApiOpen';
import {getTaskVal} from '../event/kaifukuanghuan/ApiOpen';
import {YangChengMuBiaofun} from '../event/yangchengmubiao/fun';
import {checkIsOpen} from '../hbzb/jfs/ApiOpen';
import {PlayerShared} from "../../shared/public/player";
import {kbzzUserDb} from '../kbzz/ApiOpen';
import {PlayerFun} from "../../public/player";
import kfjsFun from "../../public/kaifujingsai";
import {RankKfjs} from "../../public/rank/rank_kfjs";
import {ShopFun} from "../../public/shop";
import {Christmasfun} from '../event/christmas/fun';

export class HongDianFun {
    /**黑榜争霸红点 */
    static async hbzBgetHongDian(call: ApiCall) {
        let _res: hongdianVal = {
            show: false
        };
        if (!checkIsOpen()) return _res;
        let data = await G.mongodb.cPlayerInfo('hbzb').findOne({uid: call.uid, type: 'hbzb'});
        let _mydata = (data && data.data && data.data.refreshTime >= PublicShared.getToDayZeroTime()) ? data.data : {
            winNum: 0,
            buyFightNum: 0,
            useFightNum: 0,
            refreshTime: G.time,
            winRecPrize: [],
            useRefreshNum: 0
        };
        if (_mydata.useFightNum < _mydata.buyFightNum + G.gc.hbzb.jfsFightNum) {
            _res.show = true;
        }
        if (!_res.show) {
            let _con = JSON.parse(JSON.stringify(G.gc.hbzb.jfsFightWinNumPrize));
            for (let index = 0; index < _con.length; index++) {
                const element = _con[index];
                if (_mydata.winRecPrize.includes(index)) continue;
                if (_mydata.winNum < element.total) continue;
                _res.show = true;
                break;
            }
        }
        return _res;
    }

    /**丛林狩猎红点 */
    static async clslgetHongDian(call: ApiCall) {
        let _res: hongdianVal = {
            show: false
        };
        let weekZeroTime = PublicShared.getToWeekMondayZeroTime();
        if (G.time < weekZeroTime + G.gc.clsl_com.fightTime[0] || G.time > weekZeroTime + G.gc.clsl_com.fightTime[1]) return _res;
        let _mydata = await clslDb().findOne({uid: call.uid, type: 'clsl'});
        let useNum = _mydata?.useFightNum || 0;
        let buyNum = _mydata?.buyFightNum || 0;
        if (useNum < buyNum + G.gc.clsl_com.fightNum) {
            _res.show = true;
        }

        if (!_res.show) {
            let fightWinNum = _mydata?.fightWinNum || 0;
            let _con = JSON.parse(JSON.stringify(G.gc.clsl_com.fightWinPrize));
            for (let index = 0; index < _con.length; index++) {
                const element = _con[index];
                if (_mydata?.recWinPrize?.includes(index)) continue;
                if (fightWinNum < element.total) continue;
                _res.show = true;
                break;
            }
        }
        return _res;
    }

    /**
     * 每日试炼 物资筹集 红点
     * types.money 休闲区
     * types.exp 物资部
     * types.qhs 加工仓库
     * _mydata.data.numInfo.[type].['0'] 下标‘0’原本是根据难度设定次数，改为次数共享后，取‘0’值统一计算次数
     **/
    static async mrslGetHongDian(call: ApiCall) {
        let _res = {
            show: false
        };
        let _mydata = await G.mongodb.cPlayerInfo('meirishilian').findOne({uid: call.uid, type: 'meirishilian'});
        let types = ['money', 'exp', 'qhs'];
        for (let type of types) {
            let buyNum = _mydata?.data?.numInfo?.[type]?.['0']?.buyFightNum || 0;
            let useNum = _mydata?.data?.numInfo?.[type]?.['0']?.useFightNum || 0;
            _res.show = useNum < buyNum + (PlayerShared.getMingDaoBuff(call.conn.gud, 'wzsj_free') || 0) + G.gc.meirishilian_com.fightNum
            if (_res.show) break
        }
        return _res;
    }

    /**势力争夺 红点 */
    static async slzdGetHongDian(call: ApiCall) {
        let _res = {
            show: false
        };
        let db = await G.mongodb.collection('slzdUser').findOne({uid: call.uid});

        let _mydata = (db && db.data && db.data.refreshTime >= PublicShared.getToDayZeroTime()) ? db.data : {
            fightNum: G.gc.slzd.ctorFightNum,
            winNum: 0,
            winRec: []
        };
        if (_mydata.fightNum >= 1) {
            _res.show = true;
        }

        if (!_res.show) {
            let _con = JSON.parse(JSON.stringify(G.gc.slzd.fightWinNumPrize));
            for (let index = 0; index < _con.length; index++) {
                const element = _con[index];
                if (_mydata.winRec.includes(index)) continue;
                if (_mydata.winNum < element.total) continue;
                _res.show = true;
                break;
            }
        }
        return _res;
    }

    /**清缴真主党 红点 */
    static async qjzzdGetHongDian(call: ApiCall) {
        let _res = {
            show: false
        };
        return _res
        let data = await G.mongodb.collection('scheduler').findOne({type: 'qjzzd'});
        if (!data) return _res;   // 功能未开放
        let db = await G.mongodb.cPlayerInfo('qjzzd').findOne({uid: call.uid, type: 'qjzzd'});

        let myData = (db && db.refreshTime >= data.lastRunTime) ? db : {
            refreshTime: data.lastRunTime,
            useFightNum: 0,
            maxDps: 0
        };
        if (myData.useFightNum < G.gc.qjzzd.fightNum) {
            _res.show = true;
        }
        return _res;
    }

    /**恐怖战争 红点 */
    static async kongbuzzHongDian(call: ApiCall) {
        let _res = {
            show: false
        };
        let second = G.time - PublicShared.getToWeekMondayZeroTime();
        if (second >= G.gc.kbzz.time.apply[0] && second < G.gc.kbzz.time.apply[1]) {
            // 报名时间
            let state = await G.mongodb.cPlayerInfo('kbzzApply').findOne({uid: call.uid, type: 'kbzzApply'});
            let apply = state?.apply || false;
            if (!apply) {
                _res.show = true;
                return _res;
            }
        } else {
            let dbData = await kbzzUserDb().findOne({uid: call.uid, type: 'kbzzUser'});
            let myData = dbData ? dbData : {
                score: G.gc.kbzz.playerScore,
                recScorePrize: [],
                toDayScore: 0,
                fightNum: G.gc.kbzz.fightNum
            };
            let conf = G.gc.kbzz.scorePrize;
            for (let index = 0; index < conf.length; index++) {
                const element = conf[index];
                if (myData.recScorePrize.includes(index)) continue;
                if (myData.toDayScore < element.total) continue;
                _res.show = true;
                break;
            }
        }
        return _res;
    }

    /**斩草除根（爬塔） 红点 */
    static async pataHongDian(call: ApiCall) {
        let _res = {
            show: false,
            val: {
                shopItems: {
                    show: false
                },
                saodang: {
                    show: false
                },
                reward: {
                    show: false
                }
            }
        };
        let _conf = G.gc.patacom;
        let _conList = Object.keys(_conf).sort((a, b) => Number(a) - Number(b));
        let _myData = await PataFun.getInfo(call.uid);
        for (let index = 0; index < _conList.length; index++) {
            const element = Number(_conList[index]);
            // 未通关 已经经过排序，可以直接 break
            if (_myData.lv <= element) break
            /**已经领取 */
            if (_myData.gotarr.indexOf(element) != -1) continue
            _res.show = true
            _res.val.reward.show = true
        }
        // 扫荡判断
        let max = G.gc.com.pata_saodang.value + (PlayerShared.getMingDaoBuff(call.conn.gud, "zccg_sd") || 0);
        let prize = G.gc.pata[_myData.lv - 1]?.sdprize;
        _res.val.saodang.show = max - (_myData.saodangNum || 0) > 0 && !!prize
        _res.show = _res.show || _res.val.saodang.show
        // 商店判断
        // 个人爬塔商店购买情况
        // let shopData = await G.redis.get('shop', call.uid, '7'); // 商店编号7，未理清商店id存放的数据表，后续该出尽量改为数据库读取

        // 12.12策划确定爬塔id7的商店移除，此处商店不再需要红点
        // let shopData = await ShopFun.getShopData(call.uid, "7")
        // if (shopData) {
        //     let {buyNum, shopItems} = shopData
        //     // 获取爬塔商店商品
        //     for (let index in shopItems) {
        //         let x = shopItems[index]
        //         if (x.needZCCG > 0 && x.needZCCG < _myData.lv && (buyNum && !buyNum[index])) {
        //             // 验证是否达到购买条件
        //             let isOk = await (await PlayerFun.checkNeedIsMeet(call, x.buyNeed, false)).isOk
        //             if (isOk) {
        //                 _res.show = true
        //                 _res.val.shopItems.show = true
        //             }
        //         }
        //     }
        // }
        return _res;
    }

    /**名望免费礼包及特权领取 红点 */
    static async renownHongDian(call: ApiCall) {
        let _res = {
            show: false
        };
        let _conf = G.gc.mw_com.gift
        let _myData = await G.mongodb.collection('playerInfo', 'juewei').findOne({uid: call.conn.uid, type: 'juewei'});
        // 无数据，有免费礼包
        if (!_myData) {
            _res.show = true
            return _res
        }

        for (let index = 0; index < _conf.length; index++) {
            const element = _conf[index];
            if (index == 0 && PublicShared.getToDayZeroTime(_myData.tequan.recTime || 0) == PublicShared.getToDayZeroTime(G.time)) {
                // 特权红点
                let buyLog = await PayFun.getPayLog(call.uid, element.payId);
                if (buyLog.length > 0) {
                    _res.show = true
                    return _res
                }
            }

            // 不是免费
            if (element.payId) continue

            /**已经领取最大次数 */
            if ((_myData.record?.[index] || 0) >= element.buyNum) continue
            _res.show = true
            break
        }
        return _res;
    }

    /**开服竞赛 */
    static async kaifujingsai(call: ApiCall): Promise<hongdianVal> {
        let status = kfjsFun.getStatus()
        // 超过活动显示时间后，不查询直接返回false
        if (status.type < 1 && PublicShared.getOpenServerDay() > R.values(G.gc.kfcb_content).slice(-1)[0].showDay[1] + 1) return {show: false}
        let data = await G.mongodb.cEvent('kaifujingsai').findOne({uid: call.uid, type: 'kaifujingsai'})
        let canGet = {}
        for (let i = 1; i <= 7; i++) {
            let prize = kfjsFun.getStatus(i)
            if (PublicShared.getOpenServerDay() <= prize.conf.showDay[1]) continue
            let rankKfjs = new RankKfjs(i)
            let myRank = await rankKfjs.getRankSortByOne(call.uid)
            if (prize.type > 0 && !data?.record?.[i] && myRank >= 0) {
                canGet[i] = true
            }
        }

        if (R.values(canGet).length == 0) return {show: false}
        return {show: true, val: canGet}
    }

    /**周末礼包 */
    static async zhoumolibao(call: ApiCall): Promise<hongdianVal> {
        let _hd = (await HuoDongFun.gethdList(call, 9))[0]
        let gift = _hd?.data?.gift?.find(i => i.free)
        if (!gift) return {show: false}

        let data = await G.mongodb.cEvent('zhoumolibao').findOne({uid: call.uid, type: 'zhoumolibao'})
        let rec = data?.record?.[gift.id]
        if (rec && rec >= gift?.buyNum) return {show: false}
        return {show: true}
    }

}


export class HuoDongHongDianFun {
    /**所有可支持后台活动 红点 */
    static async houtaihdHongDian(call: ApiCall) {
        let _res = {
            show: false,
            val: {
                hdid: [],
                htype: [],
                hdxq: {}
            }
        };
        let _hdList = []
        for (let i = 0; i < 8; i++) {
            _hdList.push(...await HuoDongFun.gethdList(call, i + 1))
        }
        // let _hdList = await HuoDongFun.gethdList(call)
        for (let index = 0; index < _hdList.length; index++) {
            const element = _hdList[index];
            let ishd: hongdianVal = {show: false}
            if (element.htype == 1) {
                // 检测 htype 1 养成目标活动红点
                ishd = await this.yangchengmubiaoHongDian(call, element)
            }

            if (element.htype == 2) {
                // 检测 htype 2 掉落兑换活动红点
                ishd = await this.diaoluoduihuanHongDian(call, element)
            }

            if (element.htype == 3) {
                // 检测 htype 3 传说之路活动红点
                ishd = await this.chuanshuozhiluHongDian(call, element)
            }

            if (element.htype == 4) {
                // 检测 htype 4 自选礼包活动红点
                ishd = await this.zixuanlibaoHongDian(call, element)
            }

            if (element.htype == 5) {
                // 检测 htype 5 累计充值活动红点
                ishd = await this.leijichongzhiHongDian(call, element)
            }

            if (element.htype == 6) {
                // 检测 htype 6 七日登录活动红点
                ishd = await this.qiridengluHongDian(call, element)
            }
            if (element.htype == 8) {
                // 检测 htype 8 圣诞活动红点
                ishd = await this.christmasHongDian(call, element)
            }

            // 此活动有红点
            if (ishd.show) {
                _res.show = true
                _res.val.hdid.push(element.hdid)
                if (_res.val.htype.indexOf(element.htype) == -1) _res.val.htype.push(element.htype)
                _res.val.hdxq[element.hdid] = ishd
            }
        }
        return _res;
    }

    /**开服狂欢红点 */
    static async kfkhHongDian(call: ApiCall) {
        let _res: hongdianVal = {
            show: false
        };
        let [isOpen, tips] = PublicShared.getOpenCond(call, "kaifukuanghuan")
        if (!isOpen) return _res;

        let db = await G.mongodb.cEvent('kaifukuanghuan').findOne({uid: call.uid, type: 'kaifukuanghuan'});
        let data = db || {
            receiveLogin: [],
            receiveBox: [],
            receiveTask: Object.fromEntries(Object.keys(G.gc.kaifukuanghuan.task).map(day => [day, []]))
        };
        // 登录奖励
        let day = PublicShared.getOpenServerDay(call.conn.gud.cTime);
        if (data.receiveLogin.length < day) _res.show = true;

        // 宝箱奖励
        if (!_res.show) {
            let _con = G.gc.kaifukuanghuan.taskBoxPrize;
            let finished = Object.values(data.receiveTask).map(fs => fs.length).reduce((a, b) => a + b);
            for (let index = 0; index < _con.length; index++) {
                const element = _con[index];
                if (data.receiveBox.includes(index)) continue;
                if (finished < element.total) continue;
                _res.show = true;
            }
        }

        // 任务奖励
        if (!_res.show) {
            let _taskcon = G.gc.kaifukuanghuan.task;
            let tasks = Object.values(G.gc.kaifukuanghuan.task as k_v<_gcType['kaifukuanghuan']['task']['1']>).map(tasks => tasks.map(task => task.taskType)).reduce((a, b) => a.concat(b));
            let taskFinished = await getTaskVal(call.conn.gud, [...new Set(tasks)]);
            let _keys = Object.keys(_taskcon);
            for (let index = 0; index < _keys.length; index++) {
                const element = _taskcon[_keys[index]];

                for (let indexTask = 0; indexTask < element.length; indexTask++) {
                    const _tmp = element[indexTask];
                    if (parseInt(_keys[index]) > day) break;    // 未开放
                    if (data.receiveTask[_keys[index]].includes(indexTask)) continue;
                    // 重复领取 和 条件未满足
                    if (_tmp.taskType != 'jjc_rank') {
                        if ((taskFinished[_tmp.taskType] || 0) < _tmp.total) continue;
                    } else {
                        if ((taskFinished[_tmp.taskType] || 0) > _tmp.total) continue;
                    }

                    _res.show = true;
                    break;
                }

                if (_res.show) break;
            }
        }
        return _res;
    }

    /**基金红点 */
    static async jijinHongDian(call: ApiCall) {
        let _res: hongdianVal = {
            show: false,
            val: {
                keys: []
            }
        };
        let jijintype: jijinType[] = ["dengjijijin", "guanqiajijin", "dayjijin", "tianshujijin"];
        let logs = await PayFun.getPayLogs(call.uid);
        for (let index = 0; index < jijintype.length; index++) {
            const element = jijintype[index];
            let conf = G.gc.jijin[element];

            // 相关数据
            let data = await G.mongodb.cEvent(element).findOne({uid: call.uid, type: element});
            let rec = data?.rec || {};        // 领取数据
            let val = await getVal(call, logs, element);
            let payId = element == 'tianshujijin' ? 'zhongshenka' : element;
            let isPay = logs?.[payId]?.length > 0;
            for (let taskindex = 0; taskindex < conf.length; taskindex++) {
                const elementtask = conf[taskindex];

                if (val < elementtask.total) continue;   // 未完成
                let hasPt = elementtask.pt.length > 0;
                let hasTq = elementtask.tq.length > 0;
                let getPt = !hasPt || rec[taskindex]?.pt == true;
                let getTq = !hasTq || rec[taskindex]?.tq == true;

                if (getPt && !getTq && !isPay) continue;           // 购买礼包后才可以领取奖励
                if (getPt && getTq) continue;   // 奖励已领取

                _res.show = true;
                _res.val.keys.push(element);
                break;
            }
            // if (_res.show) break;
        }
        return _res;
    }

    /**追杀令红点 */
    static async zhuishalingHongDian(call: ApiCall) {
        let _res: hongdianVal = {
            show: false,
            val: {
                "task": [],
                "zhanling": 0
            }
        };

        let [isOpen, tips] = PublicShared.getOpenCond(call, "zhanling")
        if (!isOpen) return _res;

        // 任务奖励
        let conf = G.gc.zhanling.task;
        let _mydata = await G.mongodb.cEvent('zhanling').findOne({uid: call.uid, type: 'zhanling'});
        let tasks = G.gc.zhanling.task.map(t => {
            return {type: t.type as 'day' | 'week' | 'round', key: t.taskId};
        });
        let taskFinished = await ZhanLingTasks.getLog(call.uid, tasks);
        for (let index = 0; index < conf.length; index++) {
            const element = conf[index];
            if (element.taskId == 'tqexp' && !_mydata?.isPay) continue;
            if ((_mydata?.taskRec || []).includes(index)) continue;
            // let taskVal = await ActionLog.getDayLog(call.uid, element.taskId);
            let _key = `${element.type}@${element.taskId}`;
            let taskVal = taskFinished[_key];
            if (taskVal < element.total) continue;
            _res.show = true;
            if (!_res.val["task"].includes(element.type)) {
                _res.val["task"].push(element.type);
            }
            // break;   前端要求加 key
        }

        // 战令奖励
        let rec = _mydata?.rec || {};
        let val = _mydata?.lv || 0;
        let isPay = _mydata?.isPay;
        let _conf = G.gc.zhanling.prize;
        for (let zlindex = 0; zlindex < _conf.length; zlindex++) {
            const zlelement = _conf[zlindex];
            if (val < zlelement.lv) continue;   // 未完成
            let hasPt = zlelement.pt.length > 0;
            let hasTq = zlelement.tq.length > 0;
            let getPt = !hasPt || rec[zlindex]?.pt == true;
            let getTq = !hasTq || rec[zlindex]?.tq == true;

            if (getPt && !getTq && !isPay) continue;           // 购买礼包后才可以领取奖励
            if (getPt && getTq) continue;   // 奖励已领取

            _res.show = true;
            _res.val["zhanling"] = 1;
            break;
        }
        return _res;
    }

    /**七日登录红点 */
    static async qiridengluHongDian(call: ApiCall, hdCon: ReqAddHuoDong) {
        let _res: hongdianVal = {
            show: false
        };
        let _con = hdCon.data.arr;
        let day = await ActionLog.getRetainLog(call.uid, `login_day_qiridenglu_${hdCon.hdid}`);
        let _dbType: `qiridenglu${number}` = `qiridenglu${hdCon.hdid}`
        let _mydata = await G.mongodb.cEvent(_dbType).findOne({uid: call.uid, type: _dbType});
        for (let index = 0; index < _con.length; index++) {
            const element = _con[index];
            if (element.day > day) continue;
            if (_mydata?.recPrize?.includes(index)) continue;
            _res.show = true;
            break;
        }
        return _res;
    }

    // 一百抽 子函数
    static async yibaochouhd(conf, finish: number, recArr: number[]) {
        let ishd: 0 | 1 = 0;
        for (let index = 0; index < conf.length; index++) {
            const element = conf[index];
            if (finish < element.total) continue;
            if (recArr.includes(index)) continue;
            ishd = 1;
            break;
        }
        return ishd;
    }

    /**一百抽红点 */
    static async yibaichouHongDian(call: ApiCall) {
        let _res: hongdianVal = {
            show: false
        };
        let [isOpen, tips] = PublicShared.getOpenCond(call, "yibaichou")
        if (!isOpen) return _res;

        let _con = G.gc.yibaichou;
        let _type = ['online', 'login'];
        let _mydata = await G.mongodb.cEvent('yibaichou').findOne({uid: call.uid, type: 'yibaichou'});
        for (let index = 0; index < _type.length; index++) {
            const element = _type[index];

            let conf = G.gc.yibaichou[element + 'Prize'];
            let finish = element == 'login' ? call.conn.gud.loginDays : call.conn.gud.onlineTime;
            let recArr: number[] = _mydata?.[element + 'Rec'] || [];
            let ishd = await this.yibaochouhd(conf, finish, recArr);
            if (ishd == 1) {
                _res.show = true;
                break;
            }
        }
        return _res;
    }

    /**伙伴招募红点 */
    static async huobanzhaomuHongDian(call: ApiCall) {
        let _res: hongdianVal = {
            show: false
        };

        let [isOpen, tips] = PublicShared.getOpenCond(call, "huobanzhaomu")
        if (!isOpen) return _res;

        let _con = G.gc.huobanzhaomu;
        let _mydata = await G.mongodb.cEvent('huobanzhaomu').findOne({uid: call.uid, type: 'huobanzhaomu'});
        for (let index = 0; index < _con.length; index++) {
            const element = _con[index];
            if (_mydata?.rec.includes(index)) continue;  // 已领取
            if (element.gudKey && call.conn.gud[element.gudKey] < element.total) continue;     // 未达成
            if (!element.gudKey && (_mydata?.rec?.length || 0) < _con.length - 1) continue;    // 大奖资格不够
            _res.show = true;
            break;
        }
        return _res;
    }

    /**累计充值红点 */
    static async leijichongzhiHongDian(call: ApiCall, hdCon: ReqAddHuoDong) {
        let _res: hongdianVal = {
            show: false
        };
        let _dbType: `leijichongzhi${number}` = `leijichongzhi${hdCon.hdid}`
        let _con = hdCon.data.tasks;
        let db = await G.mongodb.cEvent(_dbType).findOne({uid: call.uid, type: _dbType});
        let _mydata = db || {sTime: PublicShared.getToDayZeroTime(G.time), recIndex: []};
        let payNum = await PayFun.getPayDaysAllPayNum(call.uid, hdCon.stime, hdCon.rtime);
        for (let index = 0; index < _con.length; index++) {
            const element = _con[index];
            if (_mydata.recIndex.includes(index)) continue;
            if (payNum < element.total) continue;
            _res.show = true;
            break;
        }
        return _res;
    }

    /**七日累充红点 */
    static async qirileichongHongDian(call: ApiCall) {
        let _res: hongdianVal = {
            show: false
        };
        let db = await G.mongodb.cEvent('qirichongzhi').findOne({uid: call.uid, type: 'qirichongzhi'});
        let _mydata = db || {round: 0, sTime: PublicShared.getToDayZeroTime(G.time), recIndexs: []};
        let _con = G.gc.qirichongzhi[_mydata.round];
        let finished = await PayFun.getPayDaysAllPayNum(call.uid, _mydata.sTime, _mydata.sTime + G.gc.qirichongzhi[_mydata.round].time);
        for (let index = 0; index < _con.tasks.length; index++) {
            const element = _con.tasks[index];
            if (_mydata.recIndexs.includes(index)) continue;
            if (finished < element.total) continue;
            _res.show = true;
            break;
        }
        return _res;
    }

    /**节日 子函数 */
    static async jieriHD(call: ApiCall, _conf, recIndex, _type, _finish: number) {
        let ishd: 0 | 1 = 0;
        for (let index = 0; index < _conf.length; index++) {
            const element = _conf[index];
            if (_type == 'task') _finish = await ActionLog.getDayLog(call.uid, element.taskId);
            if (_finish < element.total) continue;
            if (recIndex.includes(index)) continue;
            ishd = 1;
            break;
        }
        return ishd;
    }

    /**节日红点 */
    static async jieriHongDian(call: ApiCall) {
        let _res: hongdianVal = {
            show: false
        };
        let db = await G.mongodb.cEvent('jierihuodong').findOne({uid: call.uid, type: 'jierihuodong'});
        let _mydata = db || {refreshTime: G.time, recTask: [], recLogin: []};
        let _types = ['login', 'task'];
        let finish = call.conn.gud.loginDays;
        for (let index = 0; index < _types.length; index++) {
            const element = _types[index];
            let _conf = element == 'login' ? G.gc.jierihuodong.denglufuli : G.gc.jierihuodong.huodongrenwu;
            let recIndex = element == 'login' ? (_mydata?.recLogin || []) : (_mydata?.recTask || []);
            let ishd = await this.jieriHD(call, _conf, recIndex, element, finish);
            if (ishd == 1) {
                _res.show = true;
                break;
            }
        }
        return _res;
    }

    /**圣诞节活动红点 */
    static async christmasHongDian(call: ApiCall, hdCon: ReqAddHuoDong) {
        let _res: hongdianVal = {
            show: false,
        };

        let _hdCon = hdCon.data;
        let stime = hdCon.stime
        let _mydata = await Christmasfun.getMyData(call, hdCon.hdid);
        let _tasks = hdCon.data.task;   // 所有任务 taskid 为key

        for (let indextask = 0; indextask < Object.keys(_tasks).length; indextask++) {
            const elementtask = Object.keys(_tasks)[indextask];
            let _tmp = _tasks[elementtask];
            if (_tmp.pval <= (_mydata.taskval[elementtask] || 0) && !_mydata.taskfinish.includes(elementtask)) {
                // 任务完成且没有领取
                _res.show = true;
                return _res;
            }
        }

        let libaos = _hdCon.libao
        for (let indexlibao = 0; indexlibao < Object.keys(libaos).length; indexlibao++) {
            const elementlibao = Object.keys(libaos)[indexlibao];
            let _tmp = _tasks[elementlibao];
            if (_tmp.payid) continue
            let _buyNum = _mydata.libao[elementlibao] || 0
            if (_buyNum < _tmp.buynum) {
                _res.show = true;
                return _res;
            }
        }
        let _diff = PublicShared.getDiff(stime)
        // 循环判断是否有可以领取的
        for (let i = 0; i < _diff; i++) {
            if (_mydata.qiandao.includes(i)) continue
            _res.show = true;
            return _res;
        }
        let need = _hdCon.gameneed;
        // 判断消耗是否满足
        let meet = await PlayerFun.checkNeedIsMeet(call, need, false);
        if (meet.isOk == true) {
            _res.show = true;
            return _res;
        }
        let zhanling = _hdCon.zhanling
        for (let indexzhanling = 0; indexzhanling < zhanling.length; indexzhanling++) {
            if (!_mydata.pt.includes(indexzhanling)) {
                _res.show = true;
                return _res;
            }
            if (_mydata.pay && !_mydata.gj.includes(indexzhanling)) {
                _res.show = true;
                return _res;
            }
        }

        return _res;
    }


    /**养成目标红点 */
    static async yangchengmubiaoHongDian(call: ApiCall, hdCon: ReqAddHuoDong) {
        let _res: hongdianVal = {
            show: false,
        };

        let _hdCon = hdCon.data;
        let _mydata = await YangChengMuBiaofun.getMyData(call, hdCon.hdid);

        let _tasks = {};   // 所有任务 taskid 为key
        Object.values(_hdCon.tasklist).map(l => {
            return Object.assign(_tasks, l);
        });

        let _ishd = 0;
        for (let indextask = 0; indextask < Object.keys(_tasks).length; indextask++) {
            const elementtask = Object.keys(_tasks)[indextask];
            let _tmp = _tasks[elementtask];
            if (_tmp.pval <= (_mydata.taskval[elementtask] || 0) && !_mydata.finishid[_tmp.type].includes(parseInt(elementtask))) {
                // 任务完成且没有领取
                _res.show = true;
                _ishd = 1;
                break;
            }
        }

        if (_ishd != 1) {
            let _gift = _hdCon.gift.filter(l => (!l.payId && l.need.length <= 0) || l.free);
            for (let indexgift = 0; indexgift < _gift.length; indexgift++) {
                const elementgift = _gift[indexgift];
                let buyNum = _mydata.record?.[indexgift] || 0;
                if (buyNum < elementgift.buyNum) {
                    _res.show = true;
                    break;
                }
            }
        }
        return _res;
    }

    /**掉落兑换红点 */
    static async diaoluoduihuanHongDian(call: ApiCall, hdCon: ReqAddHuoDong): Promise<hongdianVal> {
        let _dbType: `diaoluoduihuan${number}` = `diaoluoduihuan${hdCon.hdid}`
        // 取出用户已领取的数据
        let data = await G.mongodb.cEvent(_dbType).findOne({uid: call.uid, type: _dbType})
        // 循环活动商店，判断免费与领取
        let confEvent = Object.keys(hdCon.data.event).filter(k => Array.isArray(hdCon.data.event[k]))
        for (let key of confEvent) {
            let item = hdCon.data.event[key]
            for (let i in item) {
                if (item[i].free && !(data && data.record && data.record[key] && data.record[key][i])) return {show: true}
            }
        }
        return {show: false};
    }

    /**传说之路 */
    static async chuanshuozhiluHongDian(call: ApiCall, hdCon: ReqAddHuoDong): Promise<hongdianVal> {
        let _dbType: `chuanshuozhilu${number}` = `chuanshuozhilu${hdCon.hdid}`

        let task = hdCon.data
        let db = await G.mongodb.cEvent(_dbType).findOne({uid: call.uid, type: _dbType});
        let info: Partial<typeof db.info['']> = db?.info?.[task.hid] || {};

        for (let conf of task.task) {
            if (info[conf.type] >= conf.total && !(info.rec || []).includes(conf.idx)) return {show: true};
        }

        if (info.rec?.length >= task.box.total && !info.box) return {show: true};

        return {show: false};
    }

    /**自选礼包红点 */
    static async zixuanlibaoHongDian(call: ApiCall, hdCon: ReqAddHuoDong): Promise<hongdianVal> {
        let _dbType: `zixuanlibao${number}` = `zixuanlibao${hdCon.hdid}`
        let db = await G.mongodb.cEvent(_dbType).findOne({uid: call.uid, type: _dbType});
        if (!db?.record?.[0]) {
            return {show: true}
        }

        return {show: false};
    }

    /**月度基金 */
    static async yuedujijinHongDian(call: ApiCall): Promise<hongdianVal> {
        let pays = 0;
        let payIds = G.gc.yuedujijin.map(v => v.payId);
        let obj: k_v<payLog[]> = {};

        for (let id of payIds) {
            let logs = obj[id] = await PayFun.getPayLog(call.uid, id);
            if (logs.length > 0) pays++;
        }

        if (pays < 1) return {show: false};

        for (let conf of G.gc.yuedujijin) {
            let id = conf.payId;
            let logs = obj[conf.payId];
            if (logs.length < 1) continue;
            let db = await G.mongodb.cEvent(id as `${number}jijin`).findOne({
                uid: call.uid,
                type: id as `${number}jijin`
            });
            let rec = db?.rec || [];
            let days = db?.days || 0;
            let round = db?.round || 0;
            if (rec.length < days + 1 && rec.length < conf.prize.length * (round + 1)) return {show: true};
        }

        return {show: false};
    }

    /** 黑市活动 */
    static async heiShihd(call: ApiCall): Promise<hongdianVal> {
        let _res: hongdianVal = {
            show: false,
            val: {
                meirijingxuan: {},
                jitianhaoli: {},
                niudanji: {}
            }
        };
        _res.val.meirijingxuan = await this.heiShiHongDian(call)
        // _res.val.jitianhaoli = await this.heiShiLCHongDian(call)
        _res.val.niudanji = await this.heiShiNiuDanJi(call)
        Object.values(_res.val).forEach(x => _res.show = _res.show || x.show)
        return _res
    }

    /**黑市 每日精选 */
    static async heiShiHongDian(call: ApiCall): Promise<hongdianVal> {
        let payKey = "136Gift1"
        let _res: hongdianVal = {
            show: false,
            val: {stask: []}
        };
        let db = await G.mongodb.cEvent('136Gift').findOne({uid: call.uid, type: '136Gift'});
        let payData = await PayFun.getPayLogs(call.uid)
        let payLen = (payData[payKey] || []).length
        let isBuy = !(!payLen || payData[payKey][payLen - 1].eTime < G.time)
        let _myData = (db && db.refreshTime >= PublicShared.getToDayZeroTime() && db.recIndex) ? db.recIndex : [];
        let _con = G.gc["dixiaheishi"]['136Gift'];
        for (let index = 1; index < _con.length; index++) {
            const element = _con[index];
            // if (element.payId && !isBuy) {
            if (element.payId && !isBuy) {
                continue;
            }
            if (_myData.includes(index)) {
                continue;
            }
            _res.val.stask.push(index)
            if (index > 1 && !_res.val.stask.includes(0)) _res.val.stask.push(0)
            _res.show = true
        }
        return _res;
    }

    /**黑市 积天豪礼 */
    // static async heiShiLCHongDian(call: ApiCall): Promise<hongdianVal> {
    //     let _res: hongdianVal = {
    //         show: false
    //     };
    //     let db = await G.mongodb.cEvent('15leichong').findOne({uid: call.uid, type: '15leichong'});
    //
    //     if (!db) return _res;
    //
    //     let _con = G.gc.shiwuleichong.data[db.index];
    //     let payDay = await PayFun.getPayDaysBuyPayNum(call.uid, db.sTime, db.sTime + _con.time, G.gc.shiwuleichong.dayPayNeed);
    //     for (let index = 0; index < _con.tasks.length; index++) {
    //         const element = _con.tasks[index];
    //         if (db.recIndex.includes(index)) continue;
    //         if (payDay < element.total) continue;
    //         _res.show = true;
    //         break;
    //     }
    //     return _res;
    // }

    /**黑市 扭蛋机 */
    static async heiShiNiuDanJi(call: ApiCall): Promise<hongdianVal> {
        // 查询配置，获取等级限制
        let openCondConf = G.gc.openCond['hs_btn_ndj']
        let _res: hongdianVal = {
            show: false
        };
        // 等级不满足，上锁，不查询红点。
        if (call.conn.gud.lv < openCondConf.display.lv) return _res
        let db = await G.mongodb.cEvent('niudanji').findOne({uid: call.uid, type: 'niudanji'});
        let useNum = db?.useNum || 0
        let hasNum = Math.floor(call.conn.gud.payExp / G.gc.niudanji.pay2num)
        _res.show = useNum < hasNum
        return _res
    }
}


export class HongDianChange {
    /**红点 change */
    static async sendChangeKey(uid: string, key: hongdianKey[]) {
        G.server.sendMsgByUid(uid, 'msg_s2c/HongDianChange', key);
    }
}