using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;

namespace YLBattle
{
    /// <summary>
    ///  逻辑管理（操作）
    /// </summary>
    public partial class LogicFighterManager : ILogicFighterOper
    {
        /// <summary>
        /// 寻求朋友帮助
        /// </summary>
        /// <param name="seat"></param>
        /// <param name="whodead"></param>
        public void SetFriendHelp(int seat, bool isShowTip = false)
        {
            HeroAdapter friend = this.Env().friend as HeroAdapter;
            friend.Seat = seat; //占位设置
            LogicFighter fighter = new LogicFighter();
            ///索引设定为当前己方最大人数+1
            int maxindex = this.Env().mLogicFighterOper.FindTeamAllFighter(EBattleTeam.BLUETEAM).Count;
            string id = (maxindex + 1).ToString();
            ///占位为死亡占位
            fighter.SetData(id, this.Env(), friend, EBattleTeam.BLUETEAM, seat);
            this.Env().ShowAdapter().CreatLogicFighter(id, EBattleTeam.BLUETEAM, this.Env().levelMode, friend, true);
            this.mFighters.Add(fighter.ID(), fighter);
            this.mFriendFighters.Add(seat, fighter);
            this.Env().friend = null; //清空好友支援数据

            if (isShowTip)
            {
                this.Env().ShowAdapter().OnFriendSupportTip(friend.TID());
            }

            //LogHelper.Log("GetFriendHelp...............seat=" + seat + " name=" + friend.FName());
        }

        /// <summary>
        /// 查找指定战斗对象
        /// </summary>
        /// <param name="id">对象唯一编号</param>
        /// <returns>目标</returns>
        public LogicFighter FindFighter(string id)
        {
            if (mFighters.ContainsKey(id))
            {
                return mFighters[id];
            }
            return null;
        }
        /// <summary>
        /// 获取指定队伍目前存活人员
        /// </summary>
        /// <param name="team">队伍描述</param>
        /// <returns>人员列表</returns>
        public List<LogicFighter> FindFighter()
        {
            List<LogicFighter> all = new List<LogicFighter>();

            foreach (KeyValuePair<string, LogicFighter> kv in this.mFighters)
            {
                all.Add(kv.Value);
            }

            return all;
        }

        /// <summary>
        /// 获取指定队伍目前存活人员
        /// </summary>
        /// <param name="team">队伍描述</param>
        /// <returns>人员列表</returns>
        public List<LogicFighter> FindAliveFighter()
        {
            List<LogicFighter> all = new List<LogicFighter>();

            foreach (KeyValuePair<string, LogicFighter> kv in this.mFighters)
            {
                if (kv.Value.IsDead() == true)
                {
                    continue;
                }

                all.Add(kv.Value);
            }

            return all;
        }

        /// <summary>
        /// 获取指定队伍目前存活人员
        /// </summary>
        /// <param name="team">队伍描述</param>
        /// <returns>人员列表</returns>
        public List<LogicFighter> FindTeamAliveFighter(EBattleTeam team)
        {
            List<LogicFighter> all = new List<LogicFighter>();

            foreach (KeyValuePair<string, LogicFighter> kv in this.mFighters)
            {
                if (kv.Value.Team() != team)
                {
                    continue;
                }

                if (kv.Value.IsDead() == true)
                {
                    continue;
                }

                all.Add(kv.Value);
            }

            return all;
        }

        /// <summary>
        /// 获取指定角色的敌人队伍存活列表
        /// </summary>
        /// <param name="id">参照对象编号</param>
        /// <returns>敌方存活角色列表</returns>
        public List<LogicFighter> FindEnemyTeam(string id)
        {
            LogicFighter who = this.FindFighter(id);
            EBattleTeam team = who.Team();
            

            return this.FindTeamAliveFighter(team);
        }

