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

namespace YLBattle
{
    /// <summary>
    /// 角色（逻辑层）
    /// </summary>
    public partial class LogicFighter
    {
        #region 基础属性
        /// <summary>
        /// 对象唯一标识符
        /// </summary>
        private string mID = string.Empty;

        /// <summary>
        /// 模板ID
        /// </summary>
        private string mTID = string.Empty;

        /// <summary>
        /// 数据适配器
        /// </summary>
        private IFighterAdapter mAdapter = null;

        /// <summary>
        /// 战斗环境
        /// </summary>
        private BattleParam mEnv = null;

        /// <summary>
        /// 隶属分组
        /// </summary>
        private EBattleTeam mTeam = EBattleTeam.NONE;

        /// <summary>
        /// 状态机
        /// </summary>
        private LogicFighterFSM mFighterFSM = null;

        /// <summary>
        /// 
        /// </summary>
        private int mSeat = 0;
        /// <summary>
        /// 
        /// </summary>
        private int mRoleType = 0;
        /// <summary>
        /// 对象属性
        /// </summary>
        private LogicFighterProperty[] mProperty = new LogicFighterProperty[(int)EBattleProperty.MAX];

        /// <summary>
        /// 当前锁定目标
        /// </summary>
        private string mLockedTarget = string.Empty;

        /// <summary>
        /// 释放技能时的当前回合数
        /// </summary>
        private int mCurtRound = 0;

        /// <summary>
        /// 上次出手时间（受攻击暂停影响）
        /// </summary>
        private long mLastAttackTime = 0;

        #endregion

        #region 外部调用

        /// <summary>
        /// 获取对象唯一标识符
        /// </summary>
        /// <returns>对象id</returns>
        public string ID()
        {
            return this.mID;
        }

        /// <summary>
        /// 获取模板数据ID
        /// </summary>
        /// <returns>对象模板id</returns>
        public string TID()
        {
            return this.mTID;
        }
        /// <summary>
        /// 获取状态机
        /// </summary>
        /// <returns>状态机管理器对象</returns>
        public LogicFighterFSM GetState()
        {
            return this.mFighterFSM;
        }

        /// <summary>
        /// 对象隶属分组
        /// </summary>
        /// <returns>详见EBattleTeam定义</returns>
        public EBattleTeam Team()
        {
            return this.mTeam;
        }

        /// <summary>
        /// 占位
        /// </summary>
        /// <returns></returns>
        public int Seat()
        {
            return mSeat;
        }

        /// <summary>
        /// 角色类型 0=小怪 1=英雄  （战斗中英雄使用公共技能槽）
        /// </summary>
        /// <returns></returns>
        public int RoleType()
        {
            return mRoleType;
        }

        /// <summary>
        /// 获取数据适配器
        /// </summary>
        /// <returns>适配器</returns>
        public IFighterAdapter Adapter()
        {
            return this.mAdapter;
        }

        /// <summary>
        /// 当前锁定的目标
        /// </summary>
        public string LockedTarget
        {
            get { return this.mLockedTarget; }
            set { this.mLockedTarget = value; }
        }

        /// <summary>
        /// 当前出手时间
        /// </summary>
        public long LastAttackTime
        {
            get { return this.mLastAttackTime; }
            set { this.mLastAttackTime = value; }
        }


        #endregion

        #region 外部排序调用
        /// <summary>
        /// 等级
        /// </summary>
        /// <returns></returns>
        public int Level
        {
            get { return this.mAdapter.Level(); }
        }
        /// <summary>
        /// 攻击速度
        /// </summary>
        public int AttackSpeed
        {
            get { return this.mAdapter.Agile(); }
        }
        /// <summary>
        /// 剩余攻击时间
        /// </summary>
        public long LeftAttackTime
        {
            get { return this.mAdapter.Agile(); }
        }

        /// <summary>
        ///  等阶
        /// </summary>
        public int StrengthLevel
        {
            get { return this.mAdapter.StrengthLevel(); }
        }

        #endregion

