using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using GCGame.Table;
using Module.Log;
using System;
using Games.Scene;
using Games.LogicObj;

// 夺旗奖励结构
public class ScoreAward : IComparable<ScoreAward>
{
    // 具体含义根据使用场景决定
    public int minLimit;        // 最底要求
    public int maxLimit;        // 最高要求

    public List<AwardItemInfo> awards = new List<AwardItemInfo>();

    public int CompareTo(ScoreAward other)
    {
        if(this.minLimit < other.minLimit)
        {
            return -1;
        }
        else if(this.minLimit > other.minLimit)
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
}

// 夺旗左上战况面板控制
// 字典配置
//5812	跨服据点_天_颜色	<color=#ff3e6b>
//5813	跨服据点_地_颜色	<color=#ff3e6b>
//5814	跨服据点_人_颜色	<color=#ff3e6b>
//5815	跨服据点_提示	击杀守卫怪后方能对据点进行攻击。
//5816	跨服据点_占领据点公告	{0}阵营的玩家{1}占领了{2}据点{3}！
//5817	跨服据点_击杀人数格式	（击杀{0}人）
//5818	跨服据点_分数增长格式	（{0}/分）
//5819	跨服据点_未上榜描述 未上榜
//5823	跨服据点_奖励排名格式_单 第 {0}名
//5824	跨服据点_奖励排名格式_多 第 {0}-{1}名
//5825	跨服据点_参与奖励 参与奖励
//5826	跨服据点_积分描述	{0}积分完成奖励
//5827	跨服据点_积分奖励完成描述	（可领取）
//5828	跨服据点_游戏倒计时 倒计时
//5829	跨服据点_离开倒计时 离开
//5830	跨服据点_自身排行榜描述 我的排名
//5831	跨服据点_据点积分描述 据点积分
//5832	跨服据点_阵营据点数格式({0}个)
//5833	跨服据点_阵营 中立
//5834	跨服据点_阵营 天
//5835	跨服据点_阵营 地
//5836	跨服据点_阵营 人
public class CaptureFlagStatePanelCtr : MonoBehaviour {

    public static int GetCurCamp()
    {
        switch (GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Force)
        {
            case 6:
                {
                    return 1;
                }
            case 7:
                {
                    return 2;
                }
            case 27:
                {
                    return 3;
                }
            default:
                return -1;
        }
    }




    public delegate void voidVector2Del(Vector2 data);

    private static CaptureFlagStatePanelCtr instance;
    public static CaptureFlagStatePanelCtr Instance
    {
        get { return instance; }
    }

    public GameObject flagPanel;                                // 旗面板
    public GameObject RankPanel;                                // 奖励/排行榜面板

    public UIContainerBase CaptureFlag;
    public UIContainerBase ranks;                               // 排行榜
    public UIContainerBase awards;                              // 积分奖励
    public Text awardDesc;                                      // 奖励
    public Text rankTitle;                                      // 排行榜
    public Text rankNum;                                        // 排行榜名次
    public Text killNum;                                        // 击杀人数
    public Text scoreTitle;                                     // 积分
    public Text scoreNum;                                       // 积分数量
    public Text scoreNum1;                                       // 积分数量
    public Text scoreDelta;                                     // 积分增长速度

    public Text scoreAwardLevel;

    public Button hideBtn;
    public Toggle flagsStateBtn;
    public Toggle rankBtn;
    public Button awardDisplayBtn;
    public Button ruleBtn;
    public Button exitBtn;
    public GameObject countDownCtr;
    public Text countDownDesc;
    public TimeDownText countDownt;
    public float calculateDelta;                                // 计算积分计算间隔
    private Coroutine countDownC;

    public Animator panelAnimator;

    public List<ScoreAward> killAwards = new List<ScoreAward>();                                            // 击杀奖励
    public List<ScoreAward> joinAwards = new List<ScoreAward>();                                            // 参与奖励
    private List<ScoreAward> scoreAwards = new List<ScoreAward>();                                          // 积分奖励
    public Text[] captureFlagText;                              // 各阵营占领数文字
    Dictionary<int, List<int>> _CaptureFalgDic = new Dictionary<int, List<int>>();
    private int currentScore = 0;                                                                           // 当前积分
    private List<CaptureFlagRankData> rankDatas = new List<CaptureFlagRankData>();

    // 夺旗排行榜数据结构
    public class CaptureFlagRankData
    {
        public int rank;
        public CrossSerFlagRankInfo packInfo;
    }

    private List<CaptureFlagItem.CaptureFlagData> _captureFlagItems = new List<CaptureFlagItem.CaptureFlagData>();

    private void Awake()
    {
        if(instance == null)
        {
            instance = this;
            Init();
        }
    }