        /// <summary>
        /// 获取指定角色的友方队伍存活列表
        /// </summary>
        /// <param name="id">参照对象编号</param>
        /// <returns>友方存活角色列表,包含自己</returns>
        public List<LogicFighter> FindFriendTeam(string id)
        {
            LogicFighter who = this.FindFighter(id);

            EBattleTeam team = who.Team();

           
            return this.FindTeamAliveFighter(team);
        }

        /// <summary>
        /// 根据站位查找fighter
        /// </summary>
        /// <param name="_seat">指定占位</param>
        /// <param name="team">所属队列</param>
        /// <returns></returns>
        public LogicFighter FindFighterBySeat(int _seat, EBattleTeam team)
        {
            LogicFighter target = null;
            List<LogicFighter> parter = this.FindTeamAliveFighter(team);
            foreach (LogicFighter fighter in parter)
            {
                if (fighter.Seat() == _seat)
                {
                    target = fighter;
                    break;
                }
            }
            return target;
        }

        /// <summary>
        /// 查找与目标指定关系的对象列表
        /// </summary>
        /// <param name="id">参照对象编号</param>
        /// <param name="relation">关系过滤</param>
        /// <returns>对象列表</returns>
        public List<LogicFighter> FindRelationAliveFighters(string id, EBattleRelation relation)
        {
            List<LogicFighter> result = new List<LogicFighter>();
            LogicFighter who = this.FindFighter(id);
            if (null == who)
            {
                return null;
            }

            foreach (KeyValuePair<string, LogicFighter> kv in this.mFighters)
            {
                if (kv.Value.ID() == id)
                {
                    continue;
                }

                if (kv.Value.IsDead())
                {
                    continue;
                }

                switch (relation)
                {
                    case EBattleRelation.EBATTLE_RELATION_NONE:
                        result.Add(kv.Value);
                        break;
                    case EBattleRelation.EBATTLE_RELATION_ENEMY:
                        {
                            if (EBattleRelation.EBATTLE_RELATION_ENEMY == who.Relation(kv.Value))
                            {
                                result.Add(kv.Value);
                            }
                        }

                        break;
                    case EBattleRelation.EBATTLE_RELATION_FRIEND:
                        {
                            if (EBattleRelation.EBATTLE_RELATION_FRIEND == who.Relation(kv.Value))
                            {
                                result.Add(kv.Value);
                            }
                        }

                        break;
                }
            }

            return result;
        }

        /// <summary>
        /// 获得当前存活的按攻击速度排序的所有人员
        /// </summary>
        /// <returns></returns>
        public List<LogicFighter> FindAliveSortFighter(EBattleTeam _team)
        {
            List<LogicFighter> all = new List<LogicFighter>();
            foreach (KeyValuePair<string, LogicFighter> kv in this.mFighters)
            {
                if (kv.Value.IsDead() == true)
                {
                    continue;
                }
                if (kv.Value.Team() != _team)
                {
                    continue;
                }
                all.Add(kv.Value);
            }
            Reverser<LogicFighter> reverser = new Reverser<LogicFighter>(Type.GetType("LogicFighter"), "AttackSpeed", ReverserInfo.Direction.ASC);
            all.Sort(reverser);

            return all;
        }


        //public List<LogicFighter> FindAliveFighterByLastAttackTime()
        //{
        //    List<LogicFighter> trgLst = this.FindAliveFighter();
        //    if (trgLst.Count > 0)
        //    {
        //        foreach (LogicFighter fighter in trgLst)
        //        {
        //            if (sombody == null)
        //            {
        //                sombody = fighter;
        //                continue;
        //            }
        //            int restTime1 = (int)(sombody.AttackSpeed - (this.Env().TimeCenter().Now() - sombody.LastAttackTime));
        //            int restTime2 = (int)(fighter.AttackSpeed - (this.Env().TimeCenter().Now() - fighter.LastAttackTime));
        //            if (restTime2 < restTime1)
        //            {
        //                sombody = fighter;
        //            }
        //        }
        //        if (sombody != null && sombody.Team() == EBattleTeam.REDTEAM)
        //        {
        //            sombody.GetState().ChangeState(BaseState.EFighterState.ROTATE, null);
        //        }
        //    }

