using mh;
using System.Collections;
using System.Collections.Generic;
using Unity.VisualScripting;
using UnityEngine;

public enum ColliderType
{
    Collider, 
    Hurtbox,
    Hitbox,
}

/// <summary>
/// 四叉树空间划分，优化碰撞检测
/// </summary>
public partial class PhysicsManager : Singleton<PhysicsManager>
{
    #region Quadtrees
    public Vector4 quadtreeCollisionRange { set { m_QuadtreeCollisionRange = value; } }
    private Vector4 m_QuadtreeCollisionRange;
    private Quadtree m_QuadtreeCollision;
    private List<IQuadTreeObject> m_QuadtreeObjColliders = new List<IQuadTreeObject>();

    public Vector4 quadtreeHurtboxRange { set { m_QuadtreeHurtboxRange = value; } }
    private Vector4 m_QuadtreeHurtboxRange;
    private Quadtree m_QuadtreeHurtboxes;
    private List<IQuadTreeObject> m_QuadtreeObjHurtboxes = new List<IQuadTreeObject>();
    #endregion 
    public List<IQuadTreeObject> sharedRetriveResults => m_SharedRetriveResults;
    private List<IQuadTreeObject> m_SharedRetriveResults = new List<IQuadTreeObject>();

    public PhysicsManager() 
    {
        m_QuadtreeCollision = new Quadtree(0, new Vector4(0, 0, 30, 30));
        m_QuadtreeHurtboxes=  new Quadtree(0, new Vector4(0,0, 30, 30));        
    } 

    public void AddCollider(IQuadTreeObject collider)
    {
        m_QuadtreeObjColliders.Add(collider);
    }

    public void RemoveCollider(IQuadTreeObject collider)
    {
        m_QuadtreeObjColliders.Remove(collider);
    }

    public void AddHurtboxes(IQuadTreeObject hurtbox)
    {
        m_QuadtreeObjHurtboxes.Add(hurtbox);
    }

    public void RemoveHurtbox(IQuadTreeObject hurtbox)
    {
        m_QuadtreeObjHurtboxes.Remove(hurtbox);
    }

    public void UpdateQuadtreeCollision()
    {
        m_QuadtreeCollision.Clear(false);
        m_QuadtreeCollision.Rebound(m_QuadtreeCollisionRange);
        for (int i = 0; i < m_QuadtreeObjColliders.Count; i++) 
        { 
            IQuadTreeObject obj = m_QuadtreeObjColliders[i];
            m_QuadtreeCollision.Insert(obj);
        }
    }

    public void UpdateQuadtreeHurtbox()
    {
        m_QuadtreeHurtboxes.Clear(false);
        m_QuadtreeHurtboxes.Rebound(m_QuadtreeHurtboxRange);
        for (int i = 0; i < m_QuadtreeObjHurtboxes.Count; i++)
        {
            IQuadTreeObject obj = m_QuadtreeObjHurtboxes[i];
            m_QuadtreeHurtboxes.Insert(obj);
        }
    }

    public void Update()
    {
        UpdateQuadtreeCollision();
        UpdateQuadtreeHurtbox();
    }

    public void Debug()
    {
        Color c = Gizmos.color;
        Gizmos.color = Color.red;
        m_QuadtreeCollision?.Iterate((t) => {
            Vector3 pos = new Vector3(t.x, t.y, 0);
            Vector3 size = new Vector3(t.w, t.h, 1);
            Gizmos.DrawWireCube(pos, size);
        });
        Gizmos.color = c;
    }

    public bool RetriveColliders(ref List<IQuadTreeObject> returnObjs, IQuadTreeObject obj)
    {
        return m_QuadtreeCollision.Retrieve(ref returnObjs, obj);       
    }

    public bool RetriveColliders(ref List<IQuadTreeObject> returnObjs, Vector4 bound)
    {
        return m_QuadtreeCollision.Retrieve(ref returnObjs, bound);
    }

    public bool RetriveHurtboxes(ref List<IQuadTreeObject> returnObjs, Vector4 bound)
    {
        return m_QuadtreeHurtboxes.Retrieve(ref returnObjs, bound);
    }

    public bool RetriveColliders(Vector4 bound)
    {
        m_SharedRetriveResults.Clear();
        return m_QuadtreeCollision.Retrieve(ref m_SharedRetriveResults, bound);
    }

    public bool RetriveHurtboxes(Vector4 bound)
    {
        m_SharedRetriveResults.Clear();
        return m_QuadtreeHurtboxes.Retrieve(ref m_SharedRetriveResults, bound);
    }

    public System.Func<Vector4, bool> GetRetriverByType(ColliderType type)
    {
        if (type == ColliderType.Collider)
            return RetriveColliders;
        else if (type == ColliderType.Hurtbox)
            return RetriveHurtboxes;
        else
            return null;
    }

}