using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using System.Collections.Generic;
using GCGame.Table;
using Games.GlobeDefine;
using Games.Item;

public class AdvanceShowPanelCtr : MonoBehaviour { 
    #region
    public Text stageText;                          // 阶级描述
    public Text modelNameText;                      // 模型名称
    public UICameraTexture modelCameraTexture;

    //public Text curCombatText;  //当前战斗力
    #endregion

    //当前页面所属类型
    //public AdvanceMenuItemPanelCtr.AdvancePanelType panelType;
    //进阶所属类型
    private int advanceType;
    private int curBaseId;
    public int curAdvanceBaseLevel;                 // 当前进阶等级 
    public int curAdcanceBaseGrade;                 // 当前等阶
    public int curAdvanceServerLevel;               // 由服务器同步(坐骑之魂使用的数量)
    public AdvanceAttrPanel attrPanel;              // 属性面板
    public AdvanceSkillPanel skillPanel;            // 技能面板
    public AdvanceEquipPanel equipPanel;            // 装备面板
    public AdvanceAnimation animatonPanel;
    public GameObject ShowModelPanel;
    public GameObject _ShowWingToggle;
    public GameObject _ShowWingMark;
    //public GameObject ShowAnimationPanel;

    // 入口
    public void InitShowPanel (AdvanceInfo info)
    {
        _ShowWingToggle.gameObject.SetActive(info.type == (int)AdvanceBase.AdvanceType.Wing);
        curAdvanceServerLevel = info.SoulDan;       // 当前坐骑的服务器等级
        attrPanel.InitAttrInfo(info);               // 显示属性
        skillPanel.InitSkillPanel(info);            // 显示技能
        InitToggleState();

        switch (info.type)
        {
            // 对于坐骑进阶需要需要额外显示坐骑的装备槽
            case (int)AdvanceBase.AdvanceType.Ride:
                equipPanel.gameObject.SetActive(true);
                if (equipPanel != null)
                {
                    equipPanel.InitEquipItem();
                }
                break;
            default:
                equipPanel.gameObject.SetActive(false);
                break;
        }

        advanceType = info.type;
        curBaseId = info.baseId;
        ShowModelPanel.SetActive(true);
        if (gameObject.activeInHierarchy)
        {
            InitShowModel();
        }

        ShowEquipRedIcon();
        ShowInjectRedIcon();
    }

    private static string effectName = "effect";
    public void ShowAnimaion(int baseId)
    {
        animatonPanel.ShowAnimation(baseId);
    }

    public void InitShowModel()
    {
        StartCoroutine(InitShowModelCoroutine());
    }