        //    return trgLst;
        //}

        /// <summary>
        /// 获取指定队伍所有人员,不论生死
        /// </summary>
        /// <param name="team">目标队伍</param>
        /// <returns>对象列表</returns>
        public List<LogicFighter> FindTeamAllFighter(EBattleTeam team)
        {
            List<LogicFighter> all = new List<LogicFighter>();

            foreach (KeyValuePair<string, LogicFighter> kv in this.mFighters)
            {
                if (kv.Value.Team() == team)
                {
                    all.Add(kv.Value);
                }
            }

            return all;
        }

        /// <summary>
        /// 查找当前地图中间的人
        /// </summary>
        /// <param name="fighter">己方</param>
        /// <returns>敌方角色</returns>
        public LogicFighter FindCenterEnemy(string whoId, EBattleTeam _team)
        {
            #region ---------------------------2017-09-08 修正

            //EBattleTeam targetTeam = _team == EBattleTeam.BLUETEAM ? EBattleTeam.REDTEAM : EBattleTeam.BLUETEAM;
            //int seat = FightingMap.Instance.GetCenterSeat();

            //sombody = this.FindFighterBySeat(seat, targetTeam);

            //if (sombody == null)
            //{
            //    List<LogicFighter> trgLst = FindTeamAliveFighter(targetTeam);
            //    Reverser<LogicFighter> reverser = new Reverser<LogicFighter>(System.Type.GetType("LogicFighter"), "AttackSpeed", ReverserInfo.Direction.ASC);
            //    trgLst.Sort(reverser);
            //    if (trgLst.Count > 0)
            //    {
            //        sombody = trgLst[0];
            //        sombody.GetState().ChangeState(BaseState.EFighterState.ROTATE, null);
            //    }
            //}
            #endregion
            /**
             * 选取规则 （选择地图中间的人，己方假象也是地图圆盘）
             * 如果 Blue(Red)CurrentCenterAttacker 为空，则是第一次出手，则攻击占位索引依次为0->4的人(以此类推）
             * 如果 Blue(Red)CurrentCenterAttacker 不为空，则为上一次出手的角色（当前应该在地图中间位置）如果不为死亡，则选定为目标
             * 如果 Blue(Red)CurrentCenterAttacker 不为空，如果死亡，则对敌方队伍按“攻击速度”排序（下一个出手的应该是剩余时间最少的一个人）迭代选择
             */
            //----是否背叛。。。。。
            LogicFighter who = this.FindFighter(whoId);

            string targetId = _team == EBattleTeam.BLUETEAM ? this.Env().mRedCurrentCenterAttacker : this.Env().mBlueCurrentCenterAttacker;
            if (targetId != string.Empty)
            {
                LogicFighter f = this.FindFighter(targetId);
                if (f != null && !f.IsDead())
                {
                    //Debug.LogError(_team.ToString() + ":[" + who + "] 获取中线目标：" + targetId);
                    return f;
                }

            }
            if (targetId == string.Empty)
            {
                LogicFighter sombody = FindFighterBySeat(0, _team == EBattleTeam.BLUETEAM ? EBattleTeam.REDTEAM : EBattleTeam.BLUETEAM);
                if (sombody != null)
                {
                    return sombody;
                }
            }

            return this.OnUpdateMapCenterFighter(_team == EBattleTeam.BLUETEAM ? EBattleTeam.REDTEAM : EBattleTeam.BLUETEAM);

        }

