//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Saturday, October 14, 2017
//--------------------------------------------------------

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using Snxxz.UI;

public class TargetBriefInfo
{
    public static PlayerInfo playerInfo { get; private set; }
    public static MonsterInfo bossInfo { get; private set; }

    public static void Init()
    {
        GA_NpcFightBoss.s_OnSelect += OnShowBossLifeBar;
        GA_NpcFightBoss.s_HpRefresh += OnRefreshBossLifeBar;

        GA_NpcClientFightBoss.s_OnSelect += OnShowBossLifeBar;
        GA_NpcClientFightBoss.s_HpRefresh += OnRefreshBossLifeBar;

        GA_Player.s_OnRefreshLife += OnRefreshPlayerLifeBar;
        GA_Player.s_OnSelected += OnShowPlayerLifeBar;
    }

    static void OnShowBossLifeBar(uint _instanceId, int _npcId, bool _show)
    {
        if (CrossServerUtility.IsCrossServerOneVsOne() && _show)
        {
            return;
        }

        if (_show)
        {
            var boss = GAMgr.Instance.GetBySID(_instanceId) as GActorNpcFight;
            if (boss != null)
            {
                bossInfo = new MonsterInfo()
                {
                    instanceId = _instanceId,
                    npcId = _npcId,
                    hp = boss.ActorInfo.RealHp,
                    maxHp = boss.ActorInfo.RealMaxHp,
                    level = boss.ActorInfo.LV
                };
            }
            else
            {
                bossInfo = default(MonsterInfo);
            }

            playerInfo = default(PlayerInfo);
        }
        else
        {
            if (bossInfo.instanceId == _instanceId)
            {
                bossInfo = default(MonsterInfo);
            }
        }

        var mapId = PlayerDatas.Instance.baseData.MapID;
        var dataMapId = MapUtility.GetDataMapId(mapId);
        if (dataMapId == DemonJarModel.DEMONJAR_MAPID
            || dataMapId == JadeDynastyBossModel.JADEDYNASTY_MAP
            || dataMapId == JadeDynastyTowerModel.DATA_MAPID)
        {
            if (_show)
            {
                WindowCenter.Instance.Open<DemonJarBossLifeBarWin>();
            }
        }
        else
        {
            WindowCenter.Instance.Open<TargetBriefInfoWin>();
        }

    }

    public static void OnRefreshBossLifeBar(uint _instanceId, int _npcId, ulong _hp, ulong _maxHp)
    {
        if (CrossServerUtility.IsCrossServerOneVsOne())
        {
            return;
        }

        playerInfo = default(PlayerInfo);
        var boss = GAMgr.Instance.GetBySID(_instanceId) as GActorNpcFight;
        if (boss != null)
        {
            bossInfo = new MonsterInfo()
            {
                instanceId = _instanceId,
                npcId = _npcId,
                hp = _hp,
                maxHp = _maxHp,
                level = boss.ActorInfo.LV
            };
        }
        else
        {
            bossInfo = default(MonsterInfo);
        }

        var mapId = PlayerDatas.Instance.baseData.MapID;
        var dataMapId = MapUtility.GetDataMapId(mapId);
        if (dataMapId == DemonJarModel.DEMONJAR_MAPID
            || dataMapId == JadeDynastyBossModel.JADEDYNASTY_MAP
            || dataMapId == JadeDynastyTowerModel.DATA_MAPID)
        {
            if (!WindowCenter.Instance.IsOpen("DemonJarBossLifeBarWin"))
            {
                WindowCenter.Instance.Open<DemonJarBossLifeBarWin>();
            }
        }
        else
        {
            if (!WindowCenter.Instance.IsOpen("TargetBriefInfoWin"))
            {
                WindowCenter.Instance.Open<TargetBriefInfoWin>(true);
            }
        }

    }

