using System;
using System.Collections;
using Sirenix.OdinInspector;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.Serialization;

// ReSharper disable once CheckNamespace
namespace BlueWaterProject
{
    public class CombatPlayer : MonoBehaviour, IDamageable
    {
        [Title("초기화 방식")]
        [SerializeField] private bool autoInit = true;

        [Title("캐릭터 변수")]
        [SerializeField] private float maxHp = 100f;
        [SerializeField] private float currentHp;
        [SerializeField] private float moveSpeed = 5f;
        [SerializeField] private float maxSlopeAngle = 50f;
        
        [field: Title("대쉬")]
        [field: SerializeField] public float DashForce { get; set; } = 20f;
        [field: SerializeField] public float DashCooldown { get; set; } = 0.5f;
        [field: DisableIf("@true")]
        [field: SerializeField] public bool IsDashing { get; set; }
        [field: DisableIf("@true")]
        [field: SerializeField] public bool EnableDash  { get; set; } = true;

        [field: Title("공격")]
        [field: SerializeField] public int MaxHitNum { get; set; } = 10;
        [field: SerializeField] public float AttackDamage { get; set; } = 10f;
        [field: SerializeField] public float AttackRange { get; set; } = 1.5f;
        [field: SerializeField] public float AttackAngle { get; set; } = 180f;
        [field: SerializeField] public float ComboTime { get; set; } = 0.5f;
        [field: SerializeField] public LayerMask TargetLayer { get; set; }
        [field: DisableIf("@true")]
        [field: SerializeField] public bool IsAttacking { get; set; }
        [field: DisableIf("@true")]
        [field: SerializeField] public bool IsComboAttacking { get; set; }
        [field: DisableIf("@true")]
        [field: SerializeField] public bool IsComboPossible { get; set; }
        
        [Title("컴포넌트")]
        [SerializeField] private PlayerInput playerInput;
        [field: SerializeField] public Rigidbody Rb { get; set; }
        [SerializeField] private Transform visualLook;
        [field: SerializeField] public Animator Animator { get; set; }
        [SerializeField] private Transform groundCheck;

        [Title("Extensions Data")]
        [SerializeField] private float nextFrameCoefficient = 3f;
        
        private Vector2 movementInput;
        private Vector3 currentDirection = Vector3.back;
        public Vector3 PreviousDirection { get; set; } = Vector3.back;
        [field: SerializeField] public Collider[] HitColliders { get; set; }
        private RaycastHit slopeHit;
        private int groundLayer;
        private bool isOnSlope;
        private bool isGrounded;
        
        private const float RAY_DISTANCE = 3f;
        
        private static readonly int XDirectionHash = Animator.StringToHash("xDirection");
        private static readonly int ZDirectionHash = Animator.StringToHash("zDirection");
        private static readonly int IsMovingHash = Animator.StringToHash("isMoving");
        public readonly int isDashingHash = Animator.StringToHash("isDashing");
        public readonly int isAttackingHash = Animator.StringToHash("isAttacking");

        private void OnDrawGizmosSelected()
        {
            var lossyScale = transform.lossyScale;
            var boxSize = new Vector3(lossyScale.x, 0.4f, lossyScale.z * 0.5f);
            Gizmos.color = IsGrounded() ? Color.blue : Color.red;
            Gizmos.DrawWireCube(groundCheck.position, boxSize);
        }

        [Button("셋팅 초기화")]
        private void Init()
        {
            playerInput = GetComponent<PlayerInput>();
            Rb = GetComponent<Rigidbody>();
            visualLook = transform.Find("VisualLook");
            Animator = visualLook.GetComponent<Animator>();
            groundCheck = transform.Find("GroundCheck");
        }

        private void Awake()
        {
            if (autoInit)
            {
                Init();
            }
        }

        private void Start()
        {
            HitColliders = new Collider[MaxHitNum];
            groundLayer = 1 << LayerMask.NameToLayer("Ground");
            
            SetCurrentHp(maxHp);
        }