        /// <summary>
        /// 刷新当前地图中间位置的角色
        /// </summary>
        /// <param name="_team">己方队伍</param>
        /// <returns>敌方角色</returns>
        public LogicFighter OnUpdateMapCenterFighter(EBattleTeam _team)
        {

            LogicFighter sombody = null;
            /**
    * 当前中心位置无角色，已死亡，按攻击速度找到下一个出手的角色，置为中心位置，并地图转向
    */
            List<LogicFighter> trgLst = FindTeamAliveFighter(_team);
            if (trgLst.Count > 0)
            {
                foreach (LogicFighter fighter in trgLst)
                {
                    if (sombody == null)
                    {
                        sombody = fighter;
                        continue;
                    }
                    int restTime1 = (int)(sombody.AttackSpeed - (this.Env().TimeCenter().Now() - sombody.LastAttackTime));
                    int restTime2 = (int)(fighter.AttackSpeed - (this.Env().TimeCenter().Now() - fighter.LastAttackTime));
                    if (restTime2 < restTime1)
                    {
                        sombody = fighter;
                    }
                }
                if (sombody != null && sombody.Team() == EBattleTeam.REDTEAM)
                {
                    sombody.GetState().ChangeState(BaseState.EFighterState.ROTATE, null);
                }
            }
            return sombody;

        }


        /// <summary>
        /// 禁用指定战斗对象
        /// </summary>
        /// <param name="id">角色编号</param>
        public void MarkDeathFighter(string id)
        {
            LogicFighter fighter = this.FindFighter(id);
            if (null == fighter)
            {
                return;
            }

            this.mDeathFighterss.Add(fighter);
        }

        /// <summary>
        /// 从死亡列表中移除指定对象
        /// </summary>
        /// <param name="id">对象id</param>
        public void RemoveFighterFromDeath(string id)
        {
            LogicFighter fighter = null;
            for (int i = 0; i < this.mDeathFighterss.Count; ++i)
            {
                if (this.mDeathFighterss[i].ID() == id)
                {
                    fighter = this.mDeathFighterss[i];
                    break;
                }
            }

            if (null != fighter)
            {
                this.mDeathFighterss.Remove(fighter);
            }
        }

        /// <summary>
        /// 英雄受到治疗效果
        /// </summary>
        /// <param name="who">目标对象</param>
        /// <param name="cure">治疗值</param>
        public void OnCureLogicFighter(string who, float cure, float tipdelayTime = 0)
        {
            LogicFighter target = this.FindFighter(who);
            if (null == target)
            {
                return;
            }

            float cureAdd = 0f;
            //if (target.GetBuffEffectProperty(EBuffEffect.EBUFF_EFFECT_Cure) > 0)
            //{
            //    cureAdd = cure * target.GetBuffEffectProperty(EBuffEffect.EBUFF_EFFECT_Cure) / 100;
            //}

            cure = cure + cureAdd;
            //Debug.Log(who + " cure:" + cure);
            target.ModifyProperty(EBattleProperty.HP, cure);
            this.Env().ShowAdapter().BattleTipShowing(who, EBattleTips.EDAMAGE_TIPS_CURE, ((int)cure).ToString());
        }