    static void OnShowPlayerLifeBar(uint _instanceId, bool _show)
    {
        if (CrossServerUtility.IsCrossServerOneVsOne() && _show)
        {
            return;
        }

        if (_show)
        {
            var player = GAMgr.Instance.GetBySID(_instanceId) as GActorPlayerBase;
            if (player != null)
            {
                playerInfo = new PlayerInfo()
                {
                    instanceId = _instanceId,
                    job = player.ActorInfo.Job,
                    name = player.ActorInfo.PlayerName,
                    level = player.ActorInfo.LV,
                    hp = player.ActorInfo.RealHp,
                    maxHp = player.ActorInfo.RealMaxHp
                };
            }
            else
            {
                playerInfo = default(PlayerInfo);
            }

            bossInfo = default(MonsterInfo);
        }
        else
        {
            if (playerInfo.instanceId == _instanceId)
            {
                playerInfo = default(PlayerInfo);
            }
        }

        if (WindowCenter.Instance.IsOpen("DemonJarBossLifeBarWin"))
        {
            WindowCenter.Instance.Close<DemonJarBossLifeBarWin>();
        }

        WindowCenter.Instance.Open<TargetBriefInfoWin>(true);
    }

    static void OnRefreshPlayerLifeBar(uint _instanceId, ulong _hp, ulong _maxHp)
    {
        if (CrossServerUtility.IsCrossServerOneVsOne())
        {
            return;
        }

        bossInfo = default(MonsterInfo);
        var player = GAMgr.Instance.GetBySID(_instanceId) as GActorPlayerBase;
        if (player != null)
        {
            playerInfo = new PlayerInfo()
            {
                instanceId = _instanceId,
                job = player.ActorInfo.Job,
                name = player.ActorInfo.PlayerName,
                level = player.ActorInfo.LV,
                hp = player.ActorInfo.RealHp,
                maxHp = player.ActorInfo.RealMaxHp
            };
        }
        else
        {
            playerInfo = default(PlayerInfo);
        }

        if (!WindowCenter.Instance.IsOpen<TargetBriefInfoWin>())
        {
            WindowCenter.Instance.Open<TargetBriefInfoWin>(true);
        }
    }

    public struct MonsterInfo
    {
        public uint instanceId;
        public int npcId;
        public ulong hp;
        public ulong maxHp;
        public int level;

        public static bool operator ==(MonsterInfo lhs, MonsterInfo rhs)
        {
            return lhs.instanceId == rhs.instanceId
                && lhs.npcId == rhs.npcId
                && lhs.hp == rhs.hp
                && lhs.maxHp == rhs.maxHp
                && lhs.level == rhs.level;
        }

        public static bool operator !=(MonsterInfo lhs, MonsterInfo rhs)
        {
            return lhs.instanceId != rhs.instanceId
                || lhs.npcId != rhs.npcId
                || lhs.hp != rhs.hp
                || lhs.maxHp != rhs.maxHp
                || lhs.level != rhs.level;
        }
    }

    public struct PlayerInfo
    {
        public uint instanceId;
        public ulong hp;
        public ulong maxHp;

        public int job;
        public int level;
        public string name;

        public static bool operator ==(PlayerInfo lhs, PlayerInfo rhs)
        {
            return lhs.instanceId == rhs.instanceId
                && lhs.hp == rhs.hp
                && lhs.maxHp == rhs.maxHp
                && lhs.job == rhs.job
                && lhs.level == rhs.level
                && lhs.name == rhs.name;
        }

        public static bool operator !=(PlayerInfo lhs, PlayerInfo rhs)
        {
            return lhs.instanceId != rhs.instanceId
                || lhs.hp != rhs.hp
                || lhs.maxHp != rhs.maxHp
                || lhs.job != rhs.job
                || lhs.level != rhs.level
                || lhs.name != rhs.name;
        }
    }

}

namespace Snxxz.UI
{

    public class TargetBriefInfoWin : Window
    {
        [SerializeField] Transform m_ContainerBoss;
        [SerializeField] BossLifeBar m_BossLifeBar;
        [SerializeField] ElderGodAngerBehaviour m_ElderGodAnger;
        [SerializeField] Transform m_ContainerPlayer;
        [SerializeField] PlayerLifeBar m_PlayerLifeBar;
        [SerializeField] FairyGrabBossBuffTip m_FairyGrabBossBuffTip;

        TargetBriefInfo.PlayerInfo playerInfo;
        TargetBriefInfo.MonsterInfo bossInfo;

        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
        }

        protected override void OnPreOpen()
        {
            m_ContainerBoss.gameObject.SetActive(false);
            m_ContainerPlayer.gameObject.SetActive(false);
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
        }