        private void OnEnable()
        {
            playerInput.actions.FindAction("Attack").performed += OnAttackEvent;
        }

        private void OnDisable()
        {
            playerInput.actions.FindAction("Attack").performed -= OnAttackEvent;
        }

        private void Update()
        {
            var isMoving = currentDirection.magnitude > 0.01f;
            if (isMoving)
            {
                PreviousDirection = currentDirection.normalized;
                Animator.SetFloat(XDirectionHash, PreviousDirection.x);
                Animator.SetFloat(ZDirectionHash, PreviousDirection.z);
            }
            Animator.SetBool(IsMovingHash, isMoving);
            
            var localScale = visualLook.localScale;
            localScale.x = PreviousDirection.x switch
            {
                > 0.01f => Mathf.Abs(localScale.x),
                < -0.01f => -Mathf.Abs(localScale.x),
                _ => localScale.x
            };
            visualLook.localScale = localScale;

            isOnSlope = IsOnSlope();
            isGrounded = IsGrounded();
        }

        private void FixedUpdate()
        {
            HandleMovement();
        }

        public void TakeDamage(float attackerPower, Vector3? attackPos = null)
        {
            if (IsDashing) return;
            
            var changeHp = Mathf.Max(currentHp - attackerPower, 0);
            SetCurrentHp(changeHp);

            if (InIslandCamera.Inst.InIslandCam)
            {
                VisualFeedbackManager.Inst.CameraShake(InIslandCamera.Inst.InIslandCam);
            }
            
            // 죽었는지 체크
            if (changeHp == 0f)
            {
                Die();
                return;
            }
        }

        public void Die()
        {
            print("Combat Player Die");
        }

        private void OnMove(InputValue value)
        {
            movementInput = value.Get<Vector2>();
        }
        
        public void OnDash()
        {
            if (!EnableDash || IsDashing) return;
            
            Animator.SetBool(isDashingHash, true);
        }
        
        private void OnAttackEvent(InputAction.CallbackContext context)
        {
            if (IsAttacking && !IsComboPossible) return;
            
            // var control = context.control;
            //
            // if (control.name.Equals("leftButton"))
            // {
            //     UseMouseAttack = true;
            // }
            // else if (control.name.Equals("k"))
            // {
            //     UseMouseAttack = false;
            // }
            
            if (IsComboPossible)
            {
                IsComboAttacking = true;
                return;
            }
            Animator.SetBool(isAttackingHash, true);
        }
        
        private void HandleMovement()
        {
            currentDirection = new Vector3(movementInput.x, 0, movementInput.y).normalized;
            //var currentDirection = IsDashing ? PreviousDirection : currentMovement.normalized;

            if (isOnSlope && isGrounded)
            {
                currentDirection = Vector3.ProjectOnPlane(currentDirection, slopeHit.normal).normalized;
            }

            var moveValue = IsDashing ? DashForce : moveSpeed;
            var newPosition = Rb.position + currentDirection * (moveValue * Time.fixedDeltaTime);

            Rb.MovePosition(newPosition);
            
            // var currentMovement = new Vector3(movementInput.x, 0, movementInput.y);
            // var currentDirection = IsDashing ? PreviousDirection : currentMovement.normalized;
            // var isNextFrameInAngle = CalculateNextFrameGroundAngle(currentDirection) < maxSlopeAngle;
            // var velocity = isNextFrameInAngle ? currentDirection : Vector3.zero;
            // var gravity = Vector3.down * Mathf.Abs(Rb.velocity.y);
            //     
            // if (IsOnSlope() && IsGrounded())
            // {
            //     velocity = Vector3.ProjectOnPlane(currentDirection, slopeHit.normal).normalized;
            //     gravity = Vector3.zero;
            //     Rb.useGravity = false;
            // }
            // else
            // {
            //     Rb.useGravity = true;
            // }
            //
            // var moveValue = IsDashing ? DashForce : moveSpeed;
            // Rb.velocity = velocity * moveValue + gravity;
        }

