using asap.core;
using cfg;
using game;
using GameCore;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using UnityEngine;

public class AquariumManager
{
    public const string AquariumEventDataNewKey = "AquariumEventDataNewKey";
    private cfg.Tables _tables;
    public AquariumManagerData data { get; private set; }
    public int MapId => data.mapId;
    public int Slot => data.slot;
    public List<string> eggNames;
    public List<AquariumSlotData> sellList;
    public AquariumManager()
    {
        _tables = GContext.container.Resolve<Tables>();
        // [REMOVED] CustomServerMgr deleted
    }
    public static AquariumManagerData GetAquariumManagerData()
    {
        string dataStr = PlayFabMgr.Instance.GetLocalData(AquariumEventDataNewKey);
        if (!string.IsNullOrEmpty(dataStr))
        {
            try
            {
                return AquariumManagerData.Deserialize(dataStr);
            }
            catch (Exception e)
            {
                Debug.LogError($"GetAquariumManagerData Deserialize Error:{e}");
            }
        }
        return null;
    }
    public async Task Synchrodata()
    {
        //从服务器拿数据
        var dataSever = GetAquariumManagerData();
        if (dataSever == null)
        {
            //新数据
            data = new AquariumManagerData();
            data.startTime = ZZTimeHelper.UtcNow().AddDays(-2);
            data.refreshCount = 0;
            data.adCount = 0;
            data.refreshDay = ZZTimeHelper.UtcNow().UtcNowOffset().Date.DayOfYear;

            data.slot = GContext.container.Resolve<PlayerData>().benefitsAquariumLimit;
        }
        else
        {
            data = dataSever;
            if (data.slotDatas == null || data.slotDatas.Count < data.slot)
            {
                return;
            }
            GetAquariumDataRequest request = new GetAquariumDataRequest();
            request.playFabId = GContext.container.Resolve<IUserService>().UserId;
            // [REMOVED] CustomServerMgr deleted
            return;
        }
    }
    void SetJury()
    {
        var dateTime = ZZTimeHelper.UtcNow();
        AquariumFish aquariumFish = null;
        for (int i = 0; i < data.slot; i++)
        {
            AquariumSlotData slotData = data.slotDatas[i];
            slotData.index = i;
            AquariumHurtData aquariumHurtData = data.aquariumHurtDatas[i];
            //没有受新伤
            if (aquariumHurtData.injuryTime < slotData.allRecoveryTime + 0.0001f)
            {
                continue;
            }

            var HatchTime = slotData.FishHatchTime();
            //还没孵化
            if (HatchTime > dateTime)
            {
                continue;
            }
            //检查是否受伤
            //正常的成长时间 自然时间+加速成长-总恢复时间
            float normalH = (float)(dateTime - HatchTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
            //受伤时的成长时间 受伤时的时间+加速成长-受伤时的总恢复时间
            float injuryH = slotData.injuryGrowthTime;

            aquariumFish = _tables.TbAquariumFish.GetOrDefault(slotData.aquariumFishID);
            //受伤时的成长进度大于正常的成长进度=还没恢复
            if (injuryH > normalH)
            {
                var recoveryTime = UnityEngine.Random.Range(aquariumFish.RecoveryTime[0], aquariumFish.RecoveryTime[1]);
                slotData.recoveryTime = recoveryTime;
                recoveryTime -= injuryH - normalH;
                //处于受伤状态刷新时间
                if (recoveryTime > 0)
                {
                    slotData.allRecoveryTime += recoveryTime;
                }
            }
            else
            {
                //不处于受伤状态添加受伤时间
                //当前正常的成长进度 自然时间+加速成长 - 全部恢复时间
                //受伤时的成长时间 受伤时的时间+加速成长-受伤时的总恢复时间

                slotData.injuryGrowthTime = (float)(dateTime - HatchTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
                slotData.recoveryTime = UnityEngine.Random.Range(aquariumFish.RecoveryTime[0], aquariumFish.RecoveryTime[1]);
                slotData.allRecoveryTime += slotData.recoveryTime;
            }

        }
    }
    public void GetRandmMap()
    {
        PlayerData playerData = GContext.container.Resolve<PlayerData>();
        PlayerFishData playerFishData = GContext.container.Resolve<PlayerFishData>();

        data.startTime = ZZTimeHelper.UtcNow();
        data.slot = playerData.benefitsAquariumLimit;
        List<AquariumInit> inits = _tables.TbAquariumInit.DataList;
        if (data.startCount < inits.Count)
        {
            NewSlotInitData(inits[data.startCount]);
        }
        else
        {
            NewSlotData();
        }
        data.refreshCount++;
        data.isHome = false;
        data.startCount++;
        //保存 数据
        SaveData(true);
        GContext.container.Resolve<TriggerPackData>().RefreshTriggerPackData(4000201, data.mapId);

#if AGG
        int fishcard_totallevel = playerFishData.GetFishLevelByMap(data.mapId);
        string egg_quality_list = data.slotDatas[0].eggId.ToString();
        for (int i = 1; i < data.slotDatas.Count; i++)
        {
            egg_quality_list = $"{egg_quality_list},{data.slotDatas[i].eggId}";
        }
        using (var e = GEvent.GameEvent("aquarium_start"))
        {
            e.AddContent("map_id", data.mapId)
            .AddContent("total_eggpots", data.slot)
            .AddContent("fishcard_totallevel", fishcard_totallevel)
            .AddContent("egg_quality_list", egg_quality_list);
        }
#endif
    }
    void NewSlotInitData(AquariumInit init)
    {
        data.mapId = init.MapID;
        List<AquariumSlotData> slotDatas = new List<AquariumSlotData>();
        List<AquariumHurtData> aquariumHurtDatas = new List<AquariumHurtData>();
        List<AquariumResultData> aquariumResultDatas = new List<AquariumResultData>();
        DateTime dateTime = ZZTimeHelper.UtcNow();

        List<AquariumEgg> TankEggList = _tables.TbAquariumEgg.DataList;
        eggNames = new List<string>();
        for (int i = 0; i < TankEggList.Count; i++)
        {
            eggNames.Add(TankEggList[i].Icon);
        }

        List<int> Egglist = init.Egglist;
        List<int> FishQualitylist = init.FishQualitylist;
        List<int> FishList = init.Fishlist;
        List<int> FishQuatitylist = init.FishQuatitylist;
        List<int> FishMutantlist = init.FishMutantlist;


        for (int i = 0; i < data.slot; i++)
        {
            AquariumSlotData aquariumSlotData = new AquariumSlotData();
            aquariumSlotData.eggId = Egglist[i];
            aquariumSlotData.aquariumFishID = FishQualitylist[i];
            aquariumSlotData.fishMQ = FishQuatitylist[i];
            aquariumSlotData.fishItemID = FishList[i];

            var tankEgg = _tables.TbAquariumEgg.GetOrDefault(Egglist[i]);

            aquariumSlotData.startTime = dateTime;
            aquariumSlotData.hatchTime = UnityEngine.Random.Range(tankEgg.HatchTime[0], tankEgg.HatchTime[1]);

            AquariumFish aquariumFish = _tables.TbAquariumFish.GetOrDefault(FishQualitylist[i]);

            float allCash = SetRewardCount(aquariumFish.SoldReward);
            float soldRewardRand = UnityEngine.Random.Range(0, aquariumFish.SoldRewardRand) - aquariumFish.SoldRewardRand * 0.5f;
            aquariumSlotData.allCash = allCash * (1 + soldRewardRand);

            aquariumSlotData.growthTime = UnityEngine.Random.Range(aquariumFish.GrowthTime[0], aquariumFish.GrowthTime[1]);
            aquariumSlotData.mutants = FishMutantlist[i];
            aquariumSlotData.index = i;
            slotDatas.Add(aquariumSlotData);

            AquariumHurtData aquariumHurtData = new AquariumHurtData();
            aquariumHurtDatas.Add(aquariumHurtData);

            AquariumResultData aquariumResultData = new AquariumResultData();
            aquariumResultDatas.Add(aquariumResultData);
        }
        data.slotDatas = slotDatas;
        data.aquariumHurtDatas = aquariumHurtDatas;
        data.aquariumResultDatas = aquariumResultDatas;
    }

    void SetAquariumFish(MapData mapData, AquariumSlotData aquariumSlotData, AquariumEgg tankEgg)
    {
        List<FishItemList> fishList = mapData.DropFishList;

        //权重取鱼
        int allProb = tankEgg.HatchFishQualityProb.Sum();
        int prob = UnityEngine.Random.Range(0, allProb);
        int curProb = 0;
        int fishQuality = tankEgg.HatchFishQuality[^1];
        for (int k = 0; k < tankEgg.HatchFishQuality.Count; k++)
        {
            curProb += tankEgg.HatchFishQualityProb[k];
            if (curProb > prob)
            {
                fishQuality = tankEgg.HatchFishQuality[k];
                break;
            }
        }
        //品质大于6？？？
        if (6 > fishQuality)
        {
            List<int> FishIDList = fishList[fishQuality - 1].FishIDList;
            aquariumSlotData.fishItemID = FishIDList[UnityEngine.Random.Range(0, FishIDList.Count)];
        }
        else
        {
            List<int> FishIDList = _tables.TbAquariumConfig.AquariumSpFishList;
            aquariumSlotData.fishItemID = FishIDList[UnityEngine.Random.Range(0, FishIDList.Count)];
        }
        aquariumSlotData.aquariumFishID = fishQuality;
        //取鱼的数量
        allProb = tankEgg.HatchFishQuantityProb.Sum();
        prob = UnityEngine.Random.Range(0, allProb);
        curProb = 0;
        int fishCount = tankEgg.HatchFishQuantity[0];
        for (int k = 0; k < tankEgg.HatchFishQuantity.Count; k++)
        {
            curProb += tankEgg.HatchFishQuantityProb[k];
            if (curProb > prob)
            {
                fishCount = tankEgg.HatchFishQuantity[k];
                break;
            }
        }
        aquariumSlotData.fishMQ = fishCount;
    }

    void SetTime(AquariumSlotData aquariumSlotData, AquariumEgg tankEgg)
    {
        aquariumSlotData.hatchTime = UnityEngine.Random.Range(tankEgg.HatchTime[0], tankEgg.HatchTime[1]);

        AquariumFish aquariumFish = _tables.TbAquariumFish.GetOrDefault(aquariumSlotData.aquariumFishID);

        float allCash = SetRewardCount(aquariumFish.SoldReward);
        float soldRewardRand = UnityEngine.Random.Range(0, aquariumFish.SoldRewardRand) - aquariumFish.SoldRewardRand * 0.5f;
        aquariumSlotData.allCash = allCash * (1 + soldRewardRand);

        aquariumSlotData.growthTime = UnityEngine.Random.Range(aquariumFish.GrowthTime[0], aquariumFish.GrowthTime[1]);
        aquariumSlotData.mutants = 0;
        for (int j = 0; j < aquariumSlotData.fishMQ; j++)
        {
            if (UnityEngine.Random.Range(0, 1f) < aquariumFish.MutantProb)
            {
                aquariumSlotData.mutants++;
            }
        }
    }
    void NewSlotData()
    {
        int curMapId = MapId;

        var mapDatas = _tables.TbMapData.DataList;
        var maxMapID = GContext.container.Resolve<PlayerData>().lastMapId;

        //非当前地图
        var mapIDs = new List<int>();
        for (int i = 0; i < mapDatas.Count; i++)
        {
            if (mapDatas[i].ID <= maxMapID)
            {
                if (mapDatas[i].ID != curMapId)
                {
                    mapIDs.Add(mapDatas[i].ID);
                }
            }
            else
            {
                break;
            }
        }
        if (mapIDs.Count == 0)
        {
            data.mapId = maxMapID;
        }
        else
        {
            data.mapId = mapIDs[UnityEngine.Random.Range(0, mapIDs.Count)];
        }

        List<AquariumSlotData> slotDatas = new List<AquariumSlotData>();
        List<AquariumHurtData> aquariumHurtDatas = new List<AquariumHurtData>();
        List<AquariumResultData> aquariumResultDatas = new List<AquariumResultData>();

        DateTime dateTime = ZZTimeHelper.UtcNow();
        MapData mapData = _tables.TbMapData.GetOrDefault(data.mapId);
        List<AquariumEgg> TankEggList = _tables.TbAquariumEgg.DataList;
        float eggAllWeight = -0.0001f;
        eggNames = new List<string>();
        for (int i = 0; i < TankEggList.Count; i++)
        {
            eggNames.Add(TankEggList[i].Icon);
            eggAllWeight += TankEggList[i].Weight;
        }
        for (int i = 0; i < data.slot; i++)
        {
            AquariumSlotData aquariumSlotData = new AquariumSlotData();
            //权重取蛋
            float eggWeight = UnityEngine.Random.Range(0, eggAllWeight);
            float curEggWeight = 0;
            AquariumEgg tankEgg = TankEggList[0];
            foreach (var item in TankEggList)
            {
                curEggWeight += item.Weight;
                if (curEggWeight > eggWeight)
                {
                    tankEgg = item;
                    break;
                }
            }
            aquariumSlotData.eggId = tankEgg.ID;
            SetAquariumFish(mapData, aquariumSlotData, tankEgg);
            aquariumSlotData.startTime = dateTime;
            SetTime(aquariumSlotData, tankEgg);
            aquariumSlotData.index = i;
            slotDatas.Add(aquariumSlotData);

            AquariumHurtData aquariumHurtData = new AquariumHurtData();
            aquariumHurtDatas.Add(aquariumHurtData);

            AquariumResultData aquariumResultData = new AquariumResultData();
            aquariumResultDatas.Add(aquariumResultData);
        }
        data.slotDatas = slotDatas;
        data.aquariumHurtDatas = aquariumHurtDatas;
        data.aquariumResultDatas = aquariumResultDatas;
    }

    public void Speedup(bool isGuide)
    {
        var dateTime = ZZTimeHelper.UtcNow();
        float AdAccelerate = _tables.TbAquariumConfig.AdAccelerate;
        if (isGuide)
        {
            AdAccelerate = _tables.TbAquariumConfig.AdAccelerateFirst;
        }
        List<AquariumSlotData> slotDataList = data.slotDatas;
        List<AquariumResultData> aquariumReportDatas = data.aquariumResultDatas;
        for (int i = 0; i < slotDataList.Count; i++)
        {
            var slotData = slotDataList[i];

            //售卖或者丢失
            if (slotData.IsResult() || aquariumReportDatas[slotData.index].IsResult())
            { continue; }
            var HatchTime = slotData.FishHatchTime();
            if (HatchTime <= dateTime)
            {
                //鱼加速
                slotData.accelerationGrowth += AdAccelerate;
            }
            else
            {
                float s = (float)(HatchTime - dateTime).TotalHours;
                if (s <= 0)
                {
                    slotData.accelerationGrowth += AdAccelerate;
                }
                else if (AdAccelerate > s)
                {
                    slotData.accelerationHatch += s;
                    slotData.accelerationGrowth += AdAccelerate - s;
                }
                else
                {
                    slotData.accelerationHatch += AdAccelerate;
                }
            }
        }
        data.adCount++;
        SaveData();
    }

    public void SellFish(List<AquariumSlotData> slotDataList)
    {
        sellList = new List<AquariumSlotData>();
        var dateTime = ZZTimeHelper.UtcNow();
        PlayerData playerData = GContext.container.Resolve<PlayerData>();
        var weight = GetWeightMag();
        AquariumFish aquariumFish;
        FishData fishData;
        DateTime startTime;
        float injuryH;
        float weightIncEvent;
        List<ItemData> itemDatas = new List<ItemData>();
        PlayerFishData playerFishData = GContext.container.Resolve<PlayerFishData>();
        float CashMag = (1 + playerData.benefitsCashMag) * (1 + playerData.benefitsAquariumCashMag);
        for (int i = 0; i < slotDataList.Count; i++)
        {
            var slotData = slotDataList[i];
            sellList.Add(slotData);
            if (slotData.allCash == 0)
            {
                slotData.allCash = 1;
            }
            //奖励
            aquariumFish = _tables.TbAquariumFish.GetOrDefault(slotData.aquariumFishID);
            startTime = slotData.FishHatchTime();
            injuryH = slotData.injuryGrowthTime;
            weightIncEvent = (1 + weight[slotData.aquariumFishID - 1]) * CashMag;

            float normalH = (float)(dateTime - startTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;

            float rewardProgress = normalH / slotData.growthTime;

            if (injuryH > normalH && injuryH > slotData.growthTime)
            {
                rewardProgress = 1 - ((injuryH - normalH) / slotData.growthTime);
            }

            if (rewardProgress > 1)
            {
                rewardProgress = 1;
            }

            //金币显示
            ItemData itemData = new ItemData();

            int fishQ = slotData.fishMQ;
            bool is_injured = false;
            if (injuryH > normalH)
            {
                fishQ -= data.aquariumHurtDatas[slotData.index].fishLQ;
                is_injured = true;
                if (fishQ <= 0)
                {
                    fishQ = 1;
                }
            }
            if (rewardProgress < 0)
            {
                rewardProgress = 0;
            }
            for (int j = 0; j < fishQ; j++)
            {
                if (j < slotData.mutants)
                {
                    itemData.count += (int)(slotData.allCash * (1 + aquariumFish.MutantGrowthExtraSoldReward * rewardProgress) * (1 + aquariumFish.MutantExtraSoldReward) * weightIncEvent);
                }
                else
                {
                    itemData.count += (int)(slotData.allCash * (1 + aquariumFish.GrowthExtraSoldReward * rewardProgress) * weightIncEvent);
                }
            }
            itemData.id = 1002;

            itemDatas.Add(itemData);
            slotData.cash = itemData.count;

            //重量
            Item item = _tables.TbItem.GetOrDefault(slotData.fishItemID);
            fishData = _tables.TbFishData.GetOrDefault(item.RedirectID);
            //float weightCount = fishData.BaseWeight * (1 + aquariumFish.GrowthExtraSoldReward * rewardProgress) * weightIncEvent;
            //playerFishData.SetWeight(fishData.ID, weightCount, false);
#if AGG
            int cardLevel = playerFishData.GetDataLevel(fishData.ID);
            using (var e = GEvent.GameEvent("aquarium_sell"))
            {
                e.AddContent("map_id", data.mapId)
                    .AddContent("total_eggpots", data.slot)
                    .AddContent("fish_eggs_quality", slotData.eggId)
                    .AddContent("mature_percent", rewardProgress)
                    .AddContent("fish_id", fishData.ID)
                    .AddContent("fishcard_level", cardLevel)
                    .AddContent("fish_quality", slotData.aquariumFishID)
                    .AddContent("mutant_count", slotData.mutants)
                    .AddContent("is_injured", is_injured)
                    .AddContent("fish_count", slotData.fishMQ)
                    .AddContent("is_dead", false)
                    .AddContent("reward_cash", slotData.cash);
            }
#endif
        }
        //GContext.Publish(new ShowData(itemDatas));
        GContext.container.Resolve<PlayerItemData>().AddItem(itemDatas, null);
        //GContext.Publish(new ShowData());
        CheckInHome();
        SaveData();
    }

    public float SetRewardCount(int dropID)
    {
        DropPackageList dropPackageList = _tables.TbDrop[dropID].DropList;
        return dropPackageList.DropCountList[0];
    }

    public void CheckInHome()
    {
        data.isHome = true;
        List<AquariumResultData> aquariumResultDatas = data.aquariumResultDatas;
        var slotDatas = data.slotDatas;
        for (int i = 0; i < data.slot; i++)
        {
            if (!slotDatas[i].IsResult() && !aquariumResultDatas[i].IsResult())
            {
                data.isHome = false;
            }
        }
        if (data.isHome)
        {
#if AGG
            PlayerFishData playerFishData = GContext.container.Resolve<PlayerFishData>();
            for (int i = 0; i < data.slot; i++)
            {
                if (!slotDatas[i].IsResult() && aquariumResultDatas[i].IsResult())
                {
                    var fishItem = _tables.TbItem.GetOrDefault(slotDatas[i].fishItemID);
                    int cardLevel = playerFishData.GetDataLevel(fishItem.RedirectID);
                    using (var e = GEvent.GameEvent("aquarium_sell"))
                    {
                        e.AddContent("map_id", data.mapId)
                        .AddContent("total_eggpots", data.slot)
                            .AddContent("fish_eggs_quality", slotDatas[i].eggId)
                            .AddContent("mature_percent", 0)
                            .AddContent("fish_id", fishItem.RedirectID)
                            .AddContent("fishcard_level", cardLevel)
                            .AddContent("fish_quality", slotDatas[i].aquariumFishID)
                            .AddContent("mutant_count", slotDatas[i].mutants)
                            .AddContent("is_injured", true)
                            .AddContent("is_dead", true)
                            .AddContent("fish_count", 0)
                            .AddContent("reward_cash", 0);
                    }
                }
            }
#endif
            UpdateUserData();
            //_ = UIManager.Instance.ShowUI(UITypes.AquariumReportPopupPanel);
        }
    }
    void UpdateUserData()
    {
        PlayFabMgr.Instance.UpdateUserDataValue(AquariumEventDataNewKey, data.Serialize());
    }
    void SaveData(bool all = false)
    {
        List<AquariumSlotData> slotDatas = data.slotDatas;
        //鱼卡等级
        PlayerFishData playerFishData = GContext.container.Resolve<PlayerFishData>();
        List<int> cardLv = new List<int>();
        for (int i = 0; i < slotDatas.Count; i++)
        {
            var fishItem = _tables.TbItem.GetOrDefault(slotDatas[i].fishItemID);
            if (fishItem.Quality < 6)
            {
                int level = playerFishData.GetDataLevel(fishItem.RedirectID);
                cardLv.Add(level);
            }
            else
            {
                int level = GContext.container.Resolve<PlayerData>().benefitsLevel[4];
                cardLv.Add(level);
            }
        }

        if (all)
        {
            UpdateAquariumAllDataRequest request = new UpdateAquariumAllDataRequest();
            request.playFabId = GContext.container.Resolve<IUserService>().UserId;
            request.data = new AquariumServerData()
            {
                startTime = data.startTime,
                mapId = data.mapId,
                slot = data.slot,
                slotDatas = data.slotDatas,
                cardLv = string.Join(',', cardLv),
                aquariumResultDatas = data.aquariumResultDatas,
                aquariumHurtDatas = data.aquariumHurtDatas,
            };
            // [REMOVED] CustomServerMgr deleted
            // customServerMgr?.CustomServerPost("aquarium/UpdateAquariumData", Newtonsoft.Json.JsonConvert.SerializeObject(request));
        }
        else
        {
            UpdateSlotDatasRequest request = new UpdateSlotDatasRequest();
            request.playFabId = GContext.container.Resolve<IUserService>().UserId;
            request.slotDatas = data.slotDatas;
            request.cardLv = string.Join(',', cardLv);
            // [REMOVED] CustomServerMgr deleted
            // customServerMgr?.CustomServerPost("aquarium/UpdateSlotData", Newtonsoft.Json.JsonConvert.SerializeObject(request));
        }
        UpdateUserData();
    }

    public List<float> GetWeightMag()
    {
        PlayerFishData playerFishData = GContext.container.Resolve<PlayerFishData>();
        PlayerData playerData = GContext.container.Resolve<PlayerData>();
        List<float> weight = new List<float>() { 0, 0, 0, 0, 0, 0 };
        List<int> fishCount = new List<int>() { 0, 0, 0, 0, 0, 0 };
        MapData mapData = _tables.TbMapData.GetOrDefault(data.mapId);
        var fishList = mapData.FishList;
        for (int j = 0; j < fishList.Count; j++)
        {
            var data = _tables.TbFishData.GetOrDefault(fishList[j]);
            fishCount[data.Quality - 1]++;
            int level = playerFishData.GetDataLevel(fishList[j]);
            if (level > 0)
            {
                FishCard fishCard = _tables.TbFishCard.GetOrDefault(data.FishCardID);
                weight[data.Quality - 1] += fishCard.WeightMagList[level - 1];
            }
        }
        for (int i = 0; i < weight.Count; i++)
        {
            weight[i] /= fishCount[i];
        }
        weight[5] = playerData.benefitsEventFishCashMag;

        return weight;
    }
}