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 AquariumShooterFishManager
{
    private cfg.Tables _tables;
    private ICustomServerMgr customServerMgr;
    public AquariumServerData serverData { get; private set; }
    public int MapId => serverData?.mapId ?? 101;
    List<int> HuntResult = null;
    List<int> DropID = null;

    public AquariumShooterFishManager()
    {
        _tables = GContext.container.Resolve<Tables>();
        customServerMgr = GContext.container.Resolve<ICustomServerMgr>();
    }

    void RobotSetFish(MapData mapData, AquariumSlotData aquariumSlotData, AquariumEgg tankEgg)
    {
        //权重取鱼
        List<int> FishIDList;

        List<FishItemList> fishList = mapData.DropFishList;
        float allProb = tankEgg.HatchFishQualityProb.Sum();
        float prob = UnityEngine.Random.Range(0, allProb);
        float 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)
        {
            FishIDList = fishList[fishQuality - 1].FishIDList;
            aquariumSlotData.fishItemID = FishIDList[UnityEngine.Random.Range(0, FishIDList.Count)];
        }
        else
        {
            FishIDList = _tables.TbAquariumConfig.AquariumSpFishList;
            aquariumSlotData.fishItemID = FishIDList[UnityEngine.Random.Range(0, FishIDList.Count)];
        }
        aquariumSlotData.aquariumFishID = fishQuality;
    }

    void RobotSetFishCount(AquariumSlotData aquariumSlotData, AquariumEgg tankEgg)
    {
        int allProb = tankEgg.HatchFishQuantityProb.Sum();
        int prob = UnityEngine.Random.Range(0, allProb);
        int 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 RobotSetTime(AquariumSlotData aquariumSlotData, AquariumEgg tankEgg)
    {
        AquariumFish tankFish = _tables.TbAquariumFish.GetOrDefault(aquariumSlotData.aquariumFishID);
        aquariumSlotData.growthTime = UnityEngine.Random.Range(tankFish.GrowthTime[0], tankFish.GrowthTime[1]);
        aquariumSlotData.hatchTime = UnityEngine.Random.Range(tankEgg.HatchTime[0], tankEgg.HatchTime[1]);

        aquariumSlotData.mutants = 0;
        for (int j = 0; j < aquariumSlotData.fishMQ; j++)
        {
            if (UnityEngine.Random.Range(0, 1f) < tankFish.MutantProb)
            {
                aquariumSlotData.mutants++;
            }
        }
    }

    AquariumServerData SetRobot(string playFabId)
    {
        int b = Convert.ToInt32(playFabId, 16);
        Robot robot = _tables.TbRobot.GetOrDefault(b);
        string AquariumServerDataStr = PlayerPrefs.GetString("AquariumServerData" + playFabId[^1]);
        DateTime dateTime = ZZTimeHelper.UtcNow();
        AquariumServerData localServerData = new AquariumServerData();
        if (!string.IsNullOrEmpty(AquariumServerDataStr))
        {
            try
            {
                localServerData = JsonConvert.DeserializeObject<AquariumServerData>(AquariumServerDataStr);
                //防止改时间导致的机器人数据错误(蛋未孵化)
                if (localServerData.startTime < ZZTimeHelper.UtcNow())
                {
                    Debug.Log($"nextOpponent InitFish SetRobotMapId {localServerData.mapId}");
                    return localServerData;
                }
            }
            catch (Exception)
            {

                Debug.LogError("AquariumServerDataStr Error");
            }
        }
        localServerData.mapId = GContext.container.Resolve<SmallGameData>().RobotMapId;
        localServerData.startTime = ZZTimeHelper.UtcNow();
        localServerData.slot = robot.HatchEggPots;

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

        List<AquariumEgg> TankEggList = _tables.TbAquariumEgg.DataList;
        float eggAllWeight = -0.0001f;
        for (int i = 0; i < TankEggList.Count; i++)
        {
            eggAllWeight += TankEggList[i].Weight;
        }
        bool isGrowth = false;
        MapData mapData = _tables.TbMapData.GetOrDefault(localServerData.mapId);

        for (int i = 0; i < localServerData.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;
            RobotSetFish(mapData, aquariumSlotData, tankEgg);

            //取鱼的数量
            RobotSetFishCount(aquariumSlotData, tankEgg);
            RobotSetTime(aquariumSlotData, tankEgg);
            aquariumSlotData.startTime = dateTime;
            if (robot != null)
            {
                if (robot.HatchProb > UnityEngine.Random.Range(0, 1f))
                {
                    isGrowth = true;
                    aquariumSlotData.accelerationHatch = aquariumSlotData.hatchTime + 1;
                    aquariumSlotData.accelerationGrowth = aquariumSlotData.growthTime *
                        UnityEngine.Random.Range(robot.MatureProgress[0], robot.MatureProgress[1]);
                }
            }
            aquariumSlotData.index = i;
            slotData.Add(aquariumSlotData);

            aquariumResultDatas.Add(new AquariumResultData());
            aquariumHurtDatas.Add(new AquariumHurtData());
        }
        if (!isGrowth)
        {
            slotData[0].accelerationHatch = slotData[0].hatchTime + 1;
            slotData[0].accelerationGrowth = slotData[0].growthTime *
                UnityEngine.Random.Range(robot.MatureProgress[0], robot.MatureProgress[1]);

        }
        localServerData.slotDatas = slotData;
        localServerData.aquariumResultDatas = aquariumResultDatas;
        localServerData.aquariumHurtDatas = aquariumHurtDatas;
        PlayerPrefs.SetString("AquariumServerData" + playFabId[^1], JsonConvert.SerializeObject(localServerData));

        //保存 数据
        return localServerData;
    }

    public AquariumServerData GetDataFishHuntInit(string playFabId, FishHuntInit inti)
    {
        int b = Convert.ToInt32(playFabId, 16);
        Robot robot = _tables.TbRobot.GetOrDefault(b);
        HuntResult = inti.HuntResult;
        DropID = inti.DropID;
        DateTime dateTime = ZZTimeHelper.UtcNow();
        AquariumServerData localServerData = new AquariumServerData();
        localServerData.mapId = inti.MapID;
        localServerData.startTime = ZZTimeHelper.UtcNow();
        List<int> Fishlist = inti.Fishlist;
        List<int> FishQuatitylist = inti.FishQuatitylist;
        List<int> FishQualitylist = inti.FishQualitylist;
        List<int> FishMutantlist = inti.FishMutantlist;
        List<float> FishGrowthlist = inti.FishGrowthlist;
        localServerData.slot = Fishlist.Count;

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

        for (int i = 0; i < localServerData.slot; i++)
        {
            AquariumSlotData aquariumSlotData = new AquariumSlotData();
            aquariumSlotData.eggId = 1;
            aquariumSlotData.fishItemID = Fishlist[i];
            aquariumSlotData.aquariumFishID = FishQualitylist[i];
            aquariumSlotData.fishMQ = FishQuatitylist[i];
            aquariumSlotData.startTime = dateTime;
            aquariumSlotData.hatchTime = 1;
            aquariumSlotData.growthTime = 1;
            aquariumSlotData.accelerationHatch = 1.1f;
            aquariumSlotData.accelerationGrowth = aquariumSlotData.growthTime * FishGrowthlist[i];

            aquariumSlotData.mutants = FishMutantlist[i];
            aquariumSlotData.index = i;
            slotData.Add(aquariumSlotData);

            aquariumResultDatas.Add(new AquariumResultData());
            aquariumHurtDatas.Add(new AquariumHurtData());
        }
        localServerData.slotDatas = slotData;
        localServerData.aquariumResultDatas = aquariumResultDatas;
        localServerData.aquariumHurtDatas = aquariumHurtDatas;
        serverData = localServerData;
        //保存 数据
        return serverData;
    }

    public async Task<AquariumServerData> GetData(string playFabId, bool isRobot, bool canEmpty)
    {
        HuntResult = null;
        DropID = null;

        if (isRobot)
        {
            serverData = SetRobot(playFabId);
            return serverData;
        }
        GetAquariumDataRequest request = new GetAquariumDataRequest();
        request.playFabId = playFabId;
        string result = await customServerMgr.CustomServerPost("aquarium/GetAquariumData", Newtonsoft.Json.JsonConvert.SerializeObject(request));
        if (result != null)
        {
            var resp = JsonConvert.DeserializeObject<GetAquariumDataResp>(result);
            if (resp.code == 0)
            {
                var data = resp.data;
                List<AquariumSlotData> slotDatas = data.slotDatas;
                if (slotDatas == null)
                {
                    return null;
                }
                if (canEmpty)
                {
                    serverData = resp.data;
                    return serverData;
                }
                var time = ZZTimeHelper.UtcNow();
                List<AquariumResultData> aquariumResultDatas = data.aquariumResultDatas;
                for (int i = 0; i < slotDatas.Count; i++)
                {
                    AquariumSlotData slotData = slotDatas[i];
                    slotData.index = i;
                    var HatchTime = slotData.FishHatchTime();

                    if (HatchTime < time)
                    {
                        if (!slotData.IsResult() && aquariumResultDatas.Count > i && !aquariumResultDatas[i].IsResult())
                        {
                            serverData = resp.data;
                            return serverData;
                        }
                    }
                }
            }
            else
            {
                Debug.LogWarning("GetAquariumDataRequest Null");
                if (canEmpty)
                {
                    PlayerData playerData = GContext.container.Resolve<PlayerData>();
                    AquariumServerData data = new AquariumServerData();
                    data.startTime = ZZTimeHelper.UtcNow();
                    data.slot = playerData.benefitsAquariumLimit;
                    List<AquariumInit> inits = _tables.TbAquariumInit.DataList;

                    NewSlotInitData(inits[0], data);
                    serverData = data;
                    return serverData;
                }
            }
        }
        return null;
    }
    void NewSlotInitData(AquariumInit init, AquariumServerData data)
    {
        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<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]);

            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;
    }
    public float RobFishRequest(int changeTargetCount, int multiple, string playFabId, int index, int groupId, OpponentItemData opponentItemData, out bool isRob, out int addRankCount)
    {
        GContext.container.Resolve<SmallGameData>().SaveFishHuntGameCount();
        AquariumSlotData slotData = serverData.slotDatas[groupId];
        AquariumFish aquariumFish = _tables.TbAquariumFish.GetOrDefault(slotData.aquariumFishID);
        //刺鱼奖励
        float extra = 0;
        if (index < slotData.mutants)
        {
            extra += aquariumFish.AttackMutantExtraReward;
        }
        isRob = false;
        ItemData itemDatas = GContext.container.Resolve<PlayerItemData>().GetItemDataOne(aquariumFish.AttackReward);
        float ExtraReward = 0;
        if (HuntResult != null)
        {
            itemDatas = GContext.container.Resolve<PlayerItemData>().GetItemDataOne(DropID[groupId]);
            if (HuntResult[groupId] == 1)
            {
                if (index < slotData.mutants)
                {
                    ExtraReward = aquariumFish.StealMutantExtraReward;
                }
                else
                {
                    ExtraReward = aquariumFish.StealExtraReward;
                }
                isRob = true;
            }
        }
        else
        {
            float random = UnityEngine.Random.Range(0, 1f);
            if (index < slotData.mutants)
            {
                if (random <= aquariumFish.StealMutantProb)
                {
                    ExtraReward = aquariumFish.StealMutantExtraReward;
                    isRob = true;
                }
            }
            else
            {
                if (random <= aquariumFish.StealProb)
                {
                    ExtraReward = aquariumFish.StealExtraReward;
                    isRob = true;
                }
            }
        }

        extra += UnityEngine.Random.Range(0, aquariumFish.StealRewardRand) - aquariumFish.StealRewardRand * 0.5f;

        itemDatas.count = (int)(itemDatas.count * (1 + extra) * multiple * (1 + ExtraReward));
        SuperHunt superHunt = GContext.container.Resolve<BuffDataCenter>().GetWeelyBuffTimeData<SuperHunt>();
        float superCashBonus = 0;
        if (superHunt != null)
        {
            superCashBonus = superHunt.CashBonus;
        }
        //itemDatas.count *= (1 + superCashBonus);
        //获取奖励
        GContext.container.Resolve<PlayerItemData>().AddItem(itemDatas);

        var _fishingEventData = GContext.container.Resolve<FishingEventData>();
        if (_fishingEventData.rankInit != null)
        {
            int point = _fishingEventData.rankInit.PointRobbery[1];
            if (isRob)
            {
                point = _fishingEventData.rankInit.PointRobbery[2];
            }
            if (index < slotData.mutants)
            {
                point += _fishingEventData.rankInit.PointRobbery[3];
            }
            addRankCount = point * multiple;
            _fishingEventData.AddRankTarget(addRankCount);
        }
        else
        {
            addRankCount = 0;
        }

        if (opponentItemData.isRobot)
        {
            int i = groupId;

            List<AquariumHurtData> aquariumHurtDatas = serverData.aquariumHurtDatas;

            //鱼被刺走
            if (isRob)
            {
                //aquariumHurtDatas[i].fishLQ++;

                ////鱼全部被刺走,重置
                //if (aquariumHurtDatas[i].fishLQ >= slotData.fishMQ)
                //{
                //    aquariumHurtDatas[i].fishLQ = 0;
                //}
                PlayerPrefs.DeleteKey("AquariumServerData" + playFabId[^1]);
                //PlayerPrefs.SetString("AquariumServerData" + playFabId[^1], JsonConvert.SerializeObject(serverData));
            }
        }
        else
        {
            //通知服务器刺伤谁的鱼
            RobFishRequest request = new RobFishRequest();
            request.timeEventId = GContext.container.Resolve<SmallGameData>().AlbumEventID;
            request.playFabId = playFabId;
            request.slotIndex = groupId;
            if (UnityEngine.Random.Range(0, 1f) <= aquariumFish.RealStealProb)
            {
                request.isRob = isRob;
            }
            request.playerId = GContext.container.Resolve<IUserService>().UserId;
            customServerMgr.CustomServerPost("aquarium/RobFish", Newtonsoft.Json.JsonConvert.SerializeObject(request));
        }

        Debug.Log($"target_source  isRobot: {opponentItemData.isRobot}  target_group: {opponentItemData.target_group} target_source {opponentItemData.target_source}");


#if AGG
        using (var e = GEvent.GameEvent("fish_raid"))
        {
            Item item = _tables.TbItem.GetOrDefault(slotData.fishItemID);
            e.AddContent("fish_id", item.RedirectID)
                .AddContent("fish_quality", slotData.aquariumFishID)
                .AddContent("is_mutant", slotData.mutants > index)
                .AddContent("result", isRob ? 1 : 0)
                .AddContent("target_accountid", opponentItemData.isRobot ? "-1" : playFabId)
                .AddContent("target_group", opponentItemData.target_group)
                .AddContent("target_source", opponentItemData.target_source)
                .AddContent("fish_multiple",multiple)
                .AddContent("target_change_count", changeTargetCount)
                .AddContent("reward_cash", itemDatas.count);
        }
#endif
        return itemDatas.count;
    }
}