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

namespace BF
{
    public class BattleControlHero : BattleControlUnit
    {
        private Camera mainCamera;
        private Rigidbody unitRigidbody;
        private bool isMoving = false;
        private float TargetX = 0.0f;
        private float TargetZ = 0.0f;
        private float moveSpeed = 1.0f;
        private Vector3 targetPosition = Vector3.zero;
        // 摄像机相关
        public bool IsCameraFollowWithHero = true;
        private Vector3 cameraOriginPosition = Vector3.zero;

        void Awake()
        {
            mainCamera = Camera.main;
            InitRigidbody();
        }

        private void InitRigidbody()
        {
            if (!gameObject.TryGetComponent<Rigidbody>(out unitRigidbody))
            {
                unitRigidbody = gameObject.AddComponent<Rigidbody>();
            }
            unitRigidbody.angularDrag = 0;
            unitRigidbody.useGravity = false;
            unitRigidbody.isKinematic = true;
            unitRigidbody.constraints = BattleConst.RIGIDBODY_CONSTRAINTS;
            bodyCollider = gameObject.AddComponent<SphereCollider>();
            bodyCollider.isTrigger = true;
        }

        public void InitHero(int side, CharacterSpineHelper helper)
        {
            Side = side;
            BattleMgr = BF.BFMain.Instance.BattleMgr;
            Direction = 1;
			gameObject.layer = BattleConst.LAYER_HERO;
            ReuseFlag++;
            IsDead = false;
            IsInGroundState = false;
            IsDisappear = false;
            BattleMgr.AddToAtkUnitsList(this);
        }

        public override void InitHpBar()
        {
            if (isHaveHpBar)
            {
                return;
            }
            hpBar = BattleMgr.PoolHelper.GetHpBar(Side);
            hpBar.transform.localScale = Vector3.one;
            hpBar.RefreshHpBar(1.0f);
            hpBar.SetShieldVisible(false);
            BattleMgr.UpdateUIPosition(transform.position, HpBarAddY, hpBar.transform as RectTransform);
            isHaveHpBar = true;
        }

        public override void RefreshHpBar(float percent)
        {
            if (!isHaveHpBar)
            {
                return;
            }
            hpBar.RefreshHpBar(percent);
        }

        public override void RefreshShieldBar(float percent, bool visible)
        {
            if (!isHaveHpBar)
            {
                return;
            }
            if (visible)
            {
                hpBar.RefreshShieldBar(percent);
            }
            hpBar.SetShieldVisible(visible);
        }

        public void SetCameraStartPosition(Vector3 originPosition)
        {
            cameraOriginPosition = originPosition;
        }

        public bool MoveAndAttack(int direction)
        {
            isMoving = true;
            bool isAttack = true;
            var x = transform.position.x;
            var z = transform.position.z;
            if (direction == 1) // 朝向右边
            {
                BattleControlUnit leftTarget = null;
                BattleControlUnit rightTarget = null;
                BattleMgr.GetNearestDefUnit(x, z, out leftTarget, out rightTarget);
                if (ReferenceEquals(rightTarget, null)) // 右边没有敌人
                {
                    if (ReferenceEquals(leftTarget, null)) // 左边也没有敌人则向该方向进行常规攻击，同时推进
                    {
                        if (BattleMgr.GetEffectWarningCount() <= 0)
                        {
                            TargetX = x + BattleConfigure.DistanceAttack;
                            TargetZ = z;
                            Direction = direction;
                        }
                        else // 找不到人，但是有预警的话就往该方向后撤
                        {
                            TargetX = x + BattleConfigure.DistanceBack;
                            TargetZ = z;
                            isAttack = false;
                        }
                    }
                    else // 左边有敌人，则向该方向进行后撤,并且当前朝向不变
                    {
                        TargetX = x + BattleConfigure.DistanceBack;
                        TargetZ = z;
                        isAttack = false;
                    }
                }
                else // 右边有敌人，向目标进行冲锋推进攻击
                {
                    TargetX = rightTarget.transform.position.x - rightTarget.BodyRadius - BodyRadius;
                    if (TargetX - x > BattleConfigure.DistanceDash)
                    {
                        TargetX = x + BattleConfigure.DistanceDash;
                    }
                    TargetZ = rightTarget.transform.position.z;
                    Direction = direction;
                }
                targetPosition = new Vector3(TargetX, 0.0f, TargetZ);
                var distance = (targetPosition - transform.position).magnitude;
                if (isAttack)
                {
                    moveSpeed = Math.Abs(distance / BattleConfigure.NormalMoveTime);
                }
                else
                {
                    moveSpeed = Math.Abs(distance / BattleConfigure.NormalBackTime);
                }
            }
            else
            {
                BattleControlUnit leftTarget = null;
                BattleControlUnit rightTarget = null;
                BattleMgr.GetNearestDefUnit(x, z, out leftTarget, out rightTarget);
                if (ReferenceEquals(leftTarget, null)) // 左边没有敌人
                {
                    if (ReferenceEquals(rightTarget, null)) // 右边也没有敌人则向该方向进行常规攻击，同时推进
                    {
                        if (BattleMgr.GetEffectWarningCount() <= 0)
                        {
                            TargetX = x - BattleConfigure.DistanceAttack;
                            TargetZ = transform.position.z;
                            Direction = direction;
                        }
                        else
                        {
                            TargetX = x - BattleConfigure.DistanceBack;
                            TargetZ = transform.position.z;
                            isAttack = false;
                        }
                    }
                    else // 右边有敌人，则向该方向进行后撤,并且当前朝向不变
                    {
                        TargetX = x - BattleConfigure.DistanceBack;
                        TargetZ = transform.position.z;
                        isAttack = false;
                    }
                }
                else // 左边有敌人，向目标进行冲锋推进攻击
                {
                    TargetX = leftTarget.transform.position.x + leftTarget.BodyRadius + BodyRadius;
                    if (x - TargetX > BattleConfigure.DistanceDash)
                    {
                        TargetX = x - BattleConfigure.DistanceDash;
                    }
                    TargetZ = leftTarget.transform.position.z;
                    Direction = direction;
                }
                targetPosition = new Vector3(TargetX, 0.0f, TargetZ);
                var distance = (targetPosition - transform.position).magnitude;
                if (isAttack)
                {
                    moveSpeed = Math.Abs(distance / BattleConfigure.NormalMoveTime);
                }
                else
                {
                    moveSpeed = Math.Abs(distance / BattleConfigure.NormalBackTime);
                }
            }
            return isAttack;
        }