    private void Init()
    {
        _captureFlagItems.Clear();
        var tabs = TableManager.GetCrossSerFlagPoint().Values;
        foreach(var kv in tabs)
        {
            if(kv != null)
            {
                CaptureFlagItem.CaptureFlagData captureFlagData = new CaptureFlagItem.CaptureFlagData();
                captureFlagData.tabCrossSerFlagPoint = kv;
                captureFlagData.State = 0;
                captureFlagData.CampIndex = 0;
                captureFlagData.CDTime = -1;
                _captureFlagItems.Add(captureFlagData);
            }
        }
        CaptureFlag.InitContentItem(_captureFlagItems, OnFlagClick);
        flagsStateBtn.onValueChanged.AddListener(OnFlagsStateBtnClick);
        rankBtn.onValueChanged.AddListener(OnRankBtnClick);
        awardDisplayBtn.onClick.AddListener(OnAwardDisplayBtnClick);
        ruleBtn.onClick.AddListener(OnRuleBtnClick);
        exitBtn.onClick.AddListener(OnExitBtnClick);
        hideBtn.onClick.AddListener(OnAnimBtnClick);

        // 初始显示阵营分布
        OnFlagsStateBtnClick(true);

        InitAward();
        _CaptureFalgDic = new Dictionary<int, List<int>>();
        UpdateCampFlagCount();

        panelAnimator.Play("Show");
        GCGame.Utils.HideMainTopRightUI();
    }

    private void InitAward()
    {
        scoreAwards.Clear();
        joinAwards.Clear();
        killAwards.Clear();

        // 初始化奖励
        var tabAward = TableManager.GetCrossSerFlagAward().Values;
        foreach (var tempTab in tabAward)
        {
            ScoreAward newOne = new ScoreAward();
            newOne.minLimit = tempTab.LimitMin;
            newOne.maxLimit = tempTab.LimitMax;
            int awardCount = tempTab.getItemIDCount();
            for (int i = 0; i < awardCount; ++i)
            {
                if (tempTab.GetItemIDbyIndex(i) > 0)
                {
                    AwardItemInfo newAward = new AwardItemInfo();
                    newAward.itemid = tempTab.GetItemIDbyIndex(i);
                    newAward.count = tempTab.GetItemNumbyIndex(i);
                    newAward.bind = tempTab.GetItemBindbyIndex(i) == 1 ? true : false;
                    newOne.awards.Add(newAward);
                }
                else
                {
                    break;
                }
            }

            switch (tempTab.Type)
            {
                case 0:
                    joinAwards.Add(newOne);
                    break;
                case 1:
                    scoreAwards.Add(newOne);
                    break;
                case 2:
                    killAwards.Add(newOne);
                    break;
            }
        }

        joinAwards.Sort();
        scoreAwards.Sort();
        killAwards.Sort();

        rankTitle.gameObject.SetActive(true);
        SetText(rankTitle, StrDictionary.GetClientDictionaryString("#{5830}"));
        scoreTitle.gameObject.SetActive(true);
        SetText(scoreTitle, StrDictionary.GetClientDictionaryString("#{5831}"));
    }

    private void OnFlagsStateBtnClick(bool isOn)
    {
        if (!isOn)
            return;
        flagPanel.SetActive(true);
        RankPanel.SetActive(false);
    }

    private void OnRankBtnClick(bool isOn)
    {
        if (!isOn)
            return;
        flagPanel.SetActive(false);
        RankPanel.SetActive(true);
    }

    private void OnAwardDisplayBtnClick()
    {
        UIManager.ShowUI(UIInfo.CaptureFlagAwardPanel);
    }

    public void OnRuleBtnClick()
    {
        MessageHelpLogic.ShowHelpMessage(61);
    }

    public void OnExitBtnClick()
    {
        if (Singleton<ObjManager>.Instance.MainPlayer != null)
        {
            Singleton<ObjManager>.Instance.MainPlayer.AskLeaveCopy();
        }
    }

    public void OnAnimBtnClick()
    {
        var state = panelAnimator.GetCurrentAnimatorStateInfo(0);
        if (state.IsName("Show"))
        {
            panelAnimator.Play("Hide");
        }
        else
        {
            panelAnimator.Play("Show");
        }
    }

    private void OnFlagClick(object obj)
    {
        CaptureFlagItem.CaptureFlagData captureFlagData = obj as CaptureFlagItem.CaptureFlagData;
        if (captureFlagData == null)
            return;

        Vector3 targetPos = new Vector3();
        targetPos.x = captureFlagData.tabCrossSerFlagPoint.BornPosX;
        targetPos.z = captureFlagData.tabCrossSerFlagPoint.BornPosZ;
        var point = new AutoSearchPoint(GameManager.gameManager.RunningScene, targetPos.x, targetPos.z);
        if (GameManager.gameManager && GameManager.gameManager.AutoSearch)
        {
            GameManager.gameManager.AutoSearch.BuildPath(point);
            if (null != GameManager.gameManager.AutoSearch.Path)
            {
                GameManager.gameManager.AutoSearch.Path.autoSearchRadius = 2;
            }
        }
        
    }