    // 显示model
    IEnumerator InitShowModelCoroutine()
    {
        modelCameraTexture._CanDrag = AdvanceMountPanelCtr.Instance.m_AdvanceType == AdvanceBase.AdvanceType.Ride || AdvanceMountPanelCtr.Instance.m_AdvanceType == AdvanceBase.AdvanceType.Wing;
        switch (advanceType)
        {
            case (int)AdvanceBase.AdvanceType.Ride:
                {
                    int curMountId = GameManager.gameManager.PlayerDataPool.m_objMountParam.AutoFlagMountID;
                    if (curMountId < 0)
                    {
                        yield break;
                    }

                    Tab_AdvanceBase advanceBase = TableManager.GetAdvanceBaseByID(curMountId, 0);
                    if (advanceBase == null)
                    {
                        //穿戴时装 这边不好处理 先显示当前进阶的等级
                        advanceBase = TableManager.GetAdvanceBaseByID(curBaseId, 0);
                        if(advanceBase == null)
                        {
                            modelCameraTexture.gameObject.SetActive(false);
                            yield break;
                        }
                        //时装
                    }
                    Tab_MountBase mountBase = TableManager.GetMountBaseByID(advanceBase.ShowModelId, 0);

                    if (mountBase == null)
                    {
                        modelCameraTexture.gameObject.SetActive(false); 
                        yield break;
                    }

                    // 坐骑模型资源数据
                    Tab_CharMount charMount = TableManager.GetCharMountByID(mountBase.ModelID, 0);
                    if (charMount == null) 
                    {
                        modelCameraTexture.gameObject.SetActive(false);
                        yield break;
                    }
                    modelCameraTexture.InitMountModelPath(charMount, delegate() {
                        modelCameraTexture.gameObject.SetActive(true);
                    });
                    modelNameText.text = mountBase.Name;
                    stageText.text = GCGame.Utils.GetGradeString(advanceBase.Grade);
                    curAdvanceBaseLevel = advanceBase.Level;
                    curAdcanceBaseGrade = advanceBase.Grade;
                }
                break;
            case (int)AdvanceBase.AdvanceType.Wing:
                {
                    Tab_AdvanceBase advanceBase = null; 
                    if (GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.AdvanceWingId > 0)
                    {
                        advanceBase = TableManager.GetAdvanceBaseByID(GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.AdvanceWingId, 0);
                    }
                    
                    if (advanceBase == null)
                    {
                        advanceBase = TableManager.GetAdvanceBaseByID(curBaseId, 0);
                    }

                    if(advanceBase == null)
                    {
                        modelCameraTexture.gameObject.SetActive(false);
                        yield break;
                    }

                    modelCameraTexture.InitWingModelPath(advanceBase, null ,delegate ()
                    {
                        modelCameraTexture._CameraPrefab.GetComponent<Camera>().orthographicSize = 1.3f;
                        modelCameraTexture.gameObject.SetActive(true);
                    });
                    modelNameText.text = advanceBase.Name;

                    stageText.text = GCGame.Utils.GetGradeString(advanceBase.Grade);
                    curAdvanceBaseLevel = advanceBase.Level;
                    curAdcanceBaseGrade = advanceBase.Grade;

                }
                break;
            default:
                {
                    Tab_AdvanceBase advanceBase = null;
                    switch (AdvanceMountPanelCtr.Instance.m_AdvanceType)
                    {
                        case AdvanceBase.AdvanceType.Piano:
                            advanceBase = TableManager.GetAdvanceBaseByID(GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.AdvanceGodweaponId, 0);
                            break;
                        case AdvanceBase.AdvanceType.Qilinbi:
                            advanceBase = TableManager.GetAdvanceBaseByID(GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.AdvanceWishId, 0);
                            break;
                        case AdvanceBase.AdvanceType.Mask:
                            advanceBase = TableManager.GetAdvanceBaseByID(GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.AdvanceMaskId, 0);
                            break;
                        case AdvanceBase.AdvanceType.Soul:
                            advanceBase = TableManager.GetAdvanceBaseByID(GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.AdvanceSealId, 0);
                            break;
                        case AdvanceBase.AdvanceType.Huopao:
                            advanceBase = TableManager.GetAdvanceBaseByID(GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.AdvanceCrownId, 0);
                            break;
                    }
                    if(advanceBase == null)
                    {
                        advanceBase = TableManager.GetAdvanceBaseByID(curBaseId, 0);
                        if(advanceBase == null)
                        {
                            modelCameraTexture.gameObject.SetActive(false);
                            yield break;
                        }
                    }
                    Tab_CharModel charModel = TableManager.GetCharModelByID(advanceBase.ShowModelId, 0);
                    if(charModel != null)
                    {
                        modelCameraTexture.InitModelPath(charModel.ResPath, charModel, LoadAssetBundle.BUNDLE_PATH_MODEL, true, delegate() {
                            modelCameraTexture._CameraPrefab.GetComponent<Camera>().orthographicSize = 1.3f;
                            modelCameraTexture.gameObject.SetActive(true);
                        });
                    }
                    modelNameText.text = advanceBase.Name;

                    stageText.text = GCGame.Utils.GetGradeString(advanceBase.Grade);
                    curAdvanceBaseLevel = advanceBase.Level;
                    curAdcanceBaseGrade = advanceBase.Grade;

                }
                yield break;
        }
    }

