import MapConroler from "../../Map";
import Freeze from "../../prop/Freeze";
import SceneManager from "../../SceneManager";
import { MiniGameSdk } from "../../Sdk/MiniGameSdk";
import Utils from "../Pay/Utils";
//@ts-ignore
//最大工具类  各种公共方法，以及处理上传，获取后端接口数据
var GameTool = {
    _startTime: 0,
    _endTime: 0,
    _totalTime: 0,

    //获取userId
    Authentication() {
        let name = "user_" + cc.fx.GameConfig.GM_INFO.gameId;
        var data = JSON.parse(localStorage.getItem(name));
        if (data == "undifend" || data == null || data == "") {
            var urlNow = window.location.href;
            if (!this.containsTrain(urlNow)) {
                let url = "https://api.sparkus.cn/api/user/auth/login?domain=hui32579WdYPsgYq&callback=" + location.href;
                window.location.href = url;
            }
        }
        else {
            cc.fx.StorageMessage.setStorage(name, data);
            cc.fx.GameConfig.GM_INFO.userId = parseInt(data.userId);
        }
    },

    containsTrain(str) {
        return /from=train/i.test(str);
    },

    //埋点上传
    setGameData() {
        //GAME_DATA 初始化 每次清零
        cc.fx.GameConfig.GAME_DATA = [];
        cc.fx.GameConfig.GAME_DATA.push(cc.fx.GameConfig.CLICK_DATA);
        cc.fx.GameConfig.CLICK_init();
        let data = cc.fx.GameConfig.GAME_DATA;
        let matchId = this.getMatchId();
        let postData = {
            "gameId": cc.fx.GameConfig.GM_INFO.gameId,
            "userId": cc.fx.GameConfig.GM_INFO.userId,
            "scode": cc.fx.GameConfig.GM_INFO.scode,
            "matchId": matchId,
            "data": data
        };

        // console.log("上传数据:",postData);
        // cc.fx.HttpUtil.uploadUserLogData(postData,function(){})
    },
    //上传排行榜  type为1
    setRank(data) {
        //GAME_DATA 初始化 每次清零
        let postData = {
            "gameId": cc.fx.GameConfig.GM_INFO.gameId,
            "userId": cc.fx.GameConfig.GM_INFO.userId,
            "type": 1,
            "score": data.score,
            "accuracy": data.date,
            "success": cc.fx.GameConfig.GM_INFO.success
        };
        // cc.fx.HttpUtil.rankData(1,function(){},postData);
    },
    //获取排行榜 type为2
    getRank(data, callback) {
        let rankLength = data.length;
        let postData = {
            "gameId": cc.fx.GameConfig.GM_INFO.gameId,
            "userId": cc.fx.GameConfig.GM_INFO.userId,
            "page": 1,
            "pageSize": rankLength
        };
        //回调进getRankData
        // cc.fx.HttpUtil.rankData(2,data =>{callback(data)},postData);
    },
    //获取matchId  用于上传每次点击数据里面记录id方便查询
    getMatchId() {
        let matchId = cc.sys.localStorage.getItem("matchId");
        let tempId = matchId;
        if (matchId == "undifend" || matchId == null) {
            matchId = this.setMatchId();
        }
        else {
            if (this.containsNanana(matchId) == true) {
                matchId = this.setMatchId();
            }
            else {
                let char = parseInt(tempId.substring(10, tempId.length));
                if (cc.fx.GameConfig.GM_INFO.level == 1) {
                    char += 1;
                    matchId = tempId.slice(0, 10) + char + "";
                    if (this.containsNanana(matchId)) matchId = this.setMatchId();
                    cc.fx.GameConfig.GM_INFO.matchId = matchId;
                    cc.sys.localStorage.setItem("matchId", matchId);
                }
            }
        }

        if (this.containsNanana(matchId) == true) {
            matchId = this.setMatchId();
        }
        return matchId;
    },
    //检测matchId 如果有缓存以前的nanana数据清除
    containsNanana(str) {
        return /na/i.test(str);
    },
    //重新设置MatchId
    setMatchId() {
        // 定义包含可用字符的字符集
        const characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
        // 创建一个数组以保存随机字符
        const uuidArray = [];
        // 循环10次 生成10位的UUID
        for (let i = 0; i < 10; i++) {
            // 生成随机索引，范围是字符集的长度
            const randomIndex = Math.floor(Math.random() * characters.length);
            // 从字符集中获取随机字符
            const randomChar = characters.charAt(randomIndex);
            // 将字符添加到数组中
            uuidArray.push(randomChar);
        }
        let data = uuidArray.join('') + 1 + "";
        cc.sys.localStorage.setItem("matchNumber", 1);
        cc.sys.localStorage.setItem("matchId", data);
        cc.fx.GameConfig.GM_INFO.matchId = data;
        return data;
    },
    //截取名字
    subName(name, length) {
        if (name.length > length) {
            name = name.substring(0, length) + "..."
        }
        return name;
    },
    //设置头像
    setPic(node, pic) {
        node.active = false;
        let url = pic;
        setTimeout(() => {
            fetch(url)
                .then(response => {
                    return response.headers.get('Content-Length');
                })
                .then(errNo => {
                    if (errNo == "5093") {
                        node.active = true;
                    }
                })
                .catch(error => {
                    // console.error('Error fetching X-Info:', error);
                });
        }, 100);
        cc.assetManager.loadRemote(url, { ext: '.png' }, (err, texture: cc.Texture2D) => {
            if (texture) {
                node.active = true;
                node.getComponent(cc.Sprite).spriteFrame = new cc.SpriteFrame(texture);
            }
            else {
                // console.log(err,texture)
            }
        })
    },
    //第一个参数把目标带进来处理，第二个参数为名字长度，不同场景不同需求
    //名字4短，小排行，名字6长，大排行
    getRankData(data, target, nameLength) {
        target.listData = data.data.list;
        target.selfData = data.data.info;
        let rankData = [];
        let self = false;
        cc.fx.GameTool.setPic(target.selfNode.getChildByName("pic").getChildByName("icon"), target.selfData.pic);
        for (let i = 0; i <= target.listData.length - 1; i++) {
            rankData.push({ rank: (i + 1), name: target.listData[i].nickName, total: target.listData[i].score, time: null, pic: target.listData[i].pic });
            if (cc.fx.GameConfig.GM_INFO.userId == target.listData[i].userId) {
                self = true;
                target.rankNumber = i;
                target.selfNode.getChildByName("rankLab").getComponent(cc.Label).string = (i + 1) + "";
            }
            if (i == (target.listData.length - 1) && self == false) {
                target.rankNumber = i;
                target.selfNode.getChildByName("rankLab").getComponent(cc.Label).string = "99+";
            }
        }
        target.selfData.nickName = cc.fx.GameTool.subName(target.selfData.nickName, nameLength);
        target.selfNode.getChildByName("nameLab").getComponent(cc.Label).string = target.selfData.nickName;
        target.selfNode.getChildByName("totalLab").getComponent(cc.Label).string = target.selfData.score;
        let timeTemp = cc.fx.GameTool.getTimeShenNong(target.selfData.totleTimes);
        // target.selfNode.getChildByName("timeLab").getComponent(cc.Label).string = timeTemp + "";
        switch (target.selfNode.getChildByName("rankLab").getComponent(cc.Label).string) {
            case "1":
                target.selfNode.getChildByName("rank").getChildByName("one").active = true;
                break;
            case "2":
                target.selfNode.getChildByName("rank").getChildByName("two").active = true;
                break;
            case "3":
                target.selfNode.getChildByName("rank").getChildByName("three").active = true;
                break;
        }
        // 大排行
        if (nameLength == 6) {
            target.rankList.setData(rankData);
            target.selfNode.opacity = 255;
            if (target.selfData.totalSunCount == 0) target.selfNode.opacity = 0;
        }
    },

    getSeedRandom: function (min, max) {//包含min 不包含max
        // console.log("随机数:",cc.fx.GameConfig.GM_INFO.currSeed);
        max = max || 1;
        min = min || 0;
        cc.fx.GameConfig.GM_INFO.currSeed = (cc.fx.GameConfig.GM_INFO.currSeed * 9301 + 49297) % 233280;
        let rnd = cc.fx.GameConfig.GM_INFO.currSeed / 233280.0;
        let tmp = min + rnd * (max - min);
        return parseInt(tmp);
    },
    //获取关卡配置的那个关卡数
    getCustom(type) {
        let custom = cc.fx.StorageMessage.getStorage(cc.fx.storageType.storageTypeCustom);
        if (custom == "undifend" || custom == null || custom == "") {
            this.setCustom();
        }
        else {
            cc.fx.GameConfig.GM_INFO_SET("custom", custom[0]);
            if (custom[0] != 0 || type == true) {
                custom.shift();
                if (custom.length == 0) {
                    this.setCustom();
                }
                else cc.fx.StorageMessage.setStorage(cc.fx.storageType.storageTypeCustom, custom);
            }
        }
    },
    //本地没有存储到配置，或者配置用完，重新创建配置
    setCustom() {
        let arrayLength = cc.fx.GameConfig.LEVEL_INFO.length;
        let arrayList = [];
        for (let i = 1; i < arrayLength; i++) {
            arrayList.push(i);
        }
        arrayList.sort(() => Math.random() - 0.5);
        arrayList.unshift(0)
        cc.fx.GameConfig.GM_INFO_SET("custom", arrayList[0]);
        cc.fx.StorageMessage.setStorage(cc.fx.storageType.storageTypeCustom, arrayList);
    },


    getSetScreenResolutionFlag: function () {
        let size = cc.winSize;
        let width = size.width;
        let height = size.height;
        if ((height / width) > (16.2 / 9)) return false;
        return true;
    },
    //判断全面屏适配
    setFit: function (canvas) {
        let flag = cc.fx.GameTool.getSetScreenResolutionFlag();
        if (flag) {
            // console.log("不是全面屏");
        } else {
            // console.log("是全面屏");
        }
        return flag;
    },
    //获取游戏信息
    getGameInfo: function (node) {
        var jg = false;
        return jg;
    },
    //设置游戏信息
    setGameInfo: function (pd) {

    },

    //打字机效果
    typingAni(label, text, cb, target) {
        var self = target;
        var html = '';
        var arr = text.split('');
        var len = arr.length;
        var step = 0;
        self.func = () => {
            html += arr[step];
            label.string = html;
            if (++step == len) {
                self.unschedule(self.func);
                cb && cb();
            }
        }
        self.schedule(self.func, 0.1, cc.macro.REPEAT_FOREVER, 0)
    },

    //输入秒,返回需要展示时间格式
    getTimeMargin: (second) => {
        let total = 0;
        total = second;
        let hour = 0;
        hour = parseInt((total / 3600) + "");//计算整数小时数
        let afterHour = total - hour * 60 * 60;//取得算出小时数后剩余的秒数
        let min = parseInt((afterHour / 60) + "");//计算整数分
        let m = "" + min;
        if (min < 10) m = "0" + min;
        let afterMin = total - hour * 60 * 60 - min * 60;//取得算出分后剩余的秒数
        let miao = afterMin + "";
        if (afterMin < 10) miao = "0" + afterMin;
        return m + ':' + miao
    },

    //输入秒,返回需要展示时间格式
    getTimeMargin2: (second) => {
        // 计算总秒数
        let total = Math.floor(second);
        // 计算小时数
        const hours = Math.floor(total / 3600);
        total %= 3600;
        // 计算分钟数
        const minutes = Math.floor(total / 60);
        // 计算剩余秒数
        const seconds = total % 60;

        // 将小时、分钟和秒转换为两位数的字符串
        const hh = String(hours).padStart(2, '0');
        const mm = String(minutes).padStart(2, '0');
        const ss = String(seconds).padStart(2, '0');

        // 若小时数大于 0，返回包含小时的完整格式，否则只返回分和秒
        return hours > 0 ? `${hh}:${mm}:${ss}` : `${mm}:${ss}`;
    },

    //输入秒,返回需要展示时间格式
    getTimeShenNong: (second) => {
        second = parseInt(second / 1000 + "");
        let total = 0;
        total = second;
        let min = 0;
        if (total > 60) {
            min = parseInt((total / 60) + "");//计算整数分
        }
        let m = min + "'";

        let afterMin = total - min * 60;//取得算出分后剩余的秒数
        let miao = afterMin + "''";
        return m + miao
    },

    //打乱数组
    shuffleArray: function (array) {
        for (let i = array.length - 1; i > 0; i--) {
            const j = Math.floor(Math.random() * (i + 1));
            [array[i], array[j]] = [array[j], array[i]];
        }
        return array;
    },


    //增加关卡数
    addLevel(time1, time2) {
        cc.fx.GameConfig.GM_INFO.level += 1;
        if (cc.fx.GameConfig.GM_INFO.level > 249) {
            cc.fx.GameConfig.GM_INFO.level = 249;
        }
        const timestamp = Date.now();
        let levelInfo = {
            level: cc.fx.GameConfig.GM_INFO.level,
            timestamp: timestamp,
        }
        console.log("55555存储关卡数据:", time1, time2);

        cc.fx.StorageMessage.setStorage("level", levelInfo);
        if (time1 != null && time2 != null) {
            let data = {
                time: time1,
                add_Time: time2,
                result: "success"
            }
            cc.fx.GameTool.shushu_Track("finish_stage", data);
            MiniGameSdk.API.shushu_SetSuperProperties(null, null);
        }

        cc.fx.GameTool.setUserLevel((data) => {
            // console.log("存储结果:",data);
            // console.log("上传",data);
        })
    },

    //改变金币信息
    changeCoin(coin) {
        console.log("changeCoin", coin);
        if (coin == undefined) return;
        if (coin < 0 && cc.fx.GameConfig.GM_INFO.coin < -coin) {
            // console.log("金币不足",cc.fx.GameConfig.GM_INFO.coin,-coin);
            return;
        }
        cc.fx.GameConfig.GM_INFO.coin += coin;
        if (coin > 0) {
            // let data = "获得" + (coin) + "金币";
            // MiniGameSdk.API.showToast(data);
        }
        else {
            let data = "消耗" + (-coin) + "金币";
            MiniGameSdk.API.showToast(data);
        }
        if (cc.fx.GameConfig.GM_INFO.coin < 0) {
            cc.fx.GameConfig.GM_INFO.coin = 0;
        }
        // console.log("改变的金币:",coin);
        // console.log("自身金币信息:",cc.fx.GameConfig.GM_INFO.coin);
        const timestamp = Date.now();
        let coinInfo = {
            coin: cc.fx.GameConfig.GM_INFO.coin,
            timestamp: timestamp,
        }
        MiniGameSdk.API.shushu_SetSuperProperties(null, null);
        cc.fx.StorageMessage.setStorage("coin", coinInfo);
        // console.log("存储金币数据:",cc.fx.GameConfig.GM_INFO.coin,coinInfo);
        cc.fx.GameTool.setUserCoin((data) => {
            // console.log("上传",data);
        })
    },
    //@ts-ignore
    //获取用户金币数量
    getUserCoin(callback: Function) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            //@ts-ignore
            wx.cloud.callFunction({
                name: 'userCoin',
                data: {
                    action: 'read'
                },
                success: res => {
                    // console.log('读取用户金币数据成功', res.result)
                    if (callback)
                        callback(res);

                },
                fail: err => {
                    callback(err);

                }
            })

            //laf云函数
            Utils.getUserCoin((data) => {
            })
        }
    },

    //改变用户金币
    setUserCoin(callback) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            if (cc.fx.GameConfig.GM_INFO.coin <= 0 || cc.fx.GameConfig.GM_INFO.coin == undefined) {
                console.log("金币上传失败", cc.fx.GameConfig.GM_INFO.coin);
                // MiniGameSdk.API.showToast(cc.fx.GameConfig.GM_INFO.coin);
                cc.fx.GameConfig.GM_INFO.coin = 0;
            }
            console.log("即将上传的金币数量:", cc.fx.GameConfig.GM_INFO.coin);
            //@ts-ignore
            wx.cloud.callFunction({
                name: 'userCoin',
                data: {
                    action: 'save',
                    coinAmount: cc.fx.GameConfig.GM_INFO.coin
                },
                success: res => {
                    // console.log('云函数返回结果:', res);
                    if (res.result.code == 200) {
                        // console.log('存储金币数据成功',cc.fx.GameConfig.GM_INFO.coin);
                    }
                    if (callback) {
                        callback(res);
                    }

                },
                fail: err => {
                    // console.log('存储金币数据失败')
                    if (callback) {
                        callback(err);
                    }
                    console.error('存储用户数据失败', err)
                }
            })

            //laf云函数
            Utils.setUserCoin((data) => {
            })
        }
    },


    //获取用户关卡数
    getUserLevel(callback: Function) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            //@ts-ignore
            wx.cloud.callFunction({
                name: 'userLevel',
                data: {
                    action: 'read'
                },
                success: res => {
                    if (callback)
                        callback(res);

                },
                fail: err => {
                    callback(err);

                }
            })

            //laf云函数
            Utils.getUserLevel((data) => {
            })
        }
    },

    //进游戏处理 体力值情况
    getHealth(callback: Function) {
        let health = cc.fx.StorageMessage.getStorage("health");
        const timestamp = Date.now();
        cc.fx.GameConfig.GM_INFO.hp = 5;
        //没有存储过体力值
        if (health == null || health == undefined || health == "") {
            console.log("没存储过体力值，初进");
            cc.fx.GameConfig.GM_INFO.hp = 5;
            cc.fx.GameTool.getUserHealth((data) => {
                console.log("体力接口返回结果", data);
                if (data.result.code == 200) {
                    cc.fx.GameConfig.GM_INFO.hp = data.result.data;
                    cc.fx.GameConfig.GM_INFO.min_Time = data.result.timestamp;
                    let healthInfo = {
                        "health": cc.fx.GameConfig.GM_INFO.hp,
                        "timestamp": data.result.timestamp
                    }
                    MiniGameSdk.API.shushu_SetSuperProperties(null, null);
                    cc.fx.StorageMessage.setStorage("health", healthInfo);
                }
                else if (data.result.code == 404 && data.result.message == "未找到体力数据") {
                    cc.fx.GameTool.setUserHealth(0, () => {
                    });
                }
                if (callback) callback();
            })
            //laf云函数
            Utils.getUserHealth((data) => {
            })
        }
        else {
            console.log("有存储过体力值:", health);
            cc.fx.GameConfig.GM_INFO.hp = health.health;
            if (callback) {
                console.log("体力值读取完毕");
                callback();
            }
            if (health.health < 0) {
                console.log("体力值异常，归零");
                cc.fx.GameConfig.GM_INFO.hp = 0;
                cc.fx.GameTool.setUserHealth(0, () => {
                    if (callback) callback();
                });
            }
            else if (health.health < 5) {
                // 30分钟的毫秒数
                const thirtyMinutes = 30 * 60 * 1000;
                const elapsedTime = timestamp - health.timestamp;
                // 计算恢复的体力值
                const recoveredHealth = Math.min(5 - health.health, Math.floor(elapsedTime / thirtyMinutes));
                if (recoveredHealth > 0) {
                    health.health += recoveredHealth;
                    cc.fx.GameTool.setUserHealth(recoveredHealth, () => {
                        if (callback) callback();
                    });
                    console.log(`体力值恢复 ${recoveredHealth} 点，当前体力值: ${cc.fx.GameConfig.GM_INFO.hp}`);
                } else {
                    // 计算距离下一次恢复的剩余时间
                    const remainingTime = Math.ceil((thirtyMinutes - (elapsedTime % thirtyMinutes)) / 1000);
                    console.log(`体力值未满，待恢复，距离下一次恢复还剩 ${remainingTime} 秒`);
                    cc.fx.GameConfig.GM_INFO.min_Time = remainingTime;
                }
            }
        }
    },

    //获取用户体力值
    getUserHealth(callback: Function) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            console.log("即将进入体力获取接口");
            //@ts-ignore
            wx.cloud.callFunction({
                name: 'userHealth',
                data: {
                    action: 'read'
                },
                success: res => {
                    // console.log("体力获取成功",res);
                    if (callback)
                        callback(res);
                },
                fail: err => {
                    // console.log("体力获取失败",err);
                    callback(err);
                }
            })

            //laf云函数
            Utils.getUserHealth((data) => {
            })
        }
    },

    //设置用户体力值  有可能加，有可能定时器减
    setUserHealth(health, callback) {
        if (health > 0) {
            if (cc.fx.GameConfig.GM_INFO.hp < cc.fx.GameConfig.GM_INFO.hp_max) {
                cc.fx.GameConfig.GM_INFO.hp += health;
            }
        }
        else {
            cc.fx.GameConfig.GM_INFO.hp += health;
        }

        // else MiniGameSdk.API.showToast("体力值恢复");
        const timestamp = Date.now();
        let healthInfo = {
            "health": cc.fx.GameConfig.GM_INFO.hp,
            "timestamp": timestamp
        }

        //如果消耗之前不是满体力，说明已经在恢复期，并不用修改时间
        if (health < 0 && cc.fx.GameConfig.GM_INFO.hp != 4) {
            let oldTime = cc.fx.StorageMessage.getStorage("health").timestamp;
            healthInfo = {
                "health": cc.fx.GameConfig.GM_INFO.hp,
                "timestamp": oldTime
            }
        }
        else {
            healthInfo = {
                "health": cc.fx.GameConfig.GM_INFO.hp,
                "timestamp": timestamp
            }
        }

        cc.fx.StorageMessage.setStorage("health", healthInfo);
        MiniGameSdk.API.shushu_SetSuperProperties(null, null);
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            //@ts-ignore
            wx.cloud.callFunction({
                name: 'userHealth',
                data: {
                    action: 'save',
                    healthAmount: cc.fx.GameConfig.GM_INFO.hp,
                    timestamp: healthInfo.timestamp
                },
                success: res => {
                    if (callback) {
                        callback(res);
                    }

                },
                fail: err => {
                    if (callback) {
                        callback(err);
                    }
                    // console.error('存储关卡数据失败', err)
                }
            })

            //laf云函数
            Utils.setUserHealth(healthInfo.timestamp, (data) => {
            })
        }
    },

    //购买行为
    buyReview(coin, callback: Function) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            // console.log("实际即将消耗金币:",coin);
            // this.changeCoin(coin);
            callback();
        }
    },

    //更改用户道具数
    buyProp(propid, callback: Function) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            let num = 3;
            let cost = 1500;
            if (propid == 2002) {
                cost = 1000;
                num = 1;
            }
            cc.fx.GameTool.changeCoin(-cost);
            const dataTemp = {
                change_reason: "商城购买道具消耗",
                id: (1001 + ""),
                num: -cost
            }
            cc.fx.GameTool.shushu_Track("resource_cost", dataTemp);

            let _id = "";
            let propNumber = 0;
            if (propid == 2001) {
                _id = "freeze_in_game";
                cc.fx.GameConfig.GM_INFO.freezeAmount += num;
                propNumber = cc.fx.GameConfig.GM_INFO.freezeAmount;
            }
            else if (propid == 2002) {
                _id = "hammer_in_game";
                cc.fx.GameConfig.GM_INFO.hammerAmount += num;
                propNumber = cc.fx.GameConfig.GM_INFO.hammerAmount;
            }
            else if (propid == 2003) {
                _id = "wand_in_game";
                cc.fx.GameConfig.GM_INFO.magicAmount += num;
                propNumber = cc.fx.GameConfig.GM_INFO.magicAmount;
            }

            console.log("购买道具:", num);
            cc.fx.GameTool.setUserProp(propid, propNumber, (data) => {
            })



            const data = {
                change_reason: "game",
                id: propid,
                num: num
            }
            cc.fx.GameTool.shushu_Track("resource_get", data);

            const buyData = {
                item_id: _id,
                item_num: num,
                item_price: cost,
                cost_type: "gold"
            }
            console.log("____________即将上传Shop_buy", buyData);
            cc.fx.GameTool.shushu_Track("shop_buy", buyData);

            callback();
        }
    },


    //改变用户关卡
    setUserLevel(callback) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            // if(cc.fx.GameConfig.GM_INFO.level <= 0 || cc.fx.GameConfig.GM_INFO.level == undefined){
            //     console.log("等级重置为0");
            //     cc.fx.GameConfig.GM_INFO.level = 0;
            // }
            // console.log("即将上传的关卡数:",cc.fx.GameConfig.GM_INFO.level);
            //@ts-ignore
            wx.cloud.callFunction({
                name: 'userLevel',
                data: {
                    action: 'save',
                    levelAmount: cc.fx.GameConfig.GM_INFO.level
                },
                success: res => {
                    // console.log('云函数返回结果:', res);
                    // console.log('存储关卡数据成功',cc.fx.GameConfig.GM_INFO.level);
                    if (callback) {
                        callback(res);
                    }

                },
                fail: err => {
                    // console.log('存储关卡数据失败')
                    return;
                    if (callback) {
                        callback(err);
                    }
                    console.error('存储关卡数据失败', err)
                }
            })

            //laf云函数
            Utils.setUserLevel((data) => {
            })
        }
    },

    //获取用户关卡数
    getUserProp(callback: Function) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            //@ts-ignore
            wx.cloud.callFunction({
                name: 'userProp',
                data: {
                    action: 'read'
                },
                success: res => {
                    // console.log('读取用户道具数据成功', res.result)
                    if (res.result.data) {
                        // cc.fx.GameConfig.GM_INFO.freezeAmount = res.result.data.freeze;
                        // cc.fx.GameConfig.GM_INFO.hammerAmount = res.result.data.hammer;
                        // cc.fx.GameConfig.GM_INFO.magicAmount = res.result.data.magic_wand;
                    }
                    if (callback)
                        callback(res);

                },
                fail: err => {
                    callback(err);
                }
            })


            //laf云函数
            Utils.getUserProp((data) => {
            })
        }
    },

    //改变用户道具
    setUserProp(propid, amount, callback) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            let newPropData = null;
            if (propid == 0) {
                newPropData = {
                    freeze: cc.fx.GameConfig.GM_INFO.freezeAmount,
                    hammer: cc.fx.GameConfig.GM_INFO.hammerAmount,
                    magic_wand: cc.fx.GameConfig.GM_INFO.magicAmount,
                }
            }
            else if (propid == 2001) {
                newPropData = amount;
            }
            else if (propid == 2002) {
                newPropData = amount;
            }
            else if (propid == 2003) {
                newPropData = amount;
            }

            //@ts-ignore
            wx.cloud.callFunction({
                name: 'userProp',
                data: {
                    action: 'save',
                    propType: propid,
                    propData: newPropData
                },
                success: res => {
                    // console.log('云函数返回结果:', res);
                    if (callback) {
                        callback(res);
                    }
                    // console.log('存储道具数据成功')
                },
                fail: err => {
                    // console.log('存储道具数据失败')
                    if (callback) {
                        callback(err);
                    }
                    console.error('存储道具数据失败', err)
                }
            })

            Utils.setUserProp(propid, newPropData, (data) => {
            })
        }
    },

    // 检查是否有足够的硬币
    consumeCoins(requiredCoins: number, propName: string, amount: number, callback) {


    },

    // 设置用户信息
    setUserInfo(callback: Function) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            const time = cc.fx.GameTool.formatDate(new Date());
            let userInfo = {
                // 这里填写要存储的用户数据
                username: cc.fx.GameConfig.GM_INFO.username,   //用户名称
                useravatar: cc.fx.GameConfig.GM_INFO.useravatar,     //用户头像
                register_time: time
            }

            //@ts-ignore
            wx.cloud.callFunction({
                name: 'userData',
                data: {
                    action: 'save',
                    userData: userInfo
                },
                success: res => {
                    // console.log('存储用户数据成功')
                    if (callback) {
                        callback(res);
                    }

                },
                fail: err => {
                    if (callback) {
                        callback("fail");
                    }
                }
            })

            Utils.setUserData(userInfo, (data) => {
            })
        }
    },

    //商城购买
    shopBuy(productId) {
        let coin = 0;
        let price = 0;
        let getCoin = 0;

        var rewardData = null;

        switch (productId) {
            case "gold_1":
                cc.fx.GameTool.changeCoin(1200);
                coin = 1200;
                price = 600;
                // MiniGameSdk.API.showToast("充值成功，获得1200金币");
                rewardData = [
                    { type: "coin", count: coin },
                ]
                break;
            case "gold_2":
                cc.fx.GameTool.changeCoin(8000);
                coin = 8000;
                price = 3600;
                // MiniGameSdk.API.showToast("充值成功，获得8000金币");
                rewardData = [
                    { type: "coin", count: coin },
                ]
                break;
            case "gold_3":
                cc.fx.GameTool.changeCoin(16000);
                coin = 16000;
                price = 6800;
                // MiniGameSdk.API.showToast("充值成功，获得16000金币");
                this.rewardData = [
                    { type: "coin", count: coin },
                ]
                break;
            case "gold_4":
                cc.fx.GameTool.changeCoin(32000);
                coin = 32000;
                price = 12800;
                // MiniGameSdk.API.showToast("充值成功，获得32000金币");
                rewardData = [
                    { type: "coin", count: coin },
                ]
                break;
            case "gold_5":
                cc.fx.GameTool.changeCoin(100000);
                coin = 100000;
                price = 32800;
                // MiniGameSdk.API.showToast("充值成功，获得100000金币");
                rewardData = [
                    { type: "coin", count: coin },
                ]
                break;
            case "gold_6":
                cc.fx.GameTool.changeCoin(240000);
                coin = 240000;
                price = 64800;
                // MiniGameSdk.API.showToast("充值成功，获得240000金币");
                rewardData = [
                    { type: "coin", count: coin },
                ]
                break;
            case "unlimited_health_bundle_1":
                cc.fx.GameTool.changeCoin(5000);
                coin = 5000;
                price = 1800;
                this.setUserPowerTime(1800);
                // MiniGameSdk.API.showToast("获得无限体力小组合包");
                rewardData = [
                    { type: "coin", count: coin },
                    { type: "infinite_health", count: 1800 },
                ]
                break;
            case "unlimited_health_bundle_2":
                cc.fx.GameTool.changeCoin(12000);
                coin = 12000;
                price = 6600;
                let propData = {
                    "freeze": 2,
                    "hammer": 2,
                    "magic_wand": 2,
                    "price": price
                }
                this.getShopProp(propData, null);
                this.setUserPowerTime(3600);
                // MiniGameSdk.API.showToast("获得无限体力大组合包");
                rewardData = [
                    { type: "coin", count: coin },
                    { type: "freeze", count: 2 },
                    { type: "hammer", count: 2 },
                    { type: "magic", count: 2 },
                    { type: "infinite_health", count: 3600 },
                ]
                break;
            case "unlimited_health_bundle_3":
                cc.fx.GameTool.changeCoin(30000);
                coin = 30000;
                price = 10800;
                let propData2 = {
                    "freeze": 6,
                    "hammer": 6,
                    "magic_wand": 6,
                    "price": price
                }
                this.getShopProp(propData2, null);
                this.setUserPowerTime(7200);
                // MiniGameSdk.API.showToast("获得无限体力超组合包");
                rewardData = [
                    { type: "coin", count: coin },
                    { type: "freeze", count: 6 },
                    { type: "hammer", count: 6 },
                    { type: "magic", count: 6 },
                    { type: "infinite_health", count: 7200 },
                ]
                break;
        }


        if (MapConroler._instance != null)
            MapConroler._instance.SceneManager.openRewardWindow(rewardData);
        else {
            const canvasTemp = cc.find("Canvas"); // 假设 Canvas 节点
            if (canvasTemp) {
                const JiaZai = canvasTemp.getComponent("JiaZai");
                if (JiaZai) {
                    JiaZai.openRewardWindow(rewardData);
                }
            }
        }


        const dataTemp = {
            change_reason: "shop",
            id: "1001",
            num: coin
        }
        cc.fx.GameTool.shushu_Track("resource_get", dataTemp);

        const buyData = {
            item_id: productId,
            item_num: coin,
            item_price: price,
            cost_type: "cash"
        }
        cc.fx.GameTool.shushu_Track("shop_buy", buyData);
        MiniGameSdk.API.shushu_SetSuperProperties(null, true);
    },

    formatDate(date: Date): string {
        const year = date.getFullYear();
        const month = String(date.getMonth() + 1).padStart(2, '0');
        const day = String(date.getDate()).padStart(2, '0');
        const hours = String(date.getHours()).padStart(2, '0');
        const minutes = String(date.getMinutes()).padStart(2, '0');
        const seconds = String(date.getSeconds()).padStart(2, '0');
        const milliseconds = String(date.getMilliseconds()).padStart(3, '0');

        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`;
    },

    //获取时间戳
    getTime() {
        const timestamp = (new Date().getTime())
        return timestamp;
    },
    pushLister: function () {

    },
    removeAllLister: function () {

    },
    //上报数据
    shushu_Track: function (name, data) {
        let eventData = {}
        switch (name) {
            case "login":
                eventData = {
                    register_time: data.register_time,
                }
                break;
            case "register":
                eventData = {
                    register_time: data.register_time,
                }
                break;
            case "enter_stage":
                eventData = {
                    stage_id: (cc.fx.GameConfig.GM_INFO.level + 1)
                }
                break;
            case "finish_stage":
                eventData = {
                    stage_id: (cc.fx.GameConfig.GM_INFO.level + 1),
                    stage_duration: data.time,
                    added_time: data.add_Time,
                    result: data.result
                }
                break;
            case "resource_get":
                eventData = {
                    change_reason: data.change_reason,   //获得来源
                    change_num: data.num,       //获得数量
                    resource_id: data.id        //道具id
                }
                break;
            case "resource_cost":
                eventData = {
                    change_reason: data.change_reason,   //获得来源
                    change_num: data.num,       //获得数量
                    resource_id: data.id        //道具id
                }
                break;
            case "shop_buy":
                eventData = {
                    item_id: data.item_id,
                    item_num: data.item_num,
                    item_price: data.item_price,
                    cost_type: data.cost_type,
                }
                break;
            case "init_order":                  //发起充值时
                eventData = {
                    order_id: data.outTradeNo,
                    pay_amount: data.price,
                    payment_name: data.payment_name,
                    payment_num: data.payment_num,
                    payment_type: data.type,
                }
                break;
            case "payment":                  //发起充值时
                eventData = {
                    order_id: data.outTradeNo,
                    pay_amount: data.price,
                    payment_name: data.payment_name,
                    payment_num: data.payment_num,
                    payment_type: data.type,
                }
                break;
            case "payment_fail":                  //发起充值时
                eventData = {
                    order_id: data.outTradeNo,
                    pay_amount: data.price,
                    payment_name: data.payment_name,
                    payment_num: data.payment_num,
                    payment_type: data.type,
                    fail_reason: data.fail_reason,
                }
                break;
        }
        if (name == "finish_stage") {
            console.log("准备上报完成");
            console.log(eventData);
            // MiniGameSdk.API.showToast("准备上报完成游戏");
        }
        // MiniGameSdk.API.shushu_Track(name,eventData);
        MiniGameSdk.API.shushu_Track(name, eventData);
    },

    //获取微信小游戏版本号
    getWechatGameVersion: function () {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            //@ts-ignore
            const accountInfo = wx.getAccountInfoSync();
            const miniProgram = accountInfo.miniProgram;
            switch (miniProgram.envVersion) {
                case 'develop':
                    return '开发版';
                case 'trial':
                    return '体验版';
                case 'release':
                    return '正式版';
                default:
                    return '未知版本';
            }
        }
    },

    //微信小游戏根据openId将用户分组，有可能会两分，三分，六分
    setWechatGameGroup: function (type: 2 | 3 | 6) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            //@ts-ignore
            if (cc.fx.GameConfig.GM_INFO.openid) {
                const openid = cc.fx.GameConfig.GM_INFO.openid;
                const lastChar = openid[openid.length - 1];
                const charCode = lastChar.charCodeAt(0);
                let groupNumber: number;
                console.log("openid尾数____________________:", charCode);

                // 根据 type 参数计算分组编号
                switch (type) {
                    case 2:
                        groupNumber = charCode % 2;
                        break;
                    case 3:
                        groupNumber = charCode % 3;
                        break;
                    case 6:
                        groupNumber = charCode % 6;
                        break;
                    default:
                        console.log('type 参数值无效，必须为 2、3 或 6');
                        return;
                }
                console.log("type____________________:", type);
                console.log("分组编号____________________:", groupNumber);
                return groupNumber;
            }
        }
        else return 1;
    },


    //购买行为，获得道具
    getShopProp(propData, callback: Function) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            const num = propData.freeze;
            console.log("_________道具增加的数量为:", num);
            cc.fx.GameConfig.GM_INFO.freezeAmount += propData.freeze;
            cc.fx.GameConfig.GM_INFO.hammerAmount += propData.hammer;
            cc.fx.GameConfig.GM_INFO.magicAmount += propData.magic_wand;
            cc.fx.GameTool.setUserProp(0, num, (data) => {
            })
            const data1 = {
                change_reason: "shop",
                id: 2001,
                num: propData.freeze
            }
            cc.fx.GameTool.shushu_Track("resource_get", data1);
            const data2 = {
                change_reason: "shop",
                id: 2002,
                num: propData.hammer
            }
            cc.fx.GameTool.shushu_Track("resource_get", data2);
            const data3 = {
                change_reason: "shop",
                id: 2003,
                num: propData.magic_wand
            }
            cc.fx.GameTool.shushu_Track("resource_get", data3);
            const buyData1 = {
                item_id: "freeze_in_game",
                item_num: propData.freeze,
                item_price: propData.price,
                cost_type: "cash"
            }

            cc.fx.GameTool.shushu_Track("shop_buy", buyData1);
            const buyData2 = {
                item_id: "hammer_in_game",
                item_num: propData.hammer,
                item_price: propData.price,
                cost_type: "cash"
            }

            cc.fx.GameTool.shushu_Track("shop_buy", buyData2);
            const buyData3 = {
                item_id: "wand_in_game",
                item_num: propData.magic_wand,
                item_price: propData.price,
                cost_type: "cash"
            }

            cc.fx.GameTool.shushu_Track("shop_buy", buyData3);

            if (callback) {
                callback();
            }
        }
    },


    //购买无限体力
    setUserPowerTime(time) {
        //@ts-ignore
        if (typeof wx !== 'undefined' && wx !== null) {
            let nowTime = Math.floor(Date.now() / 1000);
            let powerTime = cc.fx.StorageMessage.getStorage("userPowerTime");
            if (powerTime == "undifend" || powerTime == null || powerTime == "" || powerTime == 0) {
                powerTime = Math.floor(Date.now() / 1000) + time;
            } else {
                if (nowTime >= powerTime) {
                    powerTime = nowTime + time;
                }
                else {
                    powerTime = powerTime + time;
                }
            }
            cc.fx.GameConfig.GM_INFO.userPowerTime = powerTime;
            cc.fx.StorageMessage.setStorage("userPowerTime", powerTime);
            Utils.setUserPowerTime(powerTime, (data) => {
                console.log("购买无限体力同步:", data);
            })
        }
    },

    getUserPowerTime() {
        if (cc.fx.GameConfig.GM_INFO.userPowerTime > 0) {
            let nowTime = Math.floor(Date.now() / 1000);
            if (nowTime >= cc.fx.GameConfig.GM_INFO.userPowerTime) {
                cc.fx.GameConfig.GM_INFO.userPowerTime = 0;
                cc.fx.StorageMessage.setStorage("userPowerTime", 0);
                Utils.setUserPowerTime(0, (data) => {
                    console.log("购买无限体力同步:", data);
                })
                return false;
            } else {
                return true;
            }
        }
        else {
            return false;
        }
    }

};
export { GameTool };