import {ctor} from "../global";
import {initMongoDB} from "../setMongodb";
import {ReqEmail} from "../monopoly/protocols/PtlEmail";
import {MsgEmail} from "../shared/protocols/msg_s2c/MsgEmail";
import {yangchengmubiao} from "../shared/protocols/event/yangchengmubiao/PtlOpen";


/**
 * 标题：首充优化
 * 日語:初回チャージ仕様改善
 * 繁體:首儲機制改善
 * 韓国語: 초회 충전 시스템 개선
 * 英語: First Top-Up optimization
 *
 * 內文：这是您的补偿，请查收！
 * 日語:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 * 繁體中文:這是您的補償內容，煩請查收!
 * 韓国語:투자 시스템 개선으로 인한 보상을 보내드립니다.
 * 英語: Please find attached a few items as a compensation for the wait during our adjustments.
 *
 * 线上玩家脚本
 * 1、已激活首充档位且没领完3天奖励的玩家，邮件补发剩下的奖励
 * 2、重置所有玩家首充活动到新版本状态*/

async function addEmail(email: ReqEmail) {
    let {prize, uid, ...e} = email;
    let sendEmail: MsgEmail = {
        _id: null,
        uid: uid,
        type: e.type,
        title: e.title,
        content: e.content,
        createTime: G.time,
        contentInsertArr: e.contentInsertArr || []
    };

    if (email.lngTitle) {
        sendEmail.lngTitle = email.lngTitle;
        sendEmail.lngContent = email.lngContent;
    }

    if ((prize === null || prize === void 0 ? void 0 : prize.length) > 0) {
        sendEmail.prizeData = {
            prize: email.prize,
            isGet: false
        };
    }

    if (email.g123log && Object.keys(email.g123log).length > 0) {
        sendEmail.g123log = email.g123log;
    }
    await G.mongodb.collection('email').insertOne({
        ttl: new Date(), ...G.mongodb.conversionIdObj(sendEmail)
    })
}

async function shouChongReSet() {
    let shouchong = {
        "shouchong1": {
            "paynum": 6,
            "cartoon": {
                "hero": 5001
            },
            "prize": [
                [
                    {
                        "a": "hero",
                        "t": "5001",
                        "n": 1
                    },
                    {
                        "a": "attr",
                        "t": "jinbi",
                        "n": 100000
                    }
                ],
                [
                    {
                        "a": "item",
                        "t": "12",
                        "n": 200
                    },
                    {
                        "a": "attr",
                        "t": "jinbi",
                        "n": 200000
                    }
                ],
                [
                    {
                        "a": "item",
                        "t": "12",
                        "n": 200
                    },
                    {
                        "a": "attr",
                        "t": "jinbi",
                        "n": 300000
                    }
                ]
            ]
        },
        "shouchong2": {
            "paynum": 30,
            "cartoon": {
                "img": 5001
            },
            "prize": [
                [
                    {
                        "a": "equip",
                        "t": "1009",
                        "n": 1
                    },
                    {
                        "a": "equip",
                        "t": "2009",
                        "n": 1
                    }
                ],
                [
                    {
                        "a": "equip",
                        "t": "3009",
                        "n": 1
                    },
                    {
                        "a": "item",
                        "t": "2",
                        "n": 1000
                    }
                ],
                [
                    {
                        "a": "equip",
                        "t": "4009",
                        "n": 1
                    },
                    {
                        "a": "item",
                        "t": "2",
                        "n": 1000
                    }
                ]
            ]
        },
        "shouchong3": {
            "paynum": 98,
            "cartoon": {
                "hero": 5002
            },
            "prize": [
                [
                    {
                        "a": "hero",
                        "t": "5002",
                        "n": 1
                    },
                    {
                        "a": "item",
                        "t": "4",
                        "n": 10
                    }
                ],
                [
                    {
                        "a": "equip",
                        "t": "1010",
                        "n": 1
                    },
                    {
                        "a": "item",
                        "t": "2",
                        "n": 2000
                    }
                ],
                [
                    {
                        "a": "equip",
                        "t": "3010",
                        "n": 1
                    },
                    {
                        "a": "item",
                        "t": "2",
                        "n": 2000
                    }
                ]
            ]
        }
    };
    let users = await G.mongodb.collection("user").find({}, {
        projection: {uid: 1, payExp: 1}
    }).toArray();

    for (let i = 0; i < users.length; i++) {
        let user = users[i];
        let data = await G.mongodb.cEvent("shouchong").findOne({
            uid: user.uid,
            type: "shouchong",
        });

        if (!data) {
            data = {uid: user.uid, receive: {}, type: "shouchong", _id: G.mongodb.conversionId("")};
        }

        let send_prize = [];
        for (let key in shouchong) {
            // 充值不足
            if (user.payExp < shouchong[key]["paynum"] * 10) {
                continue
            }

            // 奖励已经领取完毕
            if (data?.receive && data.receive[key] && data.receive[key].length >= shouchong[key]["prize"].length) {
                continue
            }

            // 补发未领取奖励
            for (let i = 0; i < shouchong[key]["prize"].length; i++) {
                if (data?.receive && data.receive[key] && data.receive[key][i]) {
                    continue
                }

                if (!data.receive[key]) {
                    data.receive[key] = [];
                }
                data.receive[key][i] = G.time;
                send_prize = send_prize.concat(shouchong[key]["prize"][i]);
            }
        }
        if (send_prize.length <= 0) continue;

        let title = "首充优化";
        let content = "这是您的补偿，请查收！";

        let lngTitle = {
            "en": "First Top-Up optimization",
            "ja": "初回チャージ仕様改善",
            "ko": "초회 충전 시스템 개선",
            "zh-TW": "首儲機制改善"
        };
        let lngContent = {
            "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
            "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
            "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
            "zh-TW": "這是您的補償內容，煩請查收!",
        };

        // 发放邮件
        await addEmail({
            uid: user.uid,
            type: "system",
            title: title,
            content: content,
            prize: send_prize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });
        // 设置奖励发放记录
        await G.mongodb.cEvent("shouchong").updateOne({
            uid: user.uid,
            type: "shouchong",
        }, {"$set": {receive: data.receive, patch: 1}}, {upsert: true});

        console.log(`玩家${user.uid}首充奖励补发完成...`);
    }
}