    public void RefreshShowInfo(AdvanceRetInfo info)
    {
        int baseId = (info.type + 1) * 1000 + info.level;
        Tab_AdvanceBase advanceBase = TableManager.GetAdvanceBaseByID(baseId, 0);
        if(advanceBase == null)
        {
            return;
        }
        curAdvanceBaseLevel = info.level;
        curAdcanceBaseGrade = advanceBase.Grade;
    }

    // 刷新当前的技能信息
    public void RefreshSkillInfo(int oldSkillId, int newSkillId)
    {
        skillPanel.RefreshSkillPanel(oldSkillId, newSkillId, curBaseId);
    }

    public void ShowEquipRedIcon()
    {
        if (equipPanel.gameObject.activeInHierarchy)  //坐骑装备
        {
            List<GameItem> itemList = ItemTool.ItemFilter(GameManager.gameManager.PlayerDataPool.BackPack, 0);
            for (int index = 0; index < equipPanel.equipItemList.Count; index++)
            {
                AdvanceEquipItem equipCS = equipPanel.equipItemList[index].GetComponent<AdvanceEquipItem>();

                bool hasFind = false;

                // 只需和当前的比较，只要出现更好的装备，即显示红点并退出。
                int curCombatValue = -1;

                // 根据槽位获得装备
                if (equipCS.curItemDataId != -1)
                {
                    GameItem item = GameManager.gameManager.PlayerDataPool.AdvancePack.GetItem(index);
                    curCombatValue = TableManager.GetAdvanceEquipByID(item.DataID, 0).CombatValue;
                }

                for (int itemIndex = 0; itemIndex < itemList.Count; itemIndex++)
                {
                    GameItem item = itemList[itemIndex];

                    Tab_AdvanceEquip advanceEquip = TableManager.GetAdvanceEquipByID(item.DataID, 0);
                    if (advanceEquip == null)
                    {
                        continue;
                    }

                    if (item.GetClass() == (int)ItemClass.ADVANCEEQUIP
                        && advanceEquip.Index == (int)equipCS.curAdvanceEquipSlotType
                        && equipCS.CanEquipThisEquip(item))
                    {
                        // 找到第一个装备更好的就退出。
                        if (advanceEquip.CombatValue > curCombatValue)
                        {
                            hasFind = true;
                            //if (AdvanceMountPanelCtr.Instance != null)
                            //{
                            //    AdvanceMountPanelCtr.Instance.UpdateRedPoint(0, true);
                            //}

                            equipPanel.equipItemList[index].GetComponent<AdvanceEquipItem>().ShowOrHideRedIcon(true);
                            break;
                        }
                    }
                }
                if (!hasFind)
                {
                    equipPanel.equipItemList[index].GetComponent<AdvanceEquipItem>().ShowOrHideRedIcon(false);
                }
            }
        }
    }

    public void ShowInjectRedIcon()
    {
        GameItemContainer backPack = GameManager.gameManager.PlayerDataPool.BackPack;
        if (attrPanel.soulDanLimitCount != -1 && attrPanel.soulDanHasUsedCount < attrPanel.soulDanLimitCount)
        {
            attrPanel.soulDanRedIcon.gameObject.SetActive(backPack.GetItemCountByDataId(attrPanel.soulDanItemId) > 0 ? true : false);
            //if (AdvanceMountPanelCtr.Instance != null)
            //{
            //    AdvanceMountPanelCtr.Instance.UpdateRedPoint(0, true);
            //}
        }
        else
        {
            attrPanel.soulDanRedIcon.gameObject.SetActive(false);
        }

        if (attrPanel.spiritualDanLimitCount != -1 && attrPanel.spiritualDanHasUsedCount < attrPanel.spiritualDanLimitCount)
        {
            attrPanel.spiritDanRedIcon.gameObject.SetActive(backPack.GetItemCountByDataId(attrPanel.spiritualDanItemId) > 0 ? true : false);
            //if (AdvanceMountPanelCtr.Instance != null)
            //{
            //    AdvanceMountPanelCtr.Instance.UpdateRedPoint(0, true);
            //}
        }
        else
        {
            attrPanel.spiritDanRedIcon.gameObject.SetActive(false);
        }
    }