    public void OnRecPacket(SynCrossSerFlagInfo datas)
    {
        if (datas.pointInfo.Count != 0)
        {
            UpdateCampFlagCount(datas);
            if (_captureFlagItems.Count<=0)
                Init();
            for (int i = 0; i < datas.pointInfo.Count; ++i)
            {
                for(int j=0;j<_captureFlagItems.Count;j++)
                {
                    if(_captureFlagItems[j].tabCrossSerFlagPoint.Id == datas.pointInfo[i].Index)
                    {
                        _captureFlagItems[j].CampIndex = datas.pointInfo[i].CampIndex;
                        _captureFlagItems[j].PointID = datas.pointInfo[i].PointID;
                        _captureFlagItems[j].GuardID = datas.pointInfo[i].GuardID;
                        _captureFlagItems[j].CDTime = datas.pointInfo[i].LastChangeCampTime;
                    }
                }
            }
        }
        CaptureFlag.RefreshItems();
        // 同步时间
        switch (datas.timetype)
        {
            case -1:
                /* do nothing */
                break;
            case 0:
                countDownCtr.SetActive(true);
                SetText(countDownDesc, StrDictionary.GetClientDictionaryString("#{5828}"));
                countDownt.Init("",datas.time,timeFormat:TimeDownText.TimeFormat.english);
                break;
            case 1:
                countDownCtr.SetActive(true);
                SetText(countDownDesc, StrDictionary.GetClientDictionaryString("#{5829}"));
                countDownt.Init("",datas.time, timeFormat: TimeDownText.TimeFormat.english);
                break;
            default:
                countDownCtr.SetActive(false);
                break;
        }

        int myRank = 0;
        
        rankDatas.Clear();
        if (datas.rankInfo.Count != 0)
        {
            for (int i = 0; i < datas.rankInfo.Count; ++i)
            {
                CaptureFlagRankData rankItem = new CaptureFlagRankData();
                rankItem.rank = i + 1;
                rankItem.packInfo = datas.rankInfo[i];

                if (datas.rankInfo[i].guid == (long)GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Guid)
                {
                    myRank = i + 1;
                }

                rankDatas.Add(rankItem);
            }
            ranks.InitContentItem(rankDatas);

            // 更新自身数据并刷新积分奖励
            if (myRank > 0)
            {
                SetText(rankNum, myRank.ToString());
            }
            else
            {
                SetText(rankNum, StrDictionary.GetClientDictionaryString("#{5819}"));
            }
        }
        
        SetText(killNum, StrDictionary.GetClientDictionaryString("#{5817}", datas.killnum.ToString()));
        SetText(scoreNum, datas.score.ToString());
        SetText(scoreNum1,datas.score.ToString());

        int foundIndex = -1;
        // 永远显示后一档奖励，当前没找到后一档奖励，则显示 "可领取"
        if (datas.score > currentScore)
        {
            for(int i = 0; i < scoreAwards.Count; ++i)
            {
                if(datas.score < scoreAwards[i].minLimit)
                {
                    foundIndex = i;
                    break;
                }
            }
        }

        if(foundIndex == -1)
        {
            int maxIndex = scoreAwards.Count - 1;
            awards.InitContentItem(scoreAwards[maxIndex].awards);
            // 显示可领取
            SetText(awardDesc, StrDictionary.GetClientDictionaryString("#{5826}", scoreAwards[maxIndex].minLimit) + StrDictionary.GetClientDictionaryString("#{5827}"));
            scoreAwardLevel.text = StrDictionary.GetClientDictionaryString("#{59016}");
        }
        else
        {
            awards.InitContentItem(scoreAwards[foundIndex].awards);
            SetText(awardDesc, StrDictionary.GetClientDictionaryString("#{5826}", scoreAwards[foundIndex].minLimit));
            scoreAwardLevel.text = StrDictionary.GetClientDictionaryString("#{5844}", scoreAwards[foundIndex].minLimit);
        }

        CalculateScoreDelta(datas);
    }

    private void OnEnable()
    {
        SetCampMark();
    }

    public void SetCampMark()
    {
        CaptureFlag.RefreshItems();
    }