/**
 * "zhizunyueka"
 标题：至尊月卡优化
 日語:豪華月パス仕様改善
 繁體:至尊月卡改善
 韓国語:고급 월간 패스 시스템 개선
 英語: Luxurious Monthly Pass optimization

 邮件内容：这是您的补偿，请查收！
 日語:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 繁體中文:這是您的補償內容，煩請查收!
 韓国語:투자 시스템 개선으로 인한 보상을 보내드립니다.
 英語: Please find attached a few items as a compensation for the wait during our adjustments.

 线上玩家脚本：
 线上已购买至尊月卡的玩家，脚本补发：钻石*10000
 **/
async function zhizunyueka() {
    let w = {
        key: "zhizunyueka",
        del_time: {$exists: false}
    };
    let users = (await G.mongodb.collection("payLogNew").find(w).toArray()).filter(
        // 过滤没有结束时间 或者 有结束时间 但是没有过期的
        (pay) => pay.values?.length > 0 && (!pay.values.slice(-1)[0].eTime || pay.values.slice(-1)[0].eTime > G.time)
    );

    let uid2Prize: { [uid: string]: { a: string, t: string, n: number }[] } = {};
    users.forEach(user => {
        let uid = user.uid;
        if (!uid2Prize[uid]) uid2Prize[uid] = [];
        uid2Prize[uid].push({a: "attr", t: "rmbmoney", n: 10000});
    });

    let title = "至尊月卡优化";
    let content = "这是您的补偿，请查收！";
    let lngTitle = {
        "en": "Luxurious Monthly Pass optimization",
        "ja": "豪華月パス仕様改善",
        "ko": "고급 월간 패스 시스템 개선",
        "zh-TW": "至尊月卡改善",
    };
    let lngContent = {
        "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
        "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
        "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
        "zh-TW": "這是您的補償內容，煩請查收!",
    };

    for (const [uid, sendPrize] of Object.entries(uid2Prize)) {
        // 发放邮件
        await addEmail({
            uid: uid,
            type: "system",
            title: title,
            content: content,
            prize: sendPrize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });

        // 处理重复执行
        await G.mongodb.collection("payLogNew").updateMany(
            Object.assign({uid: uid}, w), {$set: {patch: 1}}
        )

        console.log(`玩家${uid}至尊月卡奖励补发完成...`);
    }
}

/**
 * "chaozhiyueka"
 标题 超值月卡优化
 ja:お得月パス仕様改善
 zh-TW:超值月卡改善
 ko:월간 패스 시스템 개선
 en: Value Monthly Pass optimization

 內文：
 这是您的补偿，请查收！
 ja:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 zh-TW:這是您的補償內容，煩請查收!
 ko:투자 시스템 개선으로 인한 보상을 보내드립니다.
 en: Please find attached a few items as a compensation for the wait during our adjustments.

 线上已购买超值月卡的玩家，脚本补发：招募卡*30
 **/
async function chaozhiyueka() {
    let w = {
        key: "chaozhiyueka",
        del_time: {$exists: false}
    };
    let users = (await G.mongodb.collection("payLogNew").find(w).toArray()).filter(
        // 过滤没有结束时间 或者 有结束时间 但是没有过期的
        (pay) => pay.values?.length > 0 && (!pay.values.slice(-1)[0].eTime || pay.values.slice(-1)[0].eTime > G.time)
    );

    let uid2Prize: { [uid: string]: { a: string, t: string, n: number }[] } = {};
    users.forEach(user => {
        let uid = user.uid;
        if (!uid2Prize[uid]) uid2Prize[uid] = [];
        uid2Prize[uid].push({a: "item", t: "4", n: 30});
    });

    let title = "超值月卡优化";
    let content = "这是您的补偿，请查收！";
    let lngTitle = {
        "ja": "お得月パス仕様改善",
        "zh-TW": "超值月卡改善",
        "ko": "월간 패스 시스템 개선",
        "en": "Value Monthly Pass optimization",
    };
    let lngContent = {
        "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
        "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
        "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
        "zh-TW": "這是您的補償內容，煩請查收!"
    };

    for (const [uid, sendPrize] of Object.entries(uid2Prize)) {
        // 发放邮件
        await addEmail({
            uid: uid,
            type: "system",
            title: title,
            content: content,
            prize: sendPrize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });

        // 处理重复执行
        await G.mongodb.collection("payLogNew").updateMany(
            Object.assign({uid: uid}, w), {$set: {patch: 1}}
        )

        console.log(`玩家${uid}超值月卡奖励补发完成...`);
    }
}

/**
 * "zhongshenka"
 标题:终身卡优化
 ja:永久パス仕様改善
 zh-TW:永久通行證改善
 ko:영구 패스 시스템 개선
 en: Lifetime Pass optimization

 內文： 这是您的补偿，请查收！
 ja:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 zh-TW:這是您的補償內容，煩請查收!
 ko:투자 시스템 개선으로 인한 보상을 보내드립니다.
 en: Please find attached a few items as a compensation for the wait during our adjustments.

 线上已购买永久卡的玩家，脚本补发：汉塞尔1，能量饮料500w
 **/
async function zhongshenka() {
    let w = {
        key: "zhongshenka",
        del_time: {$exists: false}
    };
    let users = (await G.mongodb.collection("payLogNew").find(w).toArray()).filter(
        // 过滤没有结束时间 或者 有结束时间 但是没有过期的
        (pay) => pay.values?.length > 0 && (!pay.values.slice(-1)[0].eTime || pay.values.slice(-1)[0].eTime > G.time)
    );

    let uid2Prize: { [uid: string]: { a: string, t: string, n: number }[] } = {};
    users.forEach(user => {
        let uid = user.uid;
        if (!uid2Prize[uid]) uid2Prize[uid] = [];
        uid2Prize[uid].push({"a": "item", "t": "1", "n": 5000000})
        uid2Prize[uid].push({a: "hero", t: "4012", n: 1})
    });

    let title = "终身卡优化";
    let content = "这是您的补偿，请查收！";
    let lngTitle = {
        "ja": "永久パス仕様改善",
        "zh-TW": "永久通行證改善",
        "ko": "영구 패스 시스템 개선",
        "en": "Lifetime Pass optimization",
    };
    let lngContent = {
        "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
        "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
        "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
        "zh-TW": "這是您的補償內容，煩請查收!"
    };

    for (const [uid, sendPrize] of Object.entries(uid2Prize)) {
        // 发放邮件
        await addEmail({
            uid: uid,
            type: "system",
            title: title,
            content: content,
            prize: sendPrize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });

        // 处理重复执行
        await G.mongodb.collection("payLogNew").updateMany(
            Object.assign({uid: uid}, w), {$set: {patch: 1}}
        )

        console.log(`玩家${uid}终身卡奖励补发完成...`);
    }
}