        public bool IsOnSlope()
        {
            var ray = new Ray(transform.position, Vector3.down);
            
            if (Physics.Raycast(ray, out slopeHit, RAY_DISTANCE, groundLayer))
            {
                var angle = Vector3.Angle(Vector3.up, slopeHit.normal);
                Debug.DrawRay(transform.position, Vector3.down, angle != 0f && angle < maxSlopeAngle ? Color.blue : Color.red);
                return angle != 0f && angle < maxSlopeAngle;
            }
            Debug.DrawRay(transform.position, Vector3.down, Color.red);
            return false;
        }

        private bool IsGrounded()
        {
            var lossyScale = transform.lossyScale;
            var boxSize = new Vector3(lossyScale.x, 0.4f, lossyScale.z * 0.5f);
            return Physics.CheckBox(groundCheck.position, boxSize, Quaternion.identity, groundLayer);
        }

        private float CalculateNextFrameGroundAngle(Vector3 direction)
        {
            var nextFramePlayerPosition = transform.position + direction * (nextFrameCoefficient * moveSpeed * Time.fixedDeltaTime);

            if (Physics.Raycast(nextFramePlayerPosition, Vector3.down, out var hitInfo, RAY_DISTANCE, groundLayer))
            {
                if (Vector3.Angle(Vector3.up, hitInfo.normal) > maxSlopeAngle)
                {
                    Debug.DrawRay(hitInfo.point, hitInfo.normal, Color.red);
                }
                else
                {
                    Debug.DrawRay(hitInfo.point, hitInfo.normal, Color.cyan);
                }
                Debug.DrawRay(nextFramePlayerPosition, Vector3.down, Color.green);
                return Vector3.Angle(Vector3.up, hitInfo.normal);
            }
            Debug.DrawRay(nextFramePlayerPosition, Vector3.down, Color.magenta);
            return 0;
        }
        
        public void AttackTiming()
        {
            var attackDirection = PreviousDirection;
            
            Array.Clear(HitColliders, 0, MaxHitNum);

            var size = Physics.OverlapSphereNonAlloc(transform.position, AttackRange, HitColliders, TargetLayer);

            for (var i = 0; i < size; i++)
            {
                var targetDirection = (HitColliders[i].transform.position - transform.position).normalized;
                var angleBetween = Vector3.Angle(attackDirection, targetDirection);

                if (angleBetween >= AttackAngle * 0.5f) continue;
                
                if (HitColliders[i].gameObject.layer == LayerMask.NameToLayer("Enemy"))
                {
                    var iDamageable = HitColliders[i].transform.GetComponent<IDamageable>();
                    iDamageable.TakeDamage(AttackDamage);
                    VisualFeedbackManager.Inst.TriggerHitStop(0.1f);
                }
                else if (HitColliders[i].gameObject.layer == LayerMask.NameToLayer("Skill") &&
                         HitColliders[i].CompareTag("DestructiveSkill"))
                {
                    var iDamageable = HitColliders[i].transform.GetComponent<IDamageable>();
                    iDamageable.TakeDamage(AttackDamage);
                }
            }
        }

        public void CoolDown(float waitTime, Action onCooldownComplete = null)
        {
            StartCoroutine(CoolDownCoroutine(waitTime, onCooldownComplete));
        }
        
        private IEnumerator CoolDownCoroutine(float waitTime, Action onCooldownComplete = null)
        {
            var time = 0f;

            while (time <= waitTime)
            {
                time += Time.deltaTime;
                yield return null;
            }
            
            onCooldownComplete?.Invoke();
        }
        
        private void SetCurrentHp(float value)
        { 
            currentHp = value;
        }

        public RaycastHit GetSlopeHit() => slopeHit;
    }
}