    private void CalculateScoreDelta(SynCrossSerFlagInfo datas)
    {
        if(!_CaptureFalgDic.ContainsKey(GetCurCamp()))
        {
            SetText(scoreDelta, "0");
            return;
        }

        var totalAddScore = 0;
        for(int index = 0; index < _CaptureFalgDic[GetCurCamp()].Count; index++)
        {
            var tab = TableManager.GetCrossSerFlagPointByID(_CaptureFalgDic[GetCurCamp()][index], 0);
            if (tab != null)
            {
                totalAddScore += 60 / tab.AddScoreTime * tab.AddScore;
            }
        }

        string resultStr = StrDictionary.GetClientDictionaryString("#{5818}", totalAddScore);
        SetText(scoreDelta, resultStr);
    }

    private void UpdateCampFlagCount(SynCrossSerFlagInfo info = null)
    {
        if (info != null)
        {
            //变化的全部删除
            for(int index = 0; index < info.pointInfo.Count; index++)
            {
                foreach(var flagInfo in _CaptureFalgDic)
                {
                    if (flagInfo.Value.Contains(info.pointInfo[index].Index))
                        flagInfo.Value.Remove(info.pointInfo[index].Index);
                }
            }

            //重新添加变化后的数据
            for (int index = 0; index < info.pointInfo.Count; ++index)
            {
                if (_CaptureFalgDic.ContainsKey(info.pointInfo[index].CampIndex))
                {
                    if (!_CaptureFalgDic[info.pointInfo[index].CampIndex].Contains(info.pointInfo[index].Index))
                        _CaptureFalgDic[info.pointInfo[index].CampIndex].Add(info.pointInfo[index].Index);
                }
                else
                {
                    List<int> indexList = new List<int>();
                    indexList.Add(info.pointInfo[index].Index);
                    _CaptureFalgDic.Add(info.pointInfo[index].CampIndex, indexList);
                }
            }
        }

        var totalCount = 0;
        foreach (var flag in _CaptureFalgDic)
        {
            totalCount += flag.Value.Count;
        }

        if(totalCount > 15)
        foreach (var flag in _CaptureFalgDic)
        {
            Debug.LogError("CampIndex : " + flag.Key);
            string _All = "";
            for(int index = 0; index < flag.Value.Count; index++)
            {
                _All += flag.Value[index] + "\t";
            }
            Debug.LogError("Index : " + _All);
        }

    }

    private void OnDestroy()
    {
        if(instance != null)
        {
            instance = null;
        }
    }

    private void SetText(Text text, string info)
    {
        if(text.text.Equals(info))
        {
            return;
        }
        else
        {
            text.text = info;
        }
    }

    // 与服务器一致的规则，通过索引获得阵营名称
    public static string GetCampNameByIndex(int campIndex)
    {
        string campName = "";
        switch (campIndex)
        {
            case 0:
                campName = StrDictionary.GetClientDictionaryString("#{5833}");
                break;
            case 1:
                campName = StrDictionary.GetClientDictionaryString("#{5834}");
                break;
            case 2:
                campName = StrDictionary.GetClientDictionaryString("#{5835}");
                break;
            case 3:
                campName = StrDictionary.GetClientDictionaryString("#{5836}");
                break;
        }

        if(string.IsNullOrEmpty(campName))
        {
            LogModule.ErrorLog("Can't get camp name with index : " + campIndex);
        }

        return campName;
    }

    // 通过阵营索引获得对应玩家真实的势力值
    public static int GetWarForceByIndex()
    {
        return 0;
    }

    // 通过阵营索引获得阵营名称
    public static string GetSpriteNameByCamp(int campIndex, bool isBigFlag)
    {
        string spriteName = "";
        switch(campIndex)
        {
            case 0:
                spriteName = "zhong";
                break;
            case 1:
                spriteName = "tian";
                break;
            case 2:
                spriteName = "di";
                break;
            case 3:
                spriteName = "ren";
                break;
        }
 
        if(string.IsNullOrEmpty(spriteName))
        {
            LogModule.ErrorLog("Can't find sprite name by index:" + campIndex);
        }
        else if (isBigFlag && campIndex != 0)
        {
            spriteName += "Big";
        }

        return spriteName;
    }

    public void OnNpcObjBeAttacked(Obj_Character npc)
    {
        var tab = TableManager.GetCrossSerFlagConfigByID(0);

        for(int i=0;i<_captureFlagItems.Count;i++)
        {
            if(_captureFlagItems[i].PointID == npc.ServerID)
            {
                for (int j = 0; j < npc.ClientImpactInfos.Count; ++j)
                {
                    if (npc.ClientImpactInfos[j].ImpactId == tab.BuffID)
                    {
                        GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{5838}"));
                        return;
                    }
                }

                if (_captureFlagItems[i].GuardID != -1)
                {
                    GUIData.AddNotifyData(StrDictionary.GetClientDictionaryString("#{5815}"));
                }

                return;
            }
        }
    }
}