/**
 "qingbaotequan"
 标题:资讯特权优化
 ja:情報特権仕様改善
 zh-TW:資訊特權改善
 ko:정보 특권 시스템 개선
 en: Intel Benefit optimization

 內文：这是您的补偿，请查收！
 ja:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 zh-TW:這是您的補償內容，煩請查收!
 ko:투자 시스템 개선으로 인한 보상을 보내드립니다.
 en: Please find attached a few items as a compensation for the wait during our adjustments.

 线上玩家脚本
 1、特权内容：已购买特权的玩家，特权效果更新，不重置时间
 2、已购买资讯特权的玩家，脚本补发：钻石*680，顶级紫色套装*1
 * */
async function qingbaotequan() {
    let w = {
        key: "qingbaotequan",
        patch: {$exists: false},
        del_time: {$exists: false}
    };
    let users = (await G.mongodb.collection("payLogNew").find(w).toArray()).filter(
        // 过滤没有结束时间 或者 有结束时间 但是没有过期的
        (pay) => pay.values?.length > 0 && (!pay.values.slice(-1)[0].eTime || pay.values.slice(-1)[0].eTime > G.time)
    );

    let uid2Prize: { [uid: string]: { a: string, t: string, n: number }[] } = {};
    users.forEach(user => {
        let uid = user.uid;

        if (!uid2Prize[uid]) uid2Prize[uid] = [];
        uid2Prize[uid].push({"a": "attr", "t": "rmbmoney", "n": 680});
        uid2Prize[uid].push({"a": "item", "t": "609", "n": 1});
    });

    let title = "资讯特权优化";
    let content = "这是您的补偿，请查收！";
    let lngTitle = {
        "ja": "情報特権仕様改善",
        "zh-TW": "資訊特權改善",
        "ko": "정보 특권 시스템 개선",
        "en": "Intel Benefit optimization",
    };
    let lngContent = {
        "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
        "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
        "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
        "zh-TW": "這是您的補償內容，煩請查收!"
    };
    for (const [uid, sendPrize] of Object.entries(uid2Prize)) {
        // 发放邮件
        await addEmail({
            uid: uid,
            type: "system",
            title: title,
            content: content,
            prize: sendPrize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });
        await G.mongodb.collection("payLogNew").updateMany(
            Object.assign({uid: uid}, w), {$set: {patch: 1}}
        )

        console.log(`玩家${uid}特权奖励补发完成...`);
    }
}

/**
 "zuozhantequan"
 标题:作战特权优化
 ja:作戦特権仕様改善
 zh-TW:作戰特權改善
 ko:작전 특권 시스템 개선
 en: Strategy Benefit optimization

 內文：这是您的补偿，请查收！
 ja:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 zh-TW:這是您的補償內容，煩請查收!
 ko:투자 시스템 개선으로 인한 보상을 보내드립니다.
 en: Please find attached a few items as a compensation for the wait during our adjustments.

 线上玩家脚本
 1、特权内容：已购买特权的玩家，特权效果更新，不重置时间
 2、已购买快速特权的玩家，脚本补发：钻石300，快速探险券30
 * */
async function zuozhantequan() {
    let w = {
        key: "zuozhantequan",
        patch: {$exists: false},
        del_time: {$exists: false}
    };
    let users = (await G.mongodb.collection("payLogNew").find(w).toArray()).filter(
        // 过滤没有结束时间 或者 有结束时间 但是没有过期的
        (pay) => pay.values?.length > 0 && (!pay.values.slice(-1)[0].eTime || pay.values.slice(-1)[0].eTime > G.time)
    );

    let uid2Prize: { [uid: string]: { a: string, t: string, n: number }[] } = {};
    users.forEach(user => {
        let uid = user.uid;

        if (!uid2Prize[uid]) uid2Prize[uid] = [];
        uid2Prize[uid].push({"a": "item", "t": "24", "n": 30});
        uid2Prize[uid].push({"a": "attr", "t": "rmbmoney", "n": 300});
    });

    let title = "作战特权优化";
    let content = "这是您的补偿，请查收！";
    let lngTitle = {
        "ja": "作戦特権仕様改善",
        "zh-TW": "作戰特權改善",
        "ko": "작전 특권 시스템 개선",
        "en": "Strategy Benefit optimization",
    };
    let lngContent = {
        "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
        "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
        "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
        "zh-TW": "這是您的補償內容，煩請查收!"
    };
    for (const [uid, sendPrize] of Object.entries(uid2Prize)) {
        // 发放邮件
        await addEmail({
            uid: uid,
            type: "system",
            title: title,
            content: content,
            prize: sendPrize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });
        await G.mongodb.collection("payLogNew").updateMany(
            Object.assign({uid: uid}, w), {$set: {patch: 1}}
        )

        console.log(`玩家${uid}特权奖励补发完成...`);
    }
}

/**
 "caifutequan"
 标题:资产特权优化
 ja:資産特権仕様改善
 zh-TW:資産特權改善
 ko:자산 특권 시스템 개선
 en: Asset Benefit optimization

 內文：这是您的补偿，请查收！
 ja:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 zh-TW:這是您的補償內容，煩請查收!
 ko:투자 시스템 개선으로 인한 보상을 보내드립니다.
 en: Please find attached a few items as a compensation for the wait during our adjustments.

 线上玩家脚本
 1、特权内容：已购买特权的玩家，特权效果更新，不重置时间
 2、已购买资产特权的玩家，脚本补发：钻石*300，美金*1000万
 * */
