using OpenTK.Mathematics;

namespace RubyDung;

public class World
{
    private Shader shader;

    // private Chunk chunk;
    // private Chunk[,,] chunks;
    private Dictionary<Vector3, Chunk> chunks = new Dictionary<Vector3, Chunk>();

    // private byte[,,] blocks;
    private Dictionary<Vector3, byte> blocks = new Dictionary<Vector3, byte>();

    private int chunkSize = 16;

    public Vector3i worldSize = new Vector3i(256, 256, 16);

    private int xChunks;
    private int yChunks;
    private int zChunks;

    private int viewDistance = 1;

    public World(Shader shader)
    {
        this.shader = shader;

        viewDistance *= chunkSize;

        // blocks = new byte[worldSize.X, worldSize.Y, worldSize.Z];

        for (int x = -viewDistance; x < viewDistance; x++)
        {
            for (int y = -viewDistance; y < viewDistance; y++)
            {
                for (int z = 0; z < worldSize.Z; z++)
                {
                    // blocks[x, y, z] = 1;
                    blocks[new Vector3(x, y, z)] = 1;
                }
            }
        }

        // chunk = new Chunk(shader, this, 0, 0, 0, 16, 16, 16);

        xChunks = viewDistance / chunkSize;
        yChunks = viewDistance / chunkSize;
        zChunks = worldSize.Z / chunkSize;

        // chunks = new Chunk[xChunks, yChunks, zChunks];

        //*
        for (int x = -xChunks; x < xChunks; x++)
        {
            for (int y = -yChunks; y < yChunks; y++)
            {
                for (int z = 0; z < zChunks; z++)
                {
                    int x0 = x * chunkSize;
                    int y0 = y * chunkSize;
                    int z0 = z * chunkSize;

                    int x1 = (x + 1) * chunkSize;
                    int y1 = (y + 1) * chunkSize;
                    int z1 = (z + 1) * chunkSize;

                    // chunks[x, y, z] = new Chunk(shader, this, x0, y0, z0, x1, y1, z1);
                    chunks[new Vector3(x, y, z)] = new Chunk(shader, this, x0, y0, z0, x1, y1, z1);
                }
            }
        }
        //*/
    }

    public void OnLoad()
    {
        //*
        // foreach (Chunk chunk in chunks)
        foreach (Chunk chunk in chunks.Values)
        {
            chunk.OnLoad();
        }   
        //*/     
    }

    public void OnUpdateFrame(Camera camera)
    {   
        // Calcular qual chunk o jogador está
        int posX = (int)Math.Floor(camera.cameraPos.X / chunkSize);
        int posY = (int)Math.Floor(camera.cameraPos.Y / chunkSize);

        // int blockGenerated = 0;

        for (int x = posX - viewDistance; x < posX + viewDistance; x++)
        {
            for (int y = posY - viewDistance; y < posY + viewDistance; y++)
            {
                for (int z = 0; z < worldSize.Z; z++)
                {
                    if (!blocks.ContainsKey(new Vector3(x, y, z)))
                    {
                        blocks[new Vector3(x, y, z)] = 1;

                        // blockGenerated++;
                    }
                }
            }
        }

        // Debug.Log($"Blocos gerados: {blockGenerated}");

        // Debug.Log($"Position: {posX}, {posY}; Chunk: {xChunks}, {yChunks}");

        //*
        for (int x = posX - xChunks; x < posX + xChunks; x++)
        {
            for (int y = posY - yChunks; y < posY + yChunks; y++)
            {
                for (int z = 0; z < zChunks; z++)
                {
                    if (!chunks.ContainsKey(new Vector3(x, y, z)))
                    {
                        // Debug.Log($"Novo chunk criado em: {x}, {y}, {z}");

                        int x0 = x * chunkSize;
                        int y0 = y * chunkSize;
                        int z0 = z * chunkSize;

                        int x1 = (x + 1) * chunkSize;
                        int y1 = (y + 1) * chunkSize;
                        int z1 = (z + 1) * chunkSize;

                        chunks[new Vector3(x, y, z)] = new Chunk(shader, this, x0, y0, z0, x1, y1, z1);

                        chunks[new Vector3(x, y, z)].OnLoad();
                    }
                }
            }
        }
        //*/

        // Debug.Log($"Renderizando {chunks.Count} chunks");

        // foreach (Chunk chunk in chunks)
        foreach (Chunk chunk in chunks.Values)
        {
            chunk.OnUpdateFrame();
        }
    }

    public void OnRenderFrame()
    {
        // foreach (Chunk chunk in chunks)
        foreach (Chunk chunk in chunks.Values)
        {
            chunk.OnRenderFrame();
        }
    }

    public bool IsTile(int x, int y, int z)
    {
        if (x >= -viewDistance && x < viewDistance)
        {
            if (y >= -viewDistance && y < viewDistance)
            {
                if (z >= 0 && z < worldSize.Z)
                {
                    // return blocks[x, y, z] == 1;
                    return blocks.ContainsKey(new Vector3(x, y, z));
                }
            }
        }

        return false;
    }

    public bool IsSolidTile(int x, int y, int z)
    {
        return IsTile(x, y, z);
    }

    public List<AABB> GetCubes(AABB other)
    {
        List<AABB> cubes = new List<AABB>();

        int x0 = (int)other.x0 - 1;
        int y0 = (int)other.y0 - 1;
        int z0 = (int)other.z0 - 1;

        int x1 = (int)other.x1 + 1;
        int y1 = (int)other.y1 + 1;
        int z1 = (int)other.z1 + 1;

        /*
        // Arredonda para baixo os limites mínimos
        int x0 = (int)Math.Floor(other.x0);
        int y0 = (int)Math.Floor(other.y0);
        int z0 = (int)Math.Floor(other.z0);

        // Arredonda para cima os limites máximos
        int x1 = (int)Math.Ceiling(other.x1);
        int y1 = (int)Math.Ceiling(other.y1);
        int z1 = (int)Math.Ceiling(other.z1);
        */

        //*
        if (x0 < -viewDistance)
        {
            x0 = -viewDistance;
        }
        if (y0 < -viewDistance)
        {
            y0 = -viewDistance;
        }
        if (z0 < 0)
        {
            z0 = 0;
        }

        if (x1 > viewDistance)
        {
            x1 = viewDistance;
        }
        if (y1 > viewDistance)
        {
            y1 = viewDistance;
        }
        if (z1 > worldSize.Z)
        {
            z1 = worldSize.Z;
        }
        //*/

        // Limita as coordenadas aos limites do mundo
        /*
        x0 = Math.Max(x0, -viewDistance);
        y0 = Math.Max(y0, -viewDistance);
        z0 = Math.Max(z0, 0);

        x1 = Math.Min(x1, viewDistance);
        y1 = Math.Min(y1, viewDistance);
        z1 = Math.Min(z1, worldSize.Z);
        */

        for (int x = x0; x < x1; x++)
        {
            for (int y = y0; y < y1; y++)
            {
                for (int z = z0; z < z1; z++)
                {
                    if (IsSolidTile(x, y, z))
                    {
                        cubes.Add(new AABB(
                            (float)x, (float)y, (float)z,
                            (float)x + 1.0f, (float)y + 1.0f, (float)z + 1.0f
                        ));
                    }
                }
            }
        }

        return cubes;
    }
}