    /// <summary>
    /// 检测AdvanceShow界面是否有红点在显示
    /// </summary>
    /// <returns></returns>
    public bool hasRedPoint()
    {
        if(AdvanceMountPanelCtr.Instance.showPanel.gameObject.activeInHierarchy)
        {
            // 装备栏
            for (int i = 0; i < equipPanel.equipItemList.Count; i++)
            {
                if (equipPanel.equipItemList[i].IsShowingRedPoint() == true)
                {
                    return true;
                }
            }

            // 注灵、注魂
            if (attrPanel.soulDanRedIcon.gameObject.activeSelf == true)
            {
                return true;
            }

            if (attrPanel.spiritDanRedIcon.gameObject.activeSelf == true)
            {
                return true;
            }

            // 技能
            for (int i = 0; i < skillPanel.skillItemList.Count; ++i)
            {
                if (skillPanel.skillItemList[i].IsShowingRedIcon() == true)
                {
                    return true;
                }
            }
        }
        else
        {
            if (HasRedPoint(AdvanceMountPanelCtr.Instance.m_AdvanceType))
            {
                return true;
            }
        }

        return false;
    }

    /// <summary>
    /// 检测进阶数据的装备、注灵、注魂、技能的红点情况
    /// </summary>
    /// <param name="adType">进阶类型</param>
    /// <returns>true代表存在红点，false代表无红点</returns>
    public static bool HasRedPoint(AdvanceBase.AdvanceType adType)
    {

        #region 当Advance界面在显示时，直接统计红点数目


        AdvanceInfo adInfo;
        GameManager.gameManager.PlayerDataPool.m_AdvanceData.AdvanceDataDic.TryGetValue((int)adType, out adInfo);
        // 不存在数据，或未开启该进阶
        if (adInfo == null || adInfo.level <= 0)
        {
            return false;
        }

        // 坐骑装备
        List<GameItem> itemList = ItemTool.ItemFilter(GameManager.gameManager.PlayerDataPool.BackPack, 0);
        GameItemContainer _ContainerPack = GameManager.gameManager.PlayerDataPool.AdvancePack;

        for (int index = 0; index < _ContainerPack.ContainerSize; ++index)
        {
            //AdvanceEquipItem equipCS = equipPanel.equipItemList[index].GetComponent<AdvanceEquipItem>();

            // 只需和当前的比较，只要出现更好的装备，即显示红点并退出。
            int curCombatValue = -1;
            GameItem curEquip = _ContainerPack.GetItem(index);
            Tab_AdvanceEquip advanceEquip = TableManager.GetAdvanceEquipByID(curEquip.DataID, 0);
            if (advanceEquip != null)
            {
                curCombatValue = advanceEquip.CombatValue;
            }

            for (int itemIndex = 0; itemIndex < itemList.Count; itemIndex++)
            {
                GameItem item = itemList[itemIndex];

                Tab_AdvanceEquip bp_advanceEquip = TableManager.GetAdvanceEquipByID(item.DataID, 0);
                if (advanceEquip == null)
                {
                    continue;
                }

                if (item.GetClass() == (int)ItemClass.ADVANCEEQUIP
                    && bp_advanceEquip.Index == index
                    && CanEquipThisEquip(item.DataID, AdvanceBase.AdvanceType.Ride))
                {
                    // 找到第一个装备更好的就退出。
                    if (advanceEquip.CombatValue > curCombatValue)
                    {
                        return true;
                    }
                }
            }
        }

        // 魂丹/魂灵
        GameItemContainer backPack = GameManager.gameManager.PlayerDataPool.BackPack;
        Tab_AdvanceOther other = TableManager.GetAdvanceOtherByID((int)adType, 0);

        if (other != null)
        {
            Tab_AdvanceBase advanceBase = TableManager.GetAdvanceBaseByID(adInfo.baseId, 0);
            if (advanceBase != null)
            {
                int soulDanLimitCount = advanceBase.SoulDanLimit;
                int spiritualDanLimitCount = advanceBase.SpiritDanLimit;
                int soulDanItemId = other.SoulItemId;
                int spiritualDanItemId = other.SpiritItemId;

                if (soulDanLimitCount != -1 && adInfo.SoulDan < soulDanLimitCount)
                {
                    if (backPack.GetItemCountByDataId(soulDanItemId) > 0)
                    {
                        return true;
                    }
                }

                if (spiritualDanLimitCount != -1 && adInfo.SpiritDan < spiritualDanLimitCount)
                {
                    if (backPack.GetItemCountByDataId(spiritualDanItemId) > 0)
                    {
                        return true;
                    }
                }
            }
        }

        // 技能
        if (adInfo.skillId != null)
        {
            Tab_AdvanceBase tab_adBase = TableManager.GetAdvanceBaseByID(adInfo.baseId, 0);

            for (int i = 0; i < 5; ++i)
            {
                var isNull = true;
                for (int j = 0; j < adInfo.skillId.Count; ++j)
                {
                    Tab_AdvanceSkill advanceSkill = TableManager.GetAdvanceSkillByID(adInfo.skillId[j], 0);
                    if (advanceSkill != null)
                    {
                        if (CanSkillLevelUp(adInfo.skillId[j], tab_adBase.Grade))
                        {
                            return true;
                        }
                        isNull = false;
                    }
                }

                if (!isNull)
                    continue;

                var temp_SkillDic = TypeOriginSkillDic(adType);
                if (CanSkillLevelUp(temp_SkillDic[i], tab_adBase.Grade))
                {
                    return true;
                }
            }
        }

        #endregion

        return false;
    }