async function caifutequan() {
    let w = {
        key: "caifutequan",
        patch: {$exists: false},
        del_time: {$exists: false}
    };
    let users = (await G.mongodb.collection("payLogNew").find(w).toArray()).filter(
        // 过滤没有结束时间 或者 有结束时间 但是没有过期的
        (pay) => pay.values?.length > 0 && (!pay.values.slice(-1)[0].eTime || pay.values.slice(-1)[0].eTime > G.time)
    );

    let uid2Prize: { [uid: string]: { a: string, t: string, n: number }[] } = {};
    users.forEach(user => {
        let uid = user.uid;

        if (!uid2Prize[uid]) uid2Prize[uid] = [];
        uid2Prize[uid].push({"a": "attr", "t": "rmbmoney", "n": 300})
        uid2Prize[uid].push({"a": "attr", "t": "jinbi", "n": 10000000})
    });

    let title = "资产特权优化";
    let content = "这是您的补偿，请查收！";
    let lngTitle = {
        "ja": "資産特権仕様改善",
        "zh-TW": "資産特權改善",
        "ko": "자산 특권 시스템 개선",
        "en": "Asset Benefit optimization",
    };
    let lngContent = {
        "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
        "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
        "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
        "zh-TW": "這是您的補償內容，煩請查收!"
    };
    for (const [uid, sendPrize] of Object.entries(uid2Prize)) {
        // 发放邮件
        await addEmail({
            uid: uid,
            type: "system",
            title: title,
            content: content,
            prize: sendPrize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });
        await G.mongodb.collection("payLogNew").updateMany(
            Object.assign({uid: uid}, w), {$set: {patch: 1}}
        )

        console.log(`玩家${uid}资产特权奖励补发完成...`);
    }
}

/**
 "jiubatequan"
 标题:抽奖特权优化
 ja:ガチャ特権仕様改善
 zh-TW:抽獎特權改善
 ko:모집 특권 시스템 개선
 en: Gacha Benefit optimization

 內文：这是您的补偿，请查收！
 ja:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 zh-TW:這是您的補償內容，煩請查收!
 ko:투자 시스템 개선으로 인한 보상을 보내드립니다.
 en: Please find attached a few items as a compensation for the wait during our adjustments.

 线上玩家脚本
 1、特权内容：已购买特权的玩家，特权效果更新，不重置时间
 2、已购买抽奖特权的玩家，脚本补发：钻石*680，招募卡*10
 * */
async function jiubatequan() {
    let w = {
        key: "jiubatequan",
        patch: {$exists: false},
        del_time: {$exists: false}
    };
    let users = (await G.mongodb.collection("payLogNew").find(w).toArray()).filter(
        // 过滤没有结束时间 或者 有结束时间 但是没有过期的
        (pay) => pay.values?.length > 0 && (!pay.values.slice(-1)[0].eTime || pay.values.slice(-1)[0].eTime > G.time)
    );

    let uid2Prize: { [uid: string]: { a: string, t: string, n: number }[] } = {};
    users.forEach(user => {
        let uid = user.uid;

        if (!uid2Prize[uid]) uid2Prize[uid] = [];
        uid2Prize[uid].push({"a": "item", "t": "4", "n": 10});
        uid2Prize[uid].push({"a": "attr", "t": "rmbmoney", "n": 680});
    });

    let title = "抽奖特权优化";
    let content = "这是您的补偿，请查收！";
    let lngTitle = {
        "ja": "ガチャ特権仕様改善",
        "zh-TW": "抽獎特權改善",
        "ko": "모집 특권 시스템 개선",
        "en": "Gacha Benefit optimization",
    };
    let lngContent = {
        "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
        "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
        "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
        "zh-TW": "這是您的補償內容，煩請查收!"
    };
    for (const [uid, sendPrize] of Object.entries(uid2Prize)) {
        // 发放邮件
        await addEmail({
            uid: uid,
            type: "system",
            title: title,
            content: content,
            prize: sendPrize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });
        await G.mongodb.collection("payLogNew").updateMany(
            Object.assign({uid: uid}, w), {$set: {patch: 1}}
        )

        console.log(`玩家${uid}抽奖特权奖励补发完成...`);
    }
}

/**
 不需要给玩家发送邮件

 线上玩家脚本
 刷新所有玩家各档位VIP礼包到未购买状态
 **/
async function resetVipLiBao() {
    await G.mongodb.cPlayerInfo("chongzhi").updateMany(
        {type: 'chongzhi'}, {$set: {giftBy: {}}}
    )
}


/**
 人才计划调整
 1、线上已有该活动的玩家，保留次数进度；达到新加档位可领取的奖励则直接领取
 **/
