using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using FSBuff;
using FSAssist;

namespace FSRole {
    /*
     * 角色组件
    */
    public class Role : MonoBehaviour {
        // 角色原始属性
        public RoleAttr OriginAttr;
        // 角色当前属性
        public RoleAttr CurrentAttr;
        // 角色所挂载的BUFF数组，所有Buff都放在这里面
        public ArrayList buffs;
        // 血条
        private Vector2 originSize;
        private RectTransform bloodRect;
        public void SetBloodTrs(Transform blood) {
            bloodRect = blood.GetComponent<RectTransform>();
            originSize = bloodRect.sizeDelta;
        }

        // Use this for initialization
        void Start() {
            buffs = new ArrayList();
        }

        // Update is called once per frame
        void Update() {

        }

        /*
         * 添加角色的各个接口
        */

        /*
         * 受到伤害
        */
        public void GetDamage(int value) {
            int damage = DamagePassBuff(value);
            print("角色 : " + CurrentAttr.ID + " 受到了 " + damage + " 点伤害，剩余血量 : " + (CurrentAttr.Hp + damage));

            CurrentAttr.Hp += damage;
            // 当血量大于0时
            if (CurrentAttr.Hp >= 0) {
                float newWidth = (float)CurrentAttr.Hp / OriginAttr.Hp * originSize.x;
                bloodRect.sizeDelta = new Vector2(newWidth, originSize.y);
            }
        }

        /*
         * 消耗精力
        */
        public void CostEngine(int value) {
            CurrentAttr.Mp -= value;
        }

        /*
         * 增加防御力
        */
        public void Defense(int value) {
            print("角色 : " + CurrentAttr.ID + "增加了" + value + "点防御，当前防御 : " + (CurrentAttr.Def + value));
            CurrentAttr.Def += value;
        }

        /*
         * 运行BUFF
        */
        public void BuffExecute() {
            //// 遍历数组来运行BUFF
            //foreach (Buff index in buffs) {
            //    print("角色" + CurrentAttr.ID + "的Buff ID 为 " + index.ID);
            //    index.Execute();
            //}

            int index = buffs.Count - 1;
            while (true) {
                // 当索引位置小于0时，结束查询
                if (index < 0) {
                    return;
                }

                Debug.Log("运行一个Buff : " + index);
                Buff buff = (Buff)buffs[index];
                buff.Execute();

                index--;
            }
        }

        /*
         * 添加Buff
        */
        public void AddBuff(Buff buff) {
            // 首先判断数组中是否已经存在此Buff
            // 未来还需要根据两个相同buff的属性来进行更新
            foreach (Buff index in buffs) {
                if (index.ID.Equals(buff.ID)) {
                    // 未来在这里做些什么
                    // 如果有同样的BUFF，则更新原BUFF，并叠加层数
                    index.Round = buff.Round;
                    index.Overlay++;
                    return;
                }
            }

            // 往数组中添加数组
            buffs.Add(buff);
        }

        /*
         * 移除Buff
        */
        public void EraseBuff(Buff buff) {
            // 从数组中查找
            foreach (Buff index in buffs) {
                if (index.ID.Equals(buff.ID)) {
                    print("角色 " + CurrentAttr.ID + " 取消BUFF " + buff.ID);
                    buffs.Remove(index);
                    return;
                }
            }
        }

        /*
         * 攻击时经过Buff判定
        */
        private int DamagePassBuff(int value) {
            // 根据不同的Buff给出不同的处理
            if (ContainBuff(AssistConfig.Fracture)) {
                print("存在骨折Buff的影响 ... ");
                Buff buff = GetBuff(AssistConfig.Fracture);
                // 根据叠加层数来进行判断
                if (buff.Overlay < 3) {
                    // 当层数小于3时
                    return (int)(value * 1.2f);
                } else if (buff.Overlay >= 3 && buff.Overlay < 6) {
                    // 当层数小于6时
                    return (int)(value * 1.4f);
                } else if (buff.Overlay >= 6 && buff.Overlay < 9) {
                    // 当层数小于9时
                    return (int)(value * 1.6f);
                } else {
                    // 层数大于9时
                    return (int)(value * (1.6f + (buff.Overlay - 9) * 0.2f));
                }
            }
            return value;
        }

        /*
         * 比牌时经过Buff判定
        */
        public int CompairePassBuff(int value) {
            // 根据不同的Buff给出不同的处理
            if (ContainBuff(AssistConfig.Paralysis)) {
                Buff buff = GetBuff(AssistConfig.Paralysis);
                print("存在麻痹Buff的影响 ... " + buff.Overlay);
                // 根据叠加层数来进行判断
                if (buff.Overlay < 3) {
                    // 当层数小于3时
                    return value - 1;
                } else if (buff.Overlay >= 3 && buff.Overlay < 6) {
                    // 当层数小于6时
                    return value - 2;
                } else if (buff.Overlay >= 6 && buff.Overlay < 9) {
                    // 当层数小于9时
                    return value - 3;
                } else {
                    // 层数大于9时
                    return value - 3 - (buff.Overlay - 9);
                }
            }
            return value;
        }

        /*
         * 判断是否有包含某个数组
        */
        private bool ContainBuff(string ID) {
            foreach (Buff index in buffs) {
                // 根据ID来判断
                if (index.ID == ID) {
                    return true;
                }
            }

            return false;
        }

        /*
         * 获取指定ID的Buff
        */
        private Buff GetBuff(string ID) {
            foreach (Buff index in buffs) {
                // 根据ID来判断
                if (index.ID == ID) {
                    return index;
                }
            }

            return null;
        }
    }
}