using asap.core;
using GameCore;
using LitJson;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using UnityEngine;
public struct RodStateEvent
{
    public int RoleID;
}

public partial class FishingDuelManager
{
    public int seed;
    public int WeatherType { get; private set; } = 0;//0晴天 1雨天
    bool hasRedFish;//0无红鱼 1有红鱼
    public bool IsRobot { get; private set; }
    public int MachingState = 0;// 1一方准备好 2双方准备好
    public int SceneState = 0;// 1一方准备好 2双方准备好
    public int RodState = 0;// 1一方准备好 2双方准备好
    public int GameOverState = 0;//1一方钓完 2双方钓完
    bool IsCancel = false;
    public async void StartMaching()
    {
        selfIsLastFish = false;
        //随机地图
        //等待匹配成功，或者匹配失败（机器人），开始对战
        //传入段位，可匹配段位列表，杯数，选择倍率，地图列表，随机种子seed
        int rank = eventSolomain.RankTier;
        List<int> matchTierList = eventSolomain.MatchTierList;
        int trophy = duelData.progress;
        int mag = magnification;
        List<int> mapIDs = await GetRandmMap();
        seed = new System.Random().Next();

        MachingState = 0;
        SceneState = 0;
        RodState = 0;
        GameOverState = 0;
        IsCancel = false;
        bool isSuccess = await MachingSuccess();
        if (IsCancel)
        {
            return;
        }
        //DuelFishingDataSave duelFishingDataSave = null;

        if (!isSuccess)
        {
            //if (duelFishingDataSave != null)
            //{
            //    duelData.mapId = duelFishingDataSave.mapId;
            //    seed = duelFishingDataSave.seed;
            //    enemySolomain = _tables.TbEventSolomain.DataMap[duelFishingDataSave.rankTier];
            //}
            //else
            {
                if (mapIDs.Count == 1)
                {
                    duelData.mapId = mapIDs[0];
                }
                else
                {
                    duelData.mapId = mapIDs[UnityEngine.Random.Range(0, mapIDs.Count)];
                }
                int robotTier = eventSolomain.MatchTierList[UnityEngine.Random.Range(0, eventSolomain.MatchTierList.Count)];
                enemySolomain = _tables.TbEventSolomain.DataMap[robotTier];
            }
            //============匹配失败===============
            //============匹配失败===============
        }

        WeatherType = new System.Random(seed).Next(0, 2);
        GetFishItemID(new System.Random(seed));
        SetTraitID();
        List<int> carLevels = SetSelfModel();
        if (isSuccess)
        {
            IsRobot = false;
        }
        else
        {
            IsRobot = true;
            //if (duelFishingDataSave != null)
            //{
            //    PlayerRobot(duelFishingDataSave);
            //}
            //else
            {
                MachRobot();//匹配机器人
            }
        }
        SendFishCardLevel(carLevels);
        Debug.Log($"本局鱼Seed：{seed}  WeatherType {WeatherType}");

    }
    public void CancelMaching()
    {
        //发送取消请求
        IsCancel = true;
    }
    #region 匹配成功
    //选鱼杆之后再传鱼杆ID、鱼杆等级、鱼杆星级等数据
    //SetEnemyRodData(rodData.ID, rodLevel, star);
    async Task<bool> MachingSuccess()
    {
        double maxMatchTime = eventSoloConfig.MaxMatchTime * 1000;
        while (maxMatchTime > 0)
        {
            DateTime loopStartTime = DateTime.Now;

            try
            {

                //if (NetworkManager.Instance.HasMachingSuccess())
                //{
                //    duelData.mapId = NetworkManager.Instance.GetMachingMapID();
                //    enemySolomain = NetworkManager.Instance.GetMachingEnemySolomain();
                //    seed = NetworkManager.Instance.GetMachingSeed();
                //enemyModel = new DuelPlayerModel();
                //enemyModel.Init(ID, Name, Avatar,Mag,eventSoloConfig.MaxFailCount);
                //enemyChatModel = new DuelChatModel();//真人
                //enemyChatModel = new DuelRobotChatModel();//复刻真人
                //    return true;
                //}
            }
            catch (Exception ex)
            {
                Debug.LogError($"匹配检查过程中发生异常：{ex.Message}");
                // 可根据需求选择：继续重试（仅打日志）或终止匹配（return false）
                // return false; 
            }

            TimeSpan loopElapsed = DateTime.Now - loopStartTime;
            maxMatchTime -= loopElapsed.TotalMilliseconds;
            if (IsCancel || maxMatchTime < 1000)
            {
                return false;
            }
            await Task.Delay(1000);
            maxMatchTime -= 1000f;
            if (IsCancel || maxMatchTime < 0)
            {
                return false;
            }
        }
        return false;
    }
    //=========同步鱼卡信息==========
    void SendFishCardLevel(List<int> carLevels)
    {
        selfModel.Init(carLevels);
        //传输鱼卡等级
        if (!IsRobot)
        {
            //NetworkManager.Instance.SendFishCardLevel(carLevels);
        }
        MachingState++;
    }
    //获得对手鱼卡等级
    void ReceiveEnemyFishCardLevel(List<int> carLevels)
    {
        enemyModel.Init(carLevels);
        ReceiveEnemyRodData(_tables.TbRodData.DataList[0].ID, 0, 0);//默认鱼杆信息
        MachingState++;
    }
    //=========同步鱼卡信息==========
    //=========同步鱼竿信息==========
    public void SendRodData(DuelRodData duelRod)
    {
        selfModel.SetRodData(duelRod);
        if (!IsRobot)
        {
            //NetworkManager.Instance.SendRodData(id, rodLevel, rodStar);
        }
        RodState++;
        GContext.Publish(new RodStateEvent() { RoleID = 0 });
    }
    //获得对手鱼竿等级
    public void ReceiveEnemyRodData(DuelRodData duelRod)
    {
        enemyModel.SetRodData(duelRod);
        RodState++;
        GContext.Publish(new RodStateEvent() { RoleID = 1 });
    }
    //=========同步鱼竿信息==========
    //=========同步场景完成信息==========
    public void SendChangeScene()
    {
        if (!IsRobot)
        {
            //NetworkManager.Instance.SendSceneData(mapId);
        }
        SceneState++;
    }
    public void ReceiveEnemyChangeScene()
    {
        SceneState++;
    }
    //=========同步场景完成信息==========
    #endregion