        public int GetNearestLeftRightUnit()
        {
            BattleControlUnit leftTarget = null;
            BattleControlUnit rightTarget = null;
            BattleMgr.GetNearestDefUnit(transform.position.x, transform.position.z, out leftTarget, out rightTarget);
            if (ReferenceEquals(leftTarget, null))
            {
                if (ReferenceEquals(rightTarget, null))
                {
                    return 0; // 两边都没有敌人
                }
                else
                {
                    return 2; // 只有右边有敌人
                }
            }
            else
            {
                if (ReferenceEquals(rightTarget, null))
                {
                    return 1; // 只有左边有敌人
                }
                else
                {
                    var leftDistance = Mathf.Abs(transform.position.x - leftTarget.transform.position.x);
                    var rightDistance = Mathf.Abs(transform.position.x - rightTarget.transform.position.x);
                    if (leftDistance < rightDistance)
                    {
                        return 1; // 左边的敌人离得更近
                    }
                    else
                    {
                        return 2; // 右边的敌人离得更近
                    }
                }
            }
        }

        public override bool GetWhetherUseGroundSkill()
        {
            var unit = BattleMgr.GetNearestDefUnitOnCurrDirection(transform.position.x, transform.position.z, Direction);
            if (ReferenceEquals(unit, null))
            {
                return false;
            }
            return unit.IsInGroundState;
        }

        public void StopMove()
        {
            isMoving = false;
        }

        public void StartMove()
        {
            isMoving = true;
        }

        private float GetMoveSpeed()
        {
            return moveSpeed;
        }

        public override void OnDead()
        {
            IsDead = true;
            IsInGroundState = false;
        }

        public override void Reborn()
        {
            IsDead = false;
        }

        public override void Revive()
        {
            IsDead = false;
        }

        public override void Clear()
        {
            luaOnHitTargetFunc = null;
            if (isHaveHpBar)
            {
                BattleMgr.PoolHelper.PutBackHpBar(hpBar, Side);
                hpBar = null;
                isHaveHpBar = false;
            }
        }

        void Update()
        {
            if (!isMoving)
            {
                return;
            }
            if ((transform.position - targetPosition).sqrMagnitude < 0.0001)
            {
                return;
            }
            var moveToPosition = Vector3.MoveTowards(transform.position, targetPosition, GetMoveSpeed() * Time.deltaTime*BattleConfigure.TimeScale);
            if (moveToPosition.x < BattleConfigure.SceneMinX)
            {
                moveToPosition.x = BattleConfigure.SceneMinX;
            }
            else if (moveToPosition.x > BattleConfigure.SceneMaxX)
            {
                moveToPosition.x = BattleConfigure.SceneMaxX;
            }
            transform.position = moveToPosition;
        }

        void LateUpdate()
        {
            if (IsCameraFollowWithHero)
            {
                var position = cameraOriginPosition + new Vector3(transform.localPosition.x, 0.0f, 0.0f);
                if (position.x < BattleConfigure.CameraMinX)
                {
                    position.x = BattleConfigure.CameraMinX;
                }
                else if (position.x > BattleConfigure.CameraMaxX)
                {
                    position.x = BattleConfigure.CameraMaxX;
                }
                mainCamera.transform.position = position;
                BattleConfigure.BattleCenterPosX = position.x;
                BattleMgr.UpdateEffectTextRootNode();
            }
            if (isHaveHpBar && isMoving)
            {
                BattleMgr.UpdateUIPosition(transform.position, HpBarAddY, hpBar.transform as RectTransform);
            }
        }

        private void OnDestroy()
        {
            luaOnHitTargetFunc = null;
        }
    }
}