        /// <summary>
        /// 初始化（赋值）
        /// </summary>
        /// <param name="_adp"></param>
        /// <param name="_intTeam"></param>
        /// <param name="strId"></param>
        public void SetData(string strId, BattleParam _param, IFighterAdapter _adp, EBattleTeam _eTeam, int _seat)
        {
            this.mID = strId;
            this.mTID = _adp.TID();
            this.mAdapter = _adp;
            this.mTeam = _eTeam;
            this.mEnv = _param;
            this.mSeat = _seat;

            this.mRoleType = _adp.RoleType();
            /// 从属性适配器加载角色属性
            float val = 0;
            LogicFighterProperty property = null;
            ///初始化属性
            for (int i = (int)EBattleProperty.NONE; i < (int)EBattleProperty.MAX; ++i)
            {
                val = (float)_adp.GetProperty((EBattleProperty)i);
                property = new LogicFighterProperty(val);
                this.mProperty[i] = property;
            }

            /// 加载技能
            this.mNormalSkill = _adp.NormalSkill();
            this.mManuSkill1 = _adp.ManuSkill1();
            this.mManuSkill2 = _adp.ManuSkill2();
            this.mPassiveSkill = _adp.PassiveSkill();
            this.mLeaderSkill = _adp.LeaderSkill();

            this.mLastAttackTime = 0;

            /// 初始化状态机
            this.mFighterFSM = new LogicFighterFSM();
            this.mFighterFSM.Initialize(_param, this);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="now"></param>
        public void OnUpdateSkillPower(long span)
        {
            if (this.mManuSkill1 == null)
            {
                return;
            }
            if (IsPowerFull())
            {
                return;
            }

            this.ModifyProperty(EBattleProperty.NPOWER, span);

        }

        /// <summary>
        /// red=Boss/blue=Header
        /// </summary>
        /// <returns></returns>
        public bool IsLeader()
        {
            return mAdapter.IsLeader();
        }

        /// <summary>
        /// 是否死亡
        /// </summary>
        /// <returns>true已死亡, false未死亡</returns>
        public bool IsDead()
        {
            float hp = this.GetProperty(EBattleProperty.HP);
            if (hp < 0.1)
            {
                return true;
            }

            return false;
        }

        /// <summary>
        /// 检测能量是否已满
        /// </summary>
        /// <returns>true已满,false未满</returns>
        public bool IsPowerFull()
        {
            float power = this.GetProperty(EBattleProperty.NPOWER);
            float maxPower = this.GetProperty(EBattleProperty.NMAXPOWER);
            if (maxPower - power < 0.1)
            {
                return true;
            }

            return false;
        }

        /// <summary>
        /// 获取指定技能实际等级
        /// </summary>
        /// <param name="id">技能id</param>
        /// <returns>等级,失败0</returns>
        public int GetSkillLevel(string tid)
        {
            return this.Adapter().SkillLevel(tid);
        }

        /// <summary>
        /// 检测是否为友方
        /// </summary>
        /// <param name="who">目标对象</param>
        /// <returns>友方true,否则为敌方</returns>
        public EBattleRelation Relation(LogicFighter who)
        {
            return ((int)(this.mTeam) & (int)(who.Team())) == 0 ? EBattleRelation.EBATTLE_RELATION_ENEMY : EBattleRelation.EBATTLE_RELATION_FRIEND;
        }


        #region 属性操作
        /// <summary>
        /// 获取战斗人员指定属性
        /// </summary>
        /// <param name="indx">属性索引</param>
        /// <returns>属性值</returns>
        public float GetProperty(EBattleProperty indx)
        {
            return this.mProperty[(int)indx].GetValue();
        }

        /// <summary>
        /// 获取属性基础值
        /// </summary>
        /// <param name="indx">属性索引</param>
        /// <returns>基础值</returns>
        public float GetPropertyBase(EBattleProperty indx)
        {
            return this.mProperty[(int)indx].GetBaseValue();
        }

        /// <summary>
        /// 获取属性修正值
        /// </summary>
        /// <param name="indx">属性索引</param>
        /// <returns>修正值</returns>
        public float GetPropertyCorrected(EBattleProperty indx)
        {
            return this.mProperty[(int)indx].GetCorrectedValue();
        }

        /// <summary>
        /// 设置指定属性为指定值
        /// </summary>
        /// <param name="indx">属性索引</param>
        /// <param name="val">设置的值</param>
        /// <returns>设置后的值</returns>
        public float SetProperty(EBattleProperty indx, float val)
        {

            this.mProperty[(int)indx].SetCorrectedValue(val);
            return this.mProperty[(int)indx].GetValue();
        }

        /// <summary>
        /// 修改指定属性
        /// </summary>
        /// <param name="indx">属性索引</param>
        /// <param name="val">修改值</param>
        /// <returns>返回修改以后的值</returns>
        public float ModifyProperty(EBattleProperty indx, float val)
        {

            float org = this.mProperty[(int)indx].GetValue();
            this.mProperty[(int)indx].ModifyCorrectedValue(val);

            switch (indx)
            {
                case EBattleProperty.HP:

                    float hpMax = this.mProperty[(int)EBattleProperty.HPMAX].GetValue();
                    if (this.mProperty[(int)EBattleProperty.HP].GetValue() > hpMax)
                    {
                        this.mProperty[(int)indx].SetCorrectedValue(0);
                    }

                    break;

                case EBattleProperty.NPOWER:

                    float powerMax = this.mProperty[(int)EBattleProperty.NMAXPOWER].GetValue();
                    if (this.mProperty[(int)EBattleProperty.NPOWER].GetValue() > powerMax)
                    {
                        this.mProperty[(int)indx].SetCorrectedValue(powerMax);
                    }
                    break;
            }
            //float crt = this.mProperty[(int)indx].GetValue();
            //if ((int)crt != (int)org)
            //{
            //    Debug.Log("【" + mID + "】 Pro:" + this.mTempProName[indx] + " Val:" + (val <= 0 ? "减少" : "增加") + val
            //        + "  Org:" + org + "  Crt:" + crt
            //        );
            //}
            return this.mProperty[(int)indx].GetValue();
        }

        /// <summary>
        /// 临时属性输出参照表
        /// </summary>
        Dictionary<EBattleProperty, string> mTempProName = new Dictionary<EBattleProperty, string>()
    {
        {EBattleProperty.HP,"血量"} ,
        {EBattleProperty.HPMAX,"最大血量"} ,
        {EBattleProperty.ATTACK,"攻击力"} ,
        {EBattleProperty.ATTACKSPEED,"敏捷"} ,
        {EBattleProperty.CRITICALPROB,"暴击"} ,
        {EBattleProperty.DEFENSE,"防御"} ,
        {EBattleProperty.NPOWER,"当前能量"} ,
        {EBattleProperty.NMAXPOWER,"最大能量"} ,
        {EBattleProperty.POSX,"X"} ,
        {EBattleProperty.POSY,"Y"} ,
    };


        #endregion


        #region(技能)
        /// <summary>
        /// 普通攻击
        /// </summary>
        private string mNormalSkill = string.Empty;

        /// <summary>
        /// 主动技能1
        /// </summary>
        private string mManuSkill1 = string.Empty;

        /// <summary>
        /// 主动技能2
        /// </summary>
        private string mManuSkill2 = string.Empty;

        /// <summary>
        ///  被动技能
        /// </summary>
        private string mPassiveSkill = string.Empty;

        /// <summary>
        ///  队长技能
        /// </summary>
        private string mLeaderSkill = string.Empty;

        /// <summary>
        /// 主动技能1的冷冻回合数
        /// </summary>
        private int mManuSkill1Round = 0;

        /// <summary>
        /// 必杀所需power
        /// </summary>
        private int mCriticalNeedPower = 0;

        /// <summary>
        /// 普通攻击
        /// </summary>
        /// <returns>技能模板id</returns>
        public string NormalSkill()
        {
            return this.mNormalSkill;
        }
        /// <summary>
        /// 主动技能1
        /// </summary>
        /// <returns>技能模板id</returns>
        public string ManuSkill1()
        {
            return this.mManuSkill1;
        }
        /// <summary>
        /// 主动技能2
        /// </summary>
        /// <returns>技能模板id</returns>
        public string ManuSkill2()
        {
            return this.mManuSkill2;
        }
        /// <summary>
        /// 被动技能
        /// </summary>
        /// <returns>技能模板id</returns>
        public string PassiveSkill()
        {
            return this.mPassiveSkill;
        }
        /// <summary>
        /// 被动技能
        /// </summary>
        /// <returns>技能模板id</returns>
        public string LeaderSkill()
        {
            return this.mLeaderSkill;
        }
        /// <summary>
        /// 暴击需要的TeamPowerRate
        /// </summary>
        /// <returns>技能模板id</returns>
        public int CriticalNeedPower()
        {
            return this.mCriticalNeedPower;
        }

        #endregion


    }

}