        protected override void OnAfterClose()
        {
        }

        protected override void OnActived()
        {
            base.OnActived();

            this.transform.SetAsFirstSibling();

            playerInfo = TargetBriefInfo.playerInfo;
            bossInfo = TargetBriefInfo.bossInfo;

            if (playerInfo.instanceId != 0)
            {
                ShowPlayerLifeBar(playerInfo, true);
            }
            else
            {
                ShowPlayerLifeBar(playerInfo, false);

                if (bossInfo.instanceId != 0)
                {
                    ShowBossLifeBar(bossInfo, true);
                }
                else
                {
                    ShowBossLifeBar(bossInfo, false);
                }
            }
        }

        protected override void LateUpdate()
        {
            base.LateUpdate();

            if (TargetBriefInfo.bossInfo != bossInfo)
            {
                if (TargetBriefInfo.bossInfo.instanceId == 0)
                {
                    ShowBossLifeBar(TargetBriefInfo.bossInfo, false);
                }
                else
                {
                    if (bossInfo.npcId != TargetBriefInfo.bossInfo.npcId)
                    {
                        ShowBossLifeBar(TargetBriefInfo.bossInfo, true);
                    }
                    else
                    {
                        RefreshBossLifeBar(TargetBriefInfo.bossInfo);
                    }
                }

                bossInfo = TargetBriefInfo.bossInfo;
            }

            if (TargetBriefInfo.playerInfo != playerInfo)
            {
                if (TargetBriefInfo.playerInfo.instanceId == 0)
                {
                    ShowPlayerLifeBar(TargetBriefInfo.playerInfo, false);
                }
                else
                {
                    if (playerInfo.instanceId != TargetBriefInfo.playerInfo.instanceId)
                    {
                        ShowPlayerLifeBar(TargetBriefInfo.playerInfo, true);
                    }
                    else
                    {
                        RefreshPlayerLifeBar(TargetBriefInfo.playerInfo);
                    }
                }

                playerInfo = TargetBriefInfo.playerInfo;
            }

        }

        #endregion

        void ShowBossLifeBar(TargetBriefInfo.MonsterInfo bossInfo, bool show)
        {
            if (show)
            {
                m_ContainerPlayer.gameObject.SetActive(false);
                m_ContainerBoss.gameObject.SetActive(true);
                m_FairyGrabBossBuffTip.Init();

                m_BossLifeBar.SetBaseInfo(bossInfo.npcId, bossInfo.hp, bossInfo.maxHp, bossInfo.level);
                m_ElderGodAnger.Display(bossInfo.npcId);
                m_FairyGrabBossBuffTip.Display(bossInfo.npcId);
            }
            else
            {
                m_ContainerBoss.gameObject.SetActive(false);
                m_FairyGrabBossBuffTip.UnInit();
            }
        }

        void RefreshBossLifeBar(TargetBriefInfo.MonsterInfo bossInfo)
        {
            m_ContainerBoss.gameObject.SetActive(true);
            m_BossLifeBar.Show(bossInfo.hp, bossInfo.maxHp);
        }

        void ShowPlayerLifeBar(TargetBriefInfo.PlayerInfo playerInfo, bool show)
        {
            if (show)
            {
                m_ContainerPlayer.gameObject.SetActive(true);
                m_ContainerBoss.gameObject.SetActive(false);
                m_FairyGrabBossBuffTip.UnInit();

                var instanceId = playerInfo.instanceId;
                var job = playerInfo.job;
                var playerName = playerInfo.name;
                var playerLevel = playerInfo.level;
                var playerHp = playerInfo.hp;
                var playerMaxHp = playerInfo.maxHp;

                m_PlayerLifeBar.SetBaseInfo((int)instanceId, job, 0, playerName, playerLevel, playerHp, playerMaxHp);
            }
            else
            {
                m_ContainerPlayer.gameObject.SetActive(false);
            }

        }

        void RefreshPlayerLifeBar(TargetBriefInfo.PlayerInfo playerInfo)
        {
            m_ContainerPlayer.gameObject.SetActive(true);
            m_PlayerLifeBar.Show(playerInfo.hp, playerInfo.maxHp);
        }

    }

}