        /// <summary>
        /// 英雄能量恢复
        /// </summary>
        /// <param name="who">目标对象id</param>
        /// <param name="power">能量值</param>
        /// <param name="isTip">是否需要提示信息</param>
        public void OnCurePower(string who, float power, bool isTip = false)
        {
            LogicFighter target = this.FindFighter(who);
            if (null == target)
            {
                return;
            }

            target.ModifyProperty(EBattleProperty.NPOWER, power);

            if (isTip)
            {
                this.Env().ShowAdapter().BattleTipShowing(who, EBattleTips.EDAMAGE_TIPS_POWERRECOVER, power.ToString());
            }
        }
        /// <summary>
        /// 英雄受到魔法伤害
        /// </summary>
        /// <param name="casterID">施法对象ID</param>
        /// <param name="targetID">目标对象id</param>
        /// <param name="damage">伤害数值</param>
        /// <param name="isCritical">是否暴击</param>
        /// <param name="delay">延迟显示</param>
        public void OnMagicDamageToBattleFighter(string casterID, string targetID, float damage,
            bool isCritical = false, float tipdelayTime = 0)
        {
            LogicFighter target = this.FindFighter(targetID);
            LogicFighter caster = this.FindFighter(casterID);
            if (null == target || true == target.IsDead())
            {
                //LogHelper.LogError("目标死亡 id:" + target.ID());
                return;
            }

            ///护盾检测【被攻击方】
            damage = OnMagicDamageByBuffHandle(caster, target, damage, EBuffEffect.EBUFF_EFFECT_Shield);

            if (damage == 0)
            {
                //Debug.LogError("攻击伤害为零无效");
                return;
            }

            damage = damage * this.Env().BattleGlobalOper().GetLianJiDamageRate() * 1.0f / 100;
            //Debug.LogError(targetID + " 伤害 " + damage);

            target.ModifyProperty(EBattleProperty.HP, damage);

            #region UI显示信息/动作表现
            if (target.GetState().GetCurrentState().Type() == BaseState.EFighterState.IDLE)
            {
                target.GetState().ChangeState(BaseState.EFighterState.ONHIT, null);
            }
            else
            {
                this.Env().ShowAdapter().EnterHitState(target.ID());
            }

            //刷新界面数据
            this.Env().ShowAdapter().OnRefreshWindowData();
            //伤害提示
            if (isCritical)
            {
                this.Env().ShowAdapter().BattleTipShowing(targetID, EBattleTips.EDAMAGE_TIPS_CRIT, (Mathf.Abs((int)damage)).ToString(), tipdelayTime);
            }
            else
            {
                this.Env().ShowAdapter().BattleTipShowing(targetID, EBattleTips.EDAMAGE_TIPS_DAMAGE, (Mathf.Abs((int)damage)).ToString(), tipdelayTime);
            }

            // 目标角色处理
            if (target.IsDead())
            {
                this.Env().mBattleGlobalOper.OnTriggerPassiveSkill((int)ESkillTrigger.ESkill_TRIGGER_DEAD, string.Empty, casterID, targetID);
                // 目标对象处理
                target.GetState().ChangeState(BaseState.EFighterState.DEAD, null);
                return;
            }

            #endregion
        }

        /// <summary>
        /// 攻击行为被（buff）过滤
        /// </summary>
        /// <param name="caster"></param>
        /// <param name="target"></param>
        /// <param name="damage"></param>
        /// <returns></returns>
        private float OnMagicDamageByBuffHandle(LogicFighter caster, LogicFighter target, float damage, EBuffEffect effecttype)
        {
            float result = damage;
            switch (effecttype)
            {
                case EBuffEffect.EBUFF_EFFECT_Shield:

                    ///提示用，可抵御的伤害数字
                    int shieldDefence = target.GetBuffEffectProperty(EBuffEffect.EBUFF_EFFECT_Shield);
                    ///剩余护盾值
                    int lastShieldDefence = 0;
                    // 伤害百分比加成效果
                    if (shieldDefence > 0)
                    {
                        int tipDefence = 0;
                        lastShieldDefence = shieldDefence + (int)result;

                        if (lastShieldDefence > 0)
                        {
                            tipDefence = (int)Mathf.Abs(result);
                            result = 0;
                        }
                        else
                        {
                            result = lastShieldDefence;
                            tipDefence = shieldDefence;
                            lastShieldDefence = 0;
                        }
                        LogHelper.LogError(target.ID() + ":护盾效果：抵御" + tipDefence + "点伤害,剩余" + lastShieldDefence);
                        target.SetBuffEffectProperty(EBuffEffect.EBUFF_EFFECT_Shield, lastShieldDefence);
                        this.Env().ShowAdapter().BattleTipShowing(target.ID(), EBattleTips.EDAMAGE_IMMO, tipDefence.ToString());
                    }

                    if (result == 0)
                    {

                        //LogHelper.LogError(caster.ID() + "-------------" + damage + "---------------------------护盾值剩余" + shieldDefence);

                    }


                    break;

                   
            }

            return result;
        }

    }

}