async function rcjhReSet() {
    const hdid = [100, 101];
    const task = {
        '2001': {
            'prize': [{'a': 'item', 't': '4', 'n': 5}, {'a': 'item', 't': '626', 'n': 10}],
            'tujing': '',
            'title': 'intr_yczm_day_des_2',
            'type': 2,
            'pval': 50,
            'cond': [],
            'stype': 118
        },
        '2002': {
            'prize': [{'a': 'item', 't': '4', 'n': 5}, {'a': 'item', 't': '626', 'n': 10}],
            'tujing': '',
            'title': 'intr_yczm_day_des_2',
            'type': 2,
            'pval': 100,
            'cond': [],
            'stype': 118
        },
        '2003': {
            'prize': [{'a': 'item', 't': '4', 'n': 10}, {'a': 'item', 't': '626', 'n': 20}],
            'tujing': '',
            'title': 'intr_yczm_day_des_2',
            'type': 2,
            'pval': 200,
            'cond': [],
            'stype': 118
        },
        '2004': {
            'prize': [{'a': 'item', 't': '4', 'n': 10}, {'a': 'item', 't': '600', 'n': 20}],
            'tujing': '',
            'title': 'intr_yczm_day_des_2',
            'type': 2,
            'pval': 250,
            'cond': [],
            'stype': 118
        },
        '2005': {
            'prize': [{'a': 'item', 't': '4', 'n': 10}, {'a': 'item', 't': '600', 'n': 20}],
            'tujing': '',
            'title': 'intr_yczm_day_des_2',
            'type': 2,
            'pval': 300,
            'cond': [],
            'stype': 118
        },
        '2006': {
            'prize': [{'a': 'item', 't': '4', 'n': 10}, {'a': 'item', 't': '619', 'n': 1}],
            'tujing': '',
            'title': 'intr_yczm_day_des_2',
            'type': 2,
            'pval': 400,
            'cond': [],
            'stype': 118
        },
        '2007': {
            'prize': [{'a': 'item', 't': '4', 'n': 10}, {'a': 'item', 't': '619', 'n': 1}],
            'tujing': '',
            'title': 'intr_yczm_day_des_2',
            'type': 2,
            'pval': 500,
            'cond': [],
            'stype': 118
        }
    };
    // 中间插入了2004 所以之前的任务id一次往后顺延
    const change = {2004: 2005, 2005: 2006, 2006: 2007};
    // 刷新活动配置
    await G.mongodb.collection("hdinfo").updateOne({hdid: {$in: hdid}}, {
        "$set": {'data.tasklist.2': task}
    })

    let datas: yangchengmubiao[] = [];
    // 刷新玩家领取记录
    datas = datas.concat(await G.mongodb.cEvent(`yangchengmubiao${hdid[0]}`).find(
        {type: `yangchengmubiao${hdid[0]}`}
    ).toArray());
    datas = datas.concat(await G.mongodb.cEvent(`yangchengmubiao${hdid[1]}`).find(
        {type: `yangchengmubiao${hdid[1]}`}
    ).toArray());
    for (let i = 0; i < datas.length; i++) {
        let data = datas[i];
        let finished = data.finishid["2"].map((task) => {
            return change[task] ? change[task] : task
        });
        let maxtaskval = Math.max(...Object.values(data.taskval));
        let taskval = Object.assign(Object.keys(task).map((taskid) => {
            return {[taskid]: maxtaskval}
        }));
        await G.mongodb.collection("event").updateOne(
            {uid: data.uid, type: data.type}, {$set: {taskval: taskval, "finishid.2": finished}}
        )
        console.log(`修复玩家${data.uid}人才计划数据完成...`);
    }
}


/**
 * 标题：等级基金优化
 * ja:レベル投資仕様改善
 * zh-TW:等級基金改善
 * ko:레벨 투자 시스템 개선
 * en: Level Investment optimization

 * 內文：
 * 这是您的补偿，请查收！
 * ja:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 * zh-TW:這是您的補償內容，煩請查收!
 * ko:투자 시스템 개선으로 인한 보상을 보내드립니다.
 * en: Please find attached a few items as a compensation for the wait during our adjustments.

 * 线上玩家脚本
 * 1、已购买等级基金的玩家且未领取完成的玩家，剩余奖励邮件一次性补发；
 * 2、未购买的玩家活动刷新到新版本；
 * 3、刷新等级基金到未购买状态；
 */
async function dengjiJiJinReSet() {
    let w = {key: "dengjijijin", del_time: {$exists: false}}
    // 激活了的玩家
    let _payList = (await G.mongodb.collection("payLogNew").find(w).toArray()).filter(
        // 过滤没有结束时间 或者 有结束时间 但是没有过期的
        (pay) => pay.values?.length > 0 && (!pay.values.slice(-1)[0].eTime || pay.values.slice(-1)[0].eTime > G.time)
    );

    const prizeList = [
        {
            "type": "dengjijijin",
            "total": 20,
            "pt": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 300
                }
            ],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 1700
                }
            ]
        },
        {
            "type": "dengjijijin",
            "total": 25,
            "pt": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 300
                }
            ],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 1700
                }
            ]
        },
        {
            "type": "dengjijijin",
            "total": 30,
            "pt": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 300
                }
            ],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 1700
                }
            ]
        },

        {
            "type": "dengjijijin",
            "total": 35,
            "pt": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 300
                }
            ],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 1700
                }
            ]
        },
        {
            "type": "dengjijijin",
            "total": 40,
            "pt": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 300
                }
            ],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 1700
                }
            ]
        },
        {
            "type": "dengjijijin",
            "total": 45,
            "pt": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 300
                }
            ],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 1700
                }
            ]
        },

        {
            "type": "dengjijijin",
            "total": 50,
            "pt": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 300
                }
            ],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 1700
                }
            ]
        },
        {
            "type": "dengjijijin",
            "total": 55,
            "pt": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 300
                }
            ],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 1700
                }
            ]
        }
    ];
    let _users = await G.mongodb.cEvent("dengjijijin").find(
        {"uid": {"$in": _payList.map(pay => pay.uid)}, type: 'dengjijijin'}
    ).toArray()

    let uid2Prize: { [uid: string]: { a: string, t: string, n: number }[] } = {};
    _users.forEach((user) => {
        let uid = user.uid;
        let idx2Type2Bool = user.rec;
        if (!uid2Prize[uid]) uid2Prize[uid] = [];

        // 没领的全发
        prizeList.forEach((con, idx) => {
            // 普通奖励没领
            if (!idx2Type2Bool[idx]?.pt) {
                uid2Prize[uid].push(...con.pt)
            }
            // 高级奖励没领
            if (!idx2Type2Bool[idx]?.tq) {
                uid2Prize[uid].push(...con.tq)
            }
        });
    })

    let title = "等级基金优化";
    let content = "这是您的补偿，请查收！";
    let lngTitle = {
        "ja": "レベル投資仕様改善",
        "zh-TW": "等級基金改善",
        "ko": "레벨 투자 시스템 개선",
        "en": "Level Investment optimization",
    };
    let lngContent = {
        "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
        "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
        "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
        "zh-TW": "這是您的補償內容，煩請查收!"
    };
    for (const [uid, sendPrize] of Object.entries(uid2Prize)) {
        // 发放邮件
        await addEmail({
            uid: uid,
            type: "system",
            title: title,
            content: content,
            prize: sendPrize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });
        await G.mongodb.collection("payLogNew").updateMany(
            Object.assign({uid: uid}, w), {$set: {patch: 1, del_time: G.time}}
        )
        // 基金数据清除
        await G.mongodb.collection("event").updateMany(
            {type: "dengjijijin", uid: uid}, {"$set": {uid: `${uid}_patch_del`}}
        );
        console.log(`玩家${uid}等级基金奖补发完成...`);
    }
}