    public void ReceiveEnemyRodData(int id, int rodLevel, int rodStar)
    {
        DuelRodData duelRod = new DuelRodData
        {
            rodId = id,
            rodLevel = rodLevel,
            rodStar = rodStar
        };
        enemyModel.SetRodData(duelRod);
    }

    /// <summary>
    /// 对手操作
    /// </summary>
    /// <param name="robotFishing"></param>
    public void ReceiveFishingQueue(RobotFishingQueue robotFishing)
    {
        bool gameOver;
        switch (robotFishing.changeState)
        {
            case FishingChangeState.Cast:
                enemyModel.CastRod(robotFishing.fishItemId);
                if (enemyModel.IsLastFish() && !selfModel.IsLastFish())
                {
                    enemyChatModel.SendMessage((int)RobotDuelChatType.FirstLastFishStart);
                    ReceiveFishingEvent receiveFishingEvent = new ReceiveFishingEvent();
                    receiveFishingEvent.value = LocalizationMgr.GetFormatTextValue("UI_EventFishingDuelPanel_38", enemyModel.PlayerName);
                    GContext.Publish(receiveFishingEvent);
                }
                break;
            //case FishingChangeState.StartFishing:
            //    enemyModel.StartFishing();
            //    break;
            case FishingChangeState.FishingSuccess:
                FishInfoData data = selfModel.GetDuelFishingData(enemyModel.index,
                    robotFishing.fishItemId,
                    robotFishing.point,
                    robotFishing.fishCardAdd,
                    robotFishing.fishingRodAdd);

                gameOver = enemyModel.StopFishing(data);
                if (gameOver)
                {
                    SetFishingOver(2);
                    enemyChatModel.SendMessage((int)RobotDuelChatType.FirstLastFishSuccess);
                }
                else
                {
                    enemyChatModel.SendMessage((int)RobotDuelChatType.FishingSuccess);
                }
                break;
            case FishingChangeState.FishingFail:
                gameOver = enemyModel.StopFishing(new FishInfoData());
                if (gameOver)
                {
                    SetFishingOver(2);
                }
                break;
            default:
                break;
        }
    }
    #region 聊天处理
    public void SendQuickMessage(int id)
    {
        //本地转发
        selfChatModel.SendMessage(id);
        //远端转发
        if (!IsRobot)
        {
            //NetworkManager.Instance.SendQuickMessage(id);
        }
    }
    //接收对手消息
    public void ReceiveQuickMessage(int id)
    {
        enemyChatModel.ReceiveMessage(id);
    }

    #endregion

    #region 网络接受对手操作

    #endregion
    //往服务器传数据
    public void SendDuelFishingData()
    {
        var solomain = eventSolomain;
        if (enemySolomain.RankTier < eventSolomain.RankTier)
        {
            solomain = enemySolomain;
        }
        List<DuelFishingData> DuelFishingDatas = new List<DuelFishingData>();
        foreach (var data in selfModel.DuelFishingDatas)
        {
            if (data.fishItemId > 0)
            {
                DuelFishingData showData = new DuelFishingData
                {
                    slienceTime = data.slienceTime,
                    //castingTime = data.castingTime,
                    fishingTime = data.fishingTime,
                    isWin = data.isWin,
                    fishItemId = data.fishItemId,
                    point = data.point,
                    failNum = data.failNum,
                    fishCardAdd = data.fishCardAdd,
                    fishRodAdd = data.fishRodAdd
                };
                DuelFishingDatas.Add(showData);
            }
        }
        DuelFishingDataSave duelFishingDataSave = new DuelFishingDataSave
        {
            rankTier = solomain.RankTier,
            mapId = duelData.mapId,
            seed = seed,
            playerID = selfModel.PlayerID,
            setRodTime = selfModel.SetRodTime,
            playerName = selfModel.PlayerName,
            carLevels = selfModel.CarLevels,
            playerAvatar = selfModel.PlayerAvatar,
            rankScore = selfModel.RankScore,
            mag = selfModel.Mag,
            rodId = selfModel.RodId,
            rodLevel = selfModel.RodLevel,
            rodStar = selfModel.RodStar,
            selfDuelFishingDatas = DuelFishingDatas
        };
        string json = JsonMapper.ToJson(duelFishingDataSave);
        Debug.Log("本局上传对战数据" + json);
        //NetworkManager.Instance.SendDuelFishingData(json);
    }

}
public class ReceiveFishingEvent
{
    public string value;
}
//往服务器存褚操作数据
public class DuelFishingDataSave
{
    public int rankTier { get; set; }
    public int mapId { get; set; }
    public int seed { get; set; }
    public string playerID { get; set; }
    public int setRodTime { get; set; } //设置鱼竿时间
    public string playerName { get; set; }
    public List<int> carLevels { get; set; } = new List<int>(6);
    public string playerAvatar { get; set; }
    public int rankScore { get; set; }
    public int mag { get; set; } = 1;
    public int rodId { get; set; }
    public int rodLevel { get; set; }
    public int rodStar { get; set; }
    public List<DuelFishingData> selfDuelFishingDatas { get; set; }
}