using JetBrains.Annotations;
using System.Collections;
using System.Collections.Generic;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.UIElements;
using WK.Rendering;

namespace MH
{

    public class UnitManager
    {
        public static UnitBase hero; 
    }

    public class SamuraiScript : UnitBase
    {
        [SerializeField] private WaypointScript m_Waypoint;
        [SerializeField] private float m_Speed;
        [SerializeField] private BladeScript m_Blade;
        [SerializeField] private GameObject m_GroundBreak;

        private SpriteRenderer m_Sprite;
        private bool m_Moving;
        private Camera m_Camera;
        private float m_TimeSinceLastMove;
        private const float kKeepMovingThreshold = 0.4f;
        private bool m_IsKeepMoving = false;
        private Coroutine m_CoWaypoint;
        private bool m_Attacking = false;
        private bool m_IsKeepAttacking = false;

        private void Awake()
        {
            UnitManager.hero = this;
        }

        void Start()
        {
            m_Camera = Camera.main;
            m_Moving = true;
            m_Sprite = GetComponent<SpriteRenderer>();
            m_TimeSinceLastMove = float.MaxValue;
            StartCoroutine(CoAttack(1f));
            StartCoroutine(CoStrike(1f));
        }

        protected override void Update()
        {
            base.Update();
            Move();
            LookAt();
        }

        private void LookAt()
        {
            Vector3 pos = transform.position;
            Vector3 camPos = m_Camera.transform.position;
            camPos.x = pos.x;
            camPos.y = pos.y;
            m_Camera.transform.position = camPos;
        }

        private void Move()
        {
            if(Input.GetMouseButtonDown(0)) 
            { 
                float dt = Time.time - m_TimeSinceLastMove;     
                if(dt > 0 && dt < kKeepMovingThreshold) 
                {
                    m_IsKeepMoving = true;
                }
                else
                {
                    m_IsKeepMoving = false;
                }
            }

            m_Attacking = true;//Input.GetMouseButton(1);

            if (Input.GetMouseButton(0) || m_IsKeepMoving)
            {
                m_Moving = true;

                Vector3 mousePos = Input.mousePosition;
                Vector3 mousePos3D = m_Camera.ScreenToWorldPoint(mousePos);
                mousePos3D.z = 0;

                Vector3 pos = transform.position;
                pos.z = 0;

                Vector3 toward = mousePos3D - pos;
                toward.z = 0;

                if (toward.magnitude < 0.1f)
                {
                    return;
                }

                Vector3 dir = (mousePos3D - pos).normalized;
                dir.z = 0;

                //pos.x += Time.deltaTime;
                transform.position += dir * Time.deltaTime * m_Speed;

                m_Sprite.flipX = dir.x <= 0;

                if(m_CoWaypoint == null)
                {
                    m_CoWaypoint = StartCoroutine(CoShowWaypoint(0.05f));
                }
            }
            else
            {
                if(m_CoWaypoint != null)
                {
                    StopCoroutine(m_CoWaypoint);
                    m_CoWaypoint = null;
                }

                m_Moving = false;
            }

            GetComponent<SpriteAnimationController>().playing = m_Moving ? true : false;

            if(Input.GetMouseButtonUp(0)) 
            {
                m_TimeSinceLastMove = Time.time;
            }
        }

        IEnumerator CoShowWaypoint(float dt)
        {
            while (true)
            {
                WaypointScript waypoint  = Instantiate(m_Waypoint) as WaypointScript;
                Vector3 mousePos = Input.mousePosition;
                Vector3 mousePos3D = m_Camera.ScreenToWorldPoint(mousePos);
                mousePos3D.z = 0; 
                waypoint.transform.position = mousePos3D;
                waypoint.life = 1;
                yield return new WaitForSeconds(dt);
            }
        }

        IEnumerator CoAttack(float interval)
        {
            int fac = 1;
            while (true)
            {
                if (!m_Attacking)
                {
                    yield return null;
                }
                else
                {
                    Vector3 mousePos = Input.mousePosition;
                    Vector3 mousePos3D = m_Camera.ScreenToWorldPoint(mousePos);
                    Vector2 dir = (mousePos3D.xy() - transform.position.xy()).normalized;
                    BladeScript blade = Instantiate(m_Blade);
                    blade.life = 5f;
                    blade.transform.position = transform.position + new Vector3(1 * fac, 1f, 0);
                    blade.SetFlip(fac == -1);
                    blade.dir = dir;
                    fac *= -1;
                    yield return new WaitForSeconds(interval);
                }
            }
        }

        IEnumerator CoStrike(float interval)
        {
            int fac = 1;
            while (true)
            {
                if (!m_Attacking)
                {
                    yield return null;
                }
                else
                {
                    yield return new WaitForSeconds(interval);
                    yield return new WaitForFixedUpdate();
                    Strike();
                }
            }
        }

        private void Strike()
        {
            Vector3 pos = transform.position;

            float radius = 2;

            var go = Instantiate(m_GroundBreak);
            go.transform.position = pos;
            go.gameObject.SetActive(true);
            go.transform.localScale *= radius / 1.7f;

            var colliders = PhysicsManager.Instance.CircleCast(ColliderType.Hurtbox, new Vector3(pos.x, pos.y, radius));
            if (colliders.Count != 0)
            {
                for(int i = 0; i < colliders.Count; ++i)
                {
                    go = (colliders[i] as MonoBehaviour).gameObject;
                    if(go != this.gameObject)
                    {
                        GameObject.Destroy(go);
                    }
                }
            }
        }

    }

}