/**
 * 标题：关卡基金优化
 * ja:ステージ投資仕様改善
 * zh-TW:關卡基金改善
 * ko:스테이지 투자 시스템 개선
 * en: Stage Investment optimization
 *
 * 內文：这是您的补偿，请查收！
 * ja:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 * zh-TW:這是您的補償內容，煩請查收!
 * ko:투자 시스템 개선으로 인한 보상을 보내드립니다.
 * en: Please find attached a few items as a compensation for the wait during our adjustments.

 * 线上玩家脚本
 * 1、已购买关卡基金的玩家且未领取完成的玩家，剩余奖励邮件一次性补发；
 * 2、未购买的玩家活动刷新到新版本；
 * 3、刷新关卡基金到未购买状态；
 * */
async function guanqiaJiJinReSet() {
    let w = {key: "guanqiajijin"};
    // 激活了的玩家
    let _payList = (await G.mongodb.collection("payLogNew").find(w).toArray()).filter(
        // 过滤没有结束时间 或者 有结束时间 但是没有过期的
        (pay) => pay.values?.length > 0 && (!pay.values.slice(-1)[0].eTime || pay.values.slice(-1)[0].eTime > G.time)
    );

    const prizeList = [
        {
            "type": "guanqiajijin",
            "total": 30,
            "pt": [],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 2000
                }
            ],
            "des": "guanqiajijin_des_1"
        },
        {
            "type": "guanqiajijin",
            "total": 50,
            "pt": [],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 2000
                }
            ],
            "des": "guanqiajijin_des_2"
        },
        {
            "type": "guanqiajijin",
            "total": 70,
            "pt": [],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 2000
                }
            ],
            "des": "guanqiajijin_des_3"
        },
        {
            "type": "guanqiajijin",
            "total": 90,
            "pt": [],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 2000
                }
            ],
            "des": "guanqiajijin_des_4"
        },
        {
            "type": "guanqiajijin",
            "total": 110,
            "pt": [],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 2000
                }
            ],
            "des": "guanqiajijin_des_5"
        },
        {
            "type": "guanqiajijin",
            "total": 150,
            "pt": [],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 2000
                }
            ],
            "des": "guanqiajijin_des_6"
        },
        {
            "type": "guanqiajijin",
            "total": 180,
            "pt": [],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 2000
                }
            ],
            "des": "guanqiajijin_des_7"
        },
        {
            "type": "guanqiajijin",
            "total": 250,
            "pt": [],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 2000
                }
            ],
            "des": "guanqiajijin_des_8"
        }
    ];

    // 没激活不处理
    let _users = await G.mongodb.cEvent("guanqiajijin").find(
        {
            "uid": {"$in": _payList.map(pay => pay.uid)},
            "type": 'guanqiajijin'
        },
        {projection: {_id: 0}}
    ).toArray();

    let uid2Prize: { [uid: string]: { a: string, t: string, n: number }[] } = {};
    _users.forEach(user => {
        let uid = user.uid;
        let idx2Type2Bool = user.rec;
        if (!uid2Prize[uid]) uid2Prize[uid] = [];

        // 没领的全发
        prizeList.forEach((con, idx) => {
            // 普通奖励没领
            if (!idx2Type2Bool[idx]?.pt) {
                uid2Prize[uid].push(...con.pt)
            }
            // 高级奖励没领
            if (!idx2Type2Bool[idx]?.tq) {
                uid2Prize[uid].push(...con.tq)
            }
        });
    })

    let title = "关卡基金优化";
    let content = "这是您的补偿，请查收！";
    let lngTitle = {
        "ja": "ステージ投資仕様改善",
        "zh-TW": "關卡基金改善",
        "ko": "스테이지 투자 시스템 개선",
        "en": "Stage Investment optimization",
    };
    let lngContent = {
        "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
        "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
        "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
        "zh-TW": "這是您的補償內容，煩請查收!"
    };
    for (const [uid, sendPrize] of Object.entries(uid2Prize)) {
        // 发放邮件
        await addEmail({
            uid: uid,
            type: "system",
            title: title,
            content: content,
            prize: sendPrize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });
        await G.mongodb.collection("payLogNew").updateMany(
            Object.assign({uid: uid}, w), {$set: {patch: 1, del_time: G.time}}
        )
        // 基金数据清除
        await G.mongodb.collection("event").updateMany(
            {type: "guanqiajijin", uid: uid}, {"$set": {uid: `${uid}_patch_del`}}
        );
        console.log(`玩家${uid}关卡基金奖补发完成...`);
    }
}


/**
 * 标题：特别通行证优化
 * ja:特別通行証仕様改善
 * zh-TW:特別通行證改善
 * ko:특별 통행증 시스템 개선
 * en: Special Permit optimization

 * 內文：这是您的补偿，请查收！
 * ja:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 * zh-TW:這是您的補償內容，煩請查收!
 * ko:투자 시스템 개선으로 인한 보상을 보내드립니다.
 * en: Please find attached a few items as a compensation for the wait during our adjustments.

 * 线上玩家脚本
 * 1、已购买通行证基金的玩家且未领取完成的玩家，剩余奖励邮件一次性补发；
 * 2、未购买的玩家活动刷新到新版本；
 * 3、刷新通行证基金到未购买状态；
 * */
