import SevenDayGiftApi, { SevenDayClaimResult, SevenDayRewardItem } from "./SevenDayGiftApi";

const PROCESSED_CLAIMS_KEY = "seven_day_gift_processed_claims_v1";

export default class SevenDayGiftReward {
    public static grant(result: SevenDayClaimResult, callback: (success: boolean, message?: string) => void) {
        if (!result || !result.claimId || !Array.isArray(result.rewards)) {
            callback(false, "服务器奖励数据不完整");
            return;
        }
        if (this.hasProcessed(result.claimId)) {
            callback(true);
            return;
        }

        let coin = 0;
        let hammer = 0;
        let freeze = 0;
        let magic = 0;
        let infiniteHealth = 0;
        const cats: number[] = [];

        result.rewards.forEach((item: SevenDayRewardItem) => {
            const rewardAmount = item.count !== undefined ? item.count : item.amount;
            const amount = Math.max(0, Number(rewardAmount) || 0);
            switch (item.type) {
                case "coin": coin += amount; break;
                case "hammer": hammer += amount; break;
                case "freeze": freeze += amount; break;
                case "magic_wand": magic += amount; break;
                case "infinite_health": infiniteHealth += amount; break;
                case "cat_skin":
                    if (item.itemId !== undefined) cats.push(Number(item.itemId));
                    break;
            }
        });

        this.grantCommonRewards(coin, hammer, freeze, magic, infiniteHealth, (commonSuccess: boolean, commonMessage?: string) => {
            if (!commonSuccess) {
                callback(false, commonMessage);
                return;
            }
            this.saveCats(cats, 0, (success: boolean, message?: string) => {
                if (!success) {
                    callback(false, message);
                    return;
                }
                this.markProcessed(result.claimId);
                callback(true);
            });
        });
    }

    private static grantCommonRewards(
        coin: number,
        hammer: number,
        freeze: number,
        magic: number,
        infiniteHealth: number,
        callback: (success: boolean, message?: string) => void,
    ) {
        if (coin > 0) {
            cc.fx.GameTool.changeCoin(coin);
        }

        let propData = null;
        if (hammer > 0 || freeze > 0 || magic > 0) {
            const info = cc.fx.GameConfig.GM_INFO;
            info.hammerAmount = (Number(info.hammerAmount) || 0) + hammer;
            info.freezeAmount = (Number(info.freezeAmount) || 0) + freeze;
            info.magicAmount = (Number(info.magicAmount) || 0) + magic;
            propData = {
                freeze: info.freezeAmount,
                hammer: info.hammerAmount,
                magic_wand: info.magicAmount,
            };
            cc.fx.StorageMessage.setStorage("prop", {
                hammerAmount: info.hammerAmount,
                freezeAmount: info.freezeAmount,
                magicAmount: info.magicAmount,
                timestamp: Date.now(),
            });
        }

        if (infiniteHealth > 0) {
            cc.fx.GameTool.setUserPowerTime(infiniteHealth, "seven_day_gift");
        }

        const canvas = cc.find("Canvas");
        const home: any = canvas && canvas.getComponent("JiaZai");
        if (home && home.updateCoin) {
            home.updateCoin();
        }

        if (!propData) {
            callback(true);
            return;
        }

        SevenDayGiftApi.saveProps(propData, response => {
            if (!response || response.code !== 1) {
                callback(false, response && response.msg ? response.msg : "道具同步失败");
                return;
            }
            callback(true);
        });
    }

    private static saveCats(cats: number[], index: number, callback: (success: boolean, message?: string) => void) {
        if (index >= cats.length) {
            callback(true);
            return;
        }
        const catNum = cats[index];
        SevenDayGiftApi.saveCat(catNum, response => {
            const alreadySaved = response && response.msg === "已保存猫咪";
            if (!response || (response.code !== 1 && !alreadySaved)) {
                callback(false, response && response.msg ? response.msg : "猫咪保存失败");
                return;
            }
            const current = Array.isArray(cc.fx.GameConfig.GM_INFO.catArr)
                ? cc.fx.GameConfig.GM_INFO.catArr.slice()
                : [];
            if (current.indexOf(catNum) < 0) current.push(catNum);
            cc.fx.GameConfig.GM_INFO.catArr = response.data && Array.isArray(response.data.catArr)
                ? response.data.catArr
                : current;
            this.saveCats(cats, index + 1, callback);
        });
    }

    private static hasProcessed(claimId: string): boolean {
        const records = cc.fx.StorageMessage.getStorage(PROCESSED_CLAIMS_KEY) || {};
        return records[this.claimKey(claimId)] === true;
    }

    private static markProcessed(claimId: string) {
        const records = cc.fx.StorageMessage.getStorage(PROCESSED_CLAIMS_KEY) || {};
        records[this.claimKey(claimId)] = true;
        cc.fx.StorageMessage.setStorage(PROCESSED_CLAIMS_KEY, records);
    }

    private static claimKey(claimId: string): string {
        return SevenDayGiftApi.getUid() + ":" + claimId;
    }
}