    /// <summary>
    /// 检测进阶装备能否穿戴
    /// </summary>
    /// <param name="itemId">物品id</param>
    /// <param name="advanceType">物品的进阶类型</param>
    /// <returns></returns>
    public static bool CanEquipThisEquip(int itemId, AdvanceBase.AdvanceType advanceType)
    {
        Tab_AdvanceEquip advanceEquip = TableManager.GetAdvanceEquipByID(itemId, 0);
        if (advanceEquip == null)
        {
            return false;
        }

        if(AdvanceMountPanelCtr.Instance == null)
        {
            return false;
        }

        switch (advanceType)
        {
            case AdvanceBase.AdvanceType.Ride:
                if (advanceEquip.NeedAdvanceLevel <= AdvanceMountPanelCtr.Instance.showPanel.curAdvanceBaseLevel
                    && advanceEquip.NeedSoulDan <= AdvanceMountPanelCtr.Instance.showPanel.curAdvanceServerLevel)
                {
                    return true;
                }
                return false;
        }

        return false;
    }

    /// <summary>
    /// 检测进阶技能否升级
    /// </summary>
    /// <param name="skillId">进阶技能Tab_AdvanceSkill.id</param>
    /// <param name="grade">进阶项的阶级</param>
    /// <returns></returns>
    public static bool CanSkillLevelUp(int skillId, int grade)
    {
        Tab_AdvanceSkill curAdvanceBaseSkill = TableManager.GetAdvanceSkillByID(skillId, 0);
        if (curAdvanceBaseSkill == null)
        {
            return false;
        }

        Tab_AdvanceSkill nextAdvanceBaseSkill = TableManager.GetAdvanceSkillByID(curAdvanceBaseSkill.NextSkillExId, 0);
        if (nextAdvanceBaseSkill == null)
        {
            return false;
        }

        GameItemContainer bagPack = GameManager.gameManager.PlayerDataPool.GetItemContainer(GameItemContainer.Type.TYPE_BACKPACK);
        if (bagPack == null)
        {
            return false;
        }

        int ownItemCount = bagPack.GetItemCountByDataId(nextAdvanceBaseSkill.CostItemId);
        if ((ownItemCount >= nextAdvanceBaseSkill.CostItemNum) && grade >= nextAdvanceBaseSkill.NeedAdvanceLevel)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    // Dictionary<进阶类型, Dictionary<技能槽位, 技能id>> typeOriginSkillDic；
    private static Dictionary<int, Dictionary<int, int>> typeOriginSkillDic;
    public static Dictionary<int, int> TypeOriginSkillDic(AdvanceBase.AdvanceType adType)
    {
        if(typeOriginSkillDic == null)
        {
            GetTypeOriginSkillDic();
        }

        return typeOriginSkillDic[(int)adType];
    }

    /// <summary>
    ///  获得type类型的所有初始化的技能
    /// </summary>
    /// <param name="type">进阶类型</param>
    private static void GetTypeOriginSkillDic()
    {
        typeOriginSkillDic = new Dictionary<int, Dictionary<int, int>>();
        var allSkillDic = TableManager.GetAdvanceSkill().Values;
        foreach (var skillInfo in allSkillDic)
        {
            if(!typeOriginSkillDic.ContainsKey(skillInfo.Type))
            {
                Dictionary<int, int> new_skillDic = new Dictionary<int, int>();
                typeOriginSkillDic.Add(skillInfo.Type, new_skillDic);
            }

            Dictionary<int, int> skillDic = typeOriginSkillDic[skillInfo.Type];
            if (skillDic.ContainsKey(skillInfo.Index)
                && skillInfo.SkillLevel == 0
                && skillInfo.NeedCareer == GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Profession)
            {
                skillDic[skillInfo.Index] = skillInfo.Id;
            }
            else
            {
                if (skillInfo.SkillLevel == 0
                    && skillInfo.NeedCareer == GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Profession)
                {
                    skillDic.Add(skillInfo.Index, skillInfo.Id);
                }
            }
        }
    }

    public void InitToggleState()
    {
        var mainPlayer = Singleton<ObjManager>.Instance.MainPlayer;
        if (mainPlayer && _ShowWingToggle)
            _ShowWingMark.SetActive(mainPlayer.IsShowWing);
    }

    public void OnShowWingBtn()
    {
        var mainPlayer = Singleton<ObjManager>.Instance.MainPlayer;
        if(mainPlayer)
        {
            _ShowWingMark.SetActive(!mainPlayer.IsShowWing);

            CG_REQ_SET_WING_SHOW_FLAG req = (CG_REQ_SET_WING_SHOW_FLAG)PacketDistributed.CreatePacket(MessageID.PACKET_CG_REQ_SET_WING_SHOW_FLAG);
            req.Flag = mainPlayer.IsShowWing ? 0 : 1;  //每次取反
            req.SendPacket();
        }
    }


    //垃圾Toggle
    /// <summary>
    /// 是否显示人物翅膀
    /// </summary>
    /// <param name="isOn"></param>
    //public void OnShowWingToggleOn(bool isOn)
    //{
    //    CG_REQ_SET_WING_SHOW_FLAG req = (CG_REQ_SET_WING_SHOW_FLAG)PacketDistributed.CreatePacket(MessageID.PACKET_CG_REQ_SET_WING_SHOW_FLAG);
    //    req.Flag = isOn ? 1 : 0;
    //    req.SendPacket();
    //}
}