async function dayjiJiJinReSet() {
    let w = {key: "dayjijin"};

    // 激活了的玩家
    let _payList = (await G.mongodb.collection("payLogNew").find(w).toArray()).filter(
        // 过滤没有结束时间 或者 有结束时间 但是没有过期的
        (pay) => pay.values?.length > 0 && (!pay.values.slice(-1)[0].eTime || pay.values.slice(-1)[0].eTime > G.time)
    );

    const prizeList = [
        {
            "type": "dayjijin",
            "total": 5,
            "pt": [
                {
                    "a": "item",
                    "t": "23",
                    "n": 20000
                }
            ],
            "tq": [
                {
                    "a": "item",
                    "t": "4",
                    "n": 5
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 15,
            "pt": [
                {
                    "a": "item",
                    "t": "2",
                    "n": 200
                }
            ],
            "tq": [
                {
                    "a": "item",
                    "t": "2",
                    "n": 2000
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 30,
            "pt": [
                {
                    "a": "item",
                    "t": "23",
                    "n": 20000
                }
            ],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 888
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 45,
            "pt": [
                {
                    "a": "item",
                    "t": "2",
                    "n": 200
                }
            ],
            "tq": [
                {
                    "a": "item",
                    "t": "615",
                    "n": 1
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 60,
            "pt": [
                {
                    "a": "item",
                    "t": "23",
                    "n": 20000
                }
            ],
            "tq": [
                {
                    "a": "item",
                    "t": "4",
                    "n": 5
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 75,
            "pt": [
                {
                    "a": "item",
                    "t": "2",
                    "n": 300
                }
            ],
            "tq": [
                {
                    "a": "item",
                    "t": "2",
                    "n": 2000
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 90,
            "pt": [
                {
                    "a": "item",
                    "t": "23",
                    "n": 20000
                }
            ],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 888
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 105,
            "pt": [
                {
                    "a": "item",
                    "t": "2",
                    "n": 300
                }
            ],
            "tq": [
                {
                    "a": "item",
                    "t": "615",
                    "n": 1
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 120,
            "pt": [
                {
                    "a": "item",
                    "t": "23",
                    "n": 20000
                }
            ],
            "tq": [
                {
                    "a": "item",
                    "t": "4",
                    "n": 5
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 135,
            "pt": [
                {
                    "a": "item",
                    "t": "2",
                    "n": 400
                }
            ],
            "tq": [
                {
                    "a": "item",
                    "t": "2",
                    "n": 2000
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 150,
            "pt": [
                {
                    "a": "item",
                    "t": "23",
                    "n": 20000
                }
            ],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 888
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 165,
            "pt": [
                {
                    "a": "item",
                    "t": "2",
                    "n": 400
                }
            ],
            "tq": [
                {
                    "a": "item",
                    "t": "615",
                    "n": 1
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 180,
            "pt": [
                {
                    "a": "item",
                    "t": "23",
                    "n": 20000
                }
            ],
            "tq": [
                {
                    "a": "item",
                    "t": "4",
                    "n": 5
                }
            ]
        },
        {
            "type": "dayjijin",
            "total": 200,
            "pt": [
                {
                    "a": "item",
                    "t": "2",
                    "n": 500
                }
            ],
            "tq": [
                {
                    "a": "attr",
                    "t": "rmbmoney",
                    "n": 1888
                }
            ]
        }
    ];
    // 没激活不处理
    let _users = await G.mongodb.cEvent("dayjijin").find(
        {uid: {$in: _payList.map(pay => pay.uid)}, type: "dayjijin"}
    ).toArray();

    let uid2Prize: { [uid: string]: { a: string, t: string, n: number }[] } = {};
    _users.forEach(user => {
        let uid = user.uid;
        let idx2Type2Bool = user.rec;
        if (!uid2Prize[uid]) uid2Prize[uid] = [];

        // 没领的全发
        prizeList.forEach((con, idx) => {
            // 普通奖励没领
            if (!idx2Type2Bool[idx]?.pt) {
                uid2Prize[uid].push(...con.pt)
            }
            // 高级奖励没领
            if (!idx2Type2Bool[idx]?.tq) {
                uid2Prize[uid].push(...con.tq)
            }
        });
    })

    let title = "特别通行证优化";
    let content = "这是您的补偿，请查收！";
    let lngTitle = {
        "ja": "特別通行証仕様改善",
        "zh-TW": "特別通行證改善",
        "ko": "특별 통행증 시스템 개선",
        "en": "Special Permit optimization",
    };
    let lngContent = {
        "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
        "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
        "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
        "zh-TW": "這是您的補償內容，煩請查收!"
    };
    for (const [uid, sendPrize] of Object.entries(uid2Prize)) {
        // 发放邮件
        await addEmail({
            uid: uid,
            type: "system",
            title: title,
            content: content,
            prize: sendPrize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });
        await G.mongodb.collection("payLogNew").updateMany(
            Object.assign({uid: uid}, w), {$set: {patch: 1, del_time: G.time}}
        )
        // 基金数据清除
        await G.mongodb.collection("event").updateMany(
            {type: "dayjijin", uid: uid}, {"$set": {uid: `${uid}_patch_del`}}
        );

        console.log(`玩家${uid}通行证基金奖补发完成...`);
    }
}

/**
 * 标题:特价基金优化
 * ja:特価投資仕様改善
 * zh-TW:特價基金改善
 * ko:특가 투자 시스템 개선
 * en: Value Investment optimization

 * 內文：这是您的补偿，请查收！
 * ja:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 * zh-TW:這是您的補償內容，煩請查收!
 * ko:투자 시스템 개선으로 인한 보상을 보내드립니다.
 * en: Please find attached a few items as a compensation for the wait during our adjustments.

 * 线上玩家脚本
 * 1、已购买特价基金128的玩家且未领取完成的玩家，剩余奖励邮件一次性补发；
 * 2、未购买的玩家活动刷新到新版本；
 * 3、刷新月基金到未购买状态；
 * */
async function yue128JiJinReSet() {
    let w = {key: "128jijin"};
    // 激活了的玩家
    let _payList = (await G.mongodb.collection("payLogNew").find(w).toArray()).filter(
        // 过滤没有结束时间 或者 有结束时间 但是没有过期的
        (pay) => pay.values?.length > 0 && (!pay.values.slice(-1)[0].eTime || pay.values.slice(-1)[0].eTime > G.time)
    );

    // 没激活不处理
    let _users = await G.mongodb.cEvent(`${128}jijin`).find(
        {
            "uid": {"$in": _payList.map(pay => pay.uid)},
            "type": `${128}jijin`
        }
    ).toArray();

    const prizeList = [
        {a: 'item', t: '4', n: 10},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'item', t: '9', n: 2000},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'item', t: '609', n: 1},
        {a: 'item', t: '4', n: 10},
        {a: 'attr', t: 'rmbmoney', n: 500},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'item', t: '18', n: 300},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'item', t: '6', n: 20},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'item', t: '9', n: 3000},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'item', t: '4', n: 10},
        {a: 'attr', t: 'rmbmoney', n: 500},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'item', t: '20', n: 200},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'item', t: '9', n: 3000},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'attr', t: 'rmbmoney', n: 300},
        {a: 'attr', t: 'rmbmoney', n: 1000},
        {a: 'item', t: '628', n: 1},
    ];
    let uid2Prize: { [uid: string]: { a: string, t: string, n: number }[] } = {};

    _users.forEach(user => {
        let uid = user.uid;
        let gotarr = user.rec || [];
        if (!uid2Prize[uid]) uid2Prize[uid] = [];

        // 没领的全发
        prizeList.forEach((onePrize, idx) => {
            // 领过了
            if (gotarr.includes(idx)) {
                return
            }
            uid2Prize[uid].push(onePrize)
        });
    })

    let title = "特价基金优化";
    let content = "这是您的补偿，请查收！";
    let lngTitle = {
        "ja": "特価投資仕様改善",
        "zh-TW": "特價基金改善",
        "ko": "특가 투자 시스템 개선",
        "en": "Value Investment optimization",
    };
    let lngContent = {
        "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
        "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
        "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
        "zh-TW": "這是您的補償內容，煩請查收!"
    };
    for (const [uid, sendPrize] of Object.entries(uid2Prize)) {
        // 发放邮件
        await addEmail({
            uid: uid,
            type: "system",
            title: title,
            content: content,
            prize: sendPrize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });

        await G.mongodb.collection("payLogNew").updateMany(
            Object.assign({uid: uid}, w), {$set: {patch: 1, del_time: G.time}}
        )
        // 基金数据清除
        await G.mongodb.cEvent(`${128}jijin`).updateMany(
            {uid: uid, type: `${128}jijin`}, {"$set": {uid: `${uid}_patch_del`}}
        );

        console.log(`玩家${uid}月度128基金奖补发完成...`);
    }
}

/**
 * 标题：特别基金优化
 * ja:特別投資仕様改善
 * zh-TW:特別基金改善
 * ko:특별 투자 시스템 개선
 * en: Special Investment optimization

 * 內文：这是您的补偿，请查收！
 * ja:仕様改善に伴う補填を発送させていただきました。ご確認ください。
 * zh-TW:這是您的補償內容，煩請查收!
 * ko:투자 시스템 개선으로 인한 보상을 보내드립니다.
 * en: Please find attached a few items as a compensation for the wait during our adjustments.

 * 线上玩家脚本
 * 1、已购买特别基金328的玩家且未领取完成的玩家，剩余奖励邮件一次性补发；
 * 2、未购买的玩家活动刷新到新版本；
 * 3、刷新月基金到未购买状态；
 * */
async function yue328JiJinReSet() {
    let w = {key: "328jijin"};
    // 激活了的玩家
    let _payList = (await G.mongodb.collection("payLogNew").find(w).toArray()).filter(
        // 过滤没有结束时间 或者 有结束时间 但是没有过期的
        (pay) => pay.values?.length > 0 && (!pay.values.slice(-1)[0].eTime || pay.values.slice(-1)[0].eTime > G.time)
    );

    // 没激活不处理
    let _users = await G.mongodb.cEvent(`${328}jijin`).find(
        {
            "uid": {"$in": _payList.map(pay => pay.uid)}, "type": `${328}jijin`
        }
    ).toArray();

    const prizeList = [
        {a: 'item', t: '4', n: 30},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'item', t: '10', n: 300},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'item', t: '628', n: 1},
        {a: 'item', t: '4', n: 20},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'item', t: '628', n: 1},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'item', t: '628', n: 1},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'item', t: '628', n: 1},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'item', t: '4', n: 20},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'item', t: '10', n: 400},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'item', t: '10', n: 400},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'attr', t: 'rmbmoney', n: 800},
        {a: 'attr', t: 'rmbmoney', n: 1500},
        {a: 'item', t: '617', n: 1},
    ];
    let uid2Prize: { [uid: string]: { a: string, t: string, n: number }[] } = {};

    _users.forEach(user => {
        let uid = user.uid;
        let gotarr = user.rec || [];
        if (!uid2Prize[uid]) uid2Prize[uid] = [];

        // 没领的全发
        prizeList.forEach((onePrize, idx) => {
            // 领过了
            if (gotarr.includes(idx)) {
                return
            }
            uid2Prize[uid].push(onePrize)
        });
    })

    let title = "特别基金优化";
    let content = "这是您的补偿，请查收！";
    let lngTitle = {
        "ja": "特別投資仕様改善",
        "zh-TW": "特別基金改善",
        "ko": "특별 투자 시스템 개선",
        "en": "Special Investment optimization",
    };
    let lngContent = {
        "en": "Please find attached a few items as a compensation for the wait during our adjustments.",
        "ja": "仕様改善に伴う補填を発送させていただきました。ご確認ください。",
        "ko": "투자 시스템 개선으로 인한 보상을 보내드립니다.",
        "zh-TW": "這是您的補償內容，煩請查收!"
    };
    for (const [uid, sendPrize] of Object.entries(uid2Prize)) {
        // 发放邮件
        await addEmail({
            uid: uid,
            type: "system",
            title: title,
            content: content,
            prize: sendPrize,
            lngTitle: lngTitle,
            lngContent: lngContent,
        });

        await G.mongodb.collection("payLogNew").updateMany(
            Object.assign({uid: uid}, w), {$set: {patch: 1, del_time: G.time}}
        )
        // 基金数据清除
        await G.mongodb.cEvent(`${328}jijin`).updateMany(
            {uid: uid, type: `${328}jijin`}, {"$set": {uid: `${uid}_patch_del`}}
        );

        console.log(`玩家${uid}月度128基金奖补发完成...`);
    }
}

async function start() {
    await initMongoDB();

    await shouChongReSet();
    await zhizunyueka();
    await chaozhiyueka();
    await zhongshenka();

    await qingbaotequan();
    await zuozhantequan();
    await caifutequan();
    await jiubatequan();

    await resetVipLiBao();

    await rcjhReSet();

    await dengjiJiJinReSet();
    await guanqiaJiJinReSet();

    await dayjiJiJinReSet();

    await yue128JiJinReSet();
    await yue328JiJinReSet();
}

ctor();
start().then(() => {
    setInterval(() => {
        console.log(new Date().format("MM-dd hh:mm:ss"));
    }, 1000)
    console.log("逻辑执行完成...等待退出！！！");
});


