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

public class Chunk : MonoBehaviour {

    public const int chunkStack = 10;
    public const int width = 16, height = 25;

    public static Dictionary<Vector3, Chunk> chunks = new Dictionary<Vector3, Chunk>();
    public static bool Working = false;

    public List<byte[,,]> maps = new List<byte[,,]>();
    public List<MeshFilter> meshes = new List<MeshFilter>();
    public List<MeshCollider> colliders = new List<MeshCollider>();

    public List<List<Vector3>> verts = new List<List<Vector3>>();
    public List<List<int>> triangles = new List<List<int>>();
    public List<List<Vector2>> uvs = new List<List<Vector2>>();
    public List<List<Color>> colors = new List<List<Color>>();

    public byte[,,] map = new byte[width,height,width];
    public byte[,] heightMap = new byte[width,width];

    public bool dirty = true;
    public bool lightDirty = true;
    public bool calculateMap = false;

    public Vector3 chunkPos;
    public bool canGenerateMesh = false;

    void Awake ()
    {
        transform.parent = World.me;

        for(int i = 0; i < chunkStack; i++)
        {
            maps.Add(new byte[width,height,width]);
            GameObject go = new GameObject("ChunkStack " + i);

            colliders.Add(go.AddComponent<MeshCollider>());
            meshes.Add(go.AddComponent<MeshFilter>());
            MeshRenderer me = go.AddComponent<MeshRenderer>();

            go.transform.position = new Vector3(transform.position.x, i * height, transform.position.z);
            go.transform.parent = transform;

            me.material = World.mats;
        }

        heightMap = (new byte[width,width]);
    }

    void Update ()
    {
        if(canGenerateMesh) return;

        Chunk right = GetChunk(chunkPos + new Vector3(width, 0, 0));
        Chunk left = GetChunk(chunkPos + new Vector3(-width, 0, 0));

        Chunk back = GetChunk(chunkPos + new Vector3(0, 0, width));
        Chunk front = GetChunk(chunkPos + new Vector3(0, 0, -width));

        Chunk up = GetChunk(chunkPos + new Vector3(0 , height, 0));
        Chunk down = GetChunk(chunkPos + new Vector3(0, -height, 0));

        if(right != null && right.calculateMap &&
            left != null && left.calculateMap &&
            front != null && front.calculateMap &&
            back != null && back.calculateMap &&
            up != null && up.calculateMap &&
            down != null && down.calculateMap)
        {
            canGenerateMesh = true;
        }
    }

    public void CMap()
    {
        Working = false;

        System.Random r = new System.Random();

        for(int i = 0; i < chunkStack; i++)
        {
            byte[,,] map = new byte[width, height, width];

            for(int x = 0; x < width; x++)
            {
                for(int y = 0; y < height; y++)
                {
                    for(int z = 0; z < width; z++)
                    {
                        int worldYPos = (i * height) + y;

                        if(worldYPos == height)
                        {
                            SetWorldBlock(chunkPos + new Vector3(x,y,z), 4);
                        }
                        else if(worldYPos < height + 5)
                        {
                            //map[x,y,z] = 1;
                            SetWorldBlock(chunkPos + new Vector3(x,y,z), 1);
                        }
                        else if(worldYPos == height + 5 && r.Next(0,25) == 1)
                        {
                            SetWorldBlock(chunkPos + new Vector3(x,y,z), 3);
                        }
                    }
                }
            }

            maps[i] = map;
        }
    }

    public void CMesh()
    {
        verts.Clear();
        triangles.Clear();
        uvs.Clear();
        colors.Clear();

        for(int i = 0; i < chunkStack; i++)
        {
            byte[,,] map = maps[i];

            for(int x = 0; x < width; x++)
            {
                for(int y = 0; y < height; y++)
                {
                    for(int z = 0; z < width; z++)
                    {
                        if(map[x,y,z] > 0)
                        {
                            if(isBlockTransparent(x, y + 1, z, i))
                                AddFace(x, y, z, FaceDir.Top, i);
                            if(isBlockTransparent(x, y - 1, z, i))
                                AddFace(x, y, z, FaceDir.Bottom, i);
                            if(isBlockTransparent(x + 1, y, z, i))
                                AddFace(x, y, z, FaceDir.Right, i);
                            if(isBlockTransparent(x - 1, y, z, i))
                                AddFace(x, y, z, FaceDir.Left, i);
                            if(isBlockTransparent(x, y, z + 1, i))
                                AddFace(x, y, z, FaceDir.Front, i);
                            if(isBlockTransparent(x, y, z - 1, i))
                                AddFace(x, y, z, FaceDir.Back, i);
                        }
                    }
                }
            }

            if(verts.Count <= i) continue;
            Mesh m = new Mesh();

            m.vertices = verts[i].ToArray();
            m.triangles = triangles[i].ToArray();
            m.uv = uvs[i].ToArray();
            m.colors = colors[i].ToArray();

            m.RecalculateNormals();

            meshes[i].mesh = m;
            colliders[i].sharedMesh = m;
        }

        Working = false;
    }

    public void CLight()
    {
        Working = false;
    }

    public void AddFace (int x, int y, int z, FaceDir dir, int chunkID)
    {
        if(verts.Count >= chunkID)
        {
            verts.Add(new List<Vector3>());
        }
        if(triangles.Count >= chunkID)
        {
            triangles.Add(new List<int>());
        }
        if(uvs.Count >= chunkID)
        {
            uvs.Add(new List<Vector2>());
        }
        if(colors.Count >= chunkID)
        {
            colors.Add(new List<Color>());
        }

        float blockWidth = (float)1 / (float)16;

        byte blockID = (byte)(maps[chunkID][x,y,z] - 1);

        int xOffset = Block.blocks[blockID].textureXSide;
        int yOffset = Block.blocks[blockID].textureYSide;

        int BxOffset = Block.blocks[blockID].textureXBottom;
        int ByOffset = Block.blocks[blockID].textureYBottom;

        int TxOffset = Block.blocks[blockID].textureXTop;
        int TyOffset = Block.blocks[blockID].textureYTop;

        /*if(chunkPos.y + y < heightMap[x,z])
        {
            colors[chunkID].Add(Color.red);
            colors[chunkID].Add(Color.red);
            colors[chunkID].Add(Color.red);
            colors[chunkID].Add(Color.red);
        }
        else
        {
            colors[chunkID].Add(Color.white);
            colors[chunkID].Add(Color.white);
            colors[chunkID].Add(Color.white);
            colors[chunkID].Add(Color.white);
        }*/

        colors[chunkID].Add(Color.white);
        colors[chunkID].Add(Color.white);
        colors[chunkID].Add(Color.white);
        colors[chunkID].Add(Color.white);


        if(dir == FaceDir.Top)
        {
            triangles[chunkID].Add(verts[chunkID].Count + 0);
            triangles[chunkID].Add(verts[chunkID].Count + 2);
            triangles[chunkID].Add(verts[chunkID].Count + 1);

            triangles[chunkID].Add(verts[chunkID].Count + 0);
            triangles[chunkID].Add(verts[chunkID].Count + 3);
            triangles[chunkID].Add(verts[chunkID].Count + 2);

            verts[chunkID].Add((new Vector3(x + 0, y + 1, z + 0)));
            verts[chunkID].Add((new Vector3(x + 1, y + 1, z + 0)));
            verts[chunkID].Add((new Vector3(x + 1, y + 1, z + 1)));
            verts[chunkID].Add((new Vector3(x + 0, y + 1, z + 1)));

            uvs[chunkID].Add(new Vector2((0 + TxOffset) * blockWidth, (0 + TyOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((1 + TxOffset) * blockWidth, (0 + TyOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((1 + TxOffset) * blockWidth, (1 + TyOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((0 + TxOffset) * blockWidth, (1 + TyOffset) * blockWidth));
        }
        else if(dir == FaceDir.Bottom)
        {
            triangles[chunkID].Add(verts[chunkID].Count + 1);
            triangles[chunkID].Add(verts[chunkID].Count + 2);
            triangles[chunkID].Add(verts[chunkID].Count + 0);

            triangles[chunkID].Add(verts[chunkID].Count + 2);
            triangles[chunkID].Add(verts[chunkID].Count + 3);
            triangles[chunkID].Add(verts[chunkID].Count + 0);

            verts[chunkID].Add((new Vector3(x + 0, y + 0, z + 0)));
            verts[chunkID].Add((new Vector3(x + 1, y + 0, z + 0)));
            verts[chunkID].Add((new Vector3(x + 1, y + 0, z + 1)));
            verts[chunkID].Add((new Vector3(x + 0, y + 0, z + 1)));

            uvs[chunkID].Add(new Vector2((0 + BxOffset) * blockWidth, (0 + ByOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((1 + BxOffset) * blockWidth, (0 + ByOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((1 + BxOffset) * blockWidth, (1 + ByOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((0 + BxOffset) * blockWidth, (1 + ByOffset) * blockWidth));
        }
        else if(dir == FaceDir.Front)
        {
            triangles[chunkID].Add(verts[chunkID].Count + 1);
            triangles[chunkID].Add(verts[chunkID].Count + 2);
            triangles[chunkID].Add(verts[chunkID].Count + 0);

            triangles[chunkID].Add(verts[chunkID].Count + 2);
            triangles[chunkID].Add(verts[chunkID].Count + 3);
            triangles[chunkID].Add(verts[chunkID].Count + 0);

            verts[chunkID].Add((new Vector3(x + 0, y + 0, z + 1)));
            verts[chunkID].Add((new Vector3(x + 1, y + 0, z + 1)));
            verts[chunkID].Add((new Vector3(x + 1, y + 1, z + 1)));
            verts[chunkID].Add((new Vector3(x + 0, y + 1, z + 1)));

            uvs[chunkID].Add(new Vector2((0 + xOffset) * blockWidth, (0 + yOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((1 + xOffset) * blockWidth, (0 + yOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((1 + xOffset) * blockWidth, (1 + yOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((0 + xOffset) * blockWidth, (1 + yOffset) * blockWidth));
        }
        else if(dir == FaceDir.Back)
        {
            triangles[chunkID].Add(verts[chunkID].Count + 0);
            triangles[chunkID].Add(verts[chunkID].Count + 2);
            triangles[chunkID].Add(verts[chunkID].Count + 1);

            triangles[chunkID].Add(verts[chunkID].Count + 0);
            triangles[chunkID].Add(verts[chunkID].Count + 3);
            triangles[chunkID].Add(verts[chunkID].Count + 2);

            verts[chunkID].Add((new Vector3(x + 0, y + 0, z + 0)));
            verts[chunkID].Add((new Vector3(x + 1, y + 0, z + 0)));
            verts[chunkID].Add((new Vector3(x + 1, y + 1, z + 0)));
            verts[chunkID].Add((new Vector3(x + 0, y + 1, z + 0)));

            uvs[chunkID].Add(new Vector2((0 + xOffset) * blockWidth, (0 + yOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((1 + xOffset) * blockWidth, (0 + yOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((1 + xOffset) * blockWidth, (1 + yOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((0 + xOffset) * blockWidth, (1 + yOffset) * blockWidth));
        }
        else if(dir == FaceDir.Right)
        {
            triangles[chunkID].Add(verts[chunkID].Count + 0);
            triangles[chunkID].Add(verts[chunkID].Count + 2);
            triangles[chunkID].Add(verts[chunkID].Count + 1);

            triangles[chunkID].Add(verts[chunkID].Count + 0);
            triangles[chunkID].Add(verts[chunkID].Count + 3);
            triangles[chunkID].Add(verts[chunkID].Count + 2);

            verts[chunkID].Add((new Vector3(x + 1, y + 0, z + 0)));
            verts[chunkID].Add((new Vector3(x + 1, y + 0, z + 1)));
            verts[chunkID].Add((new Vector3(x + 1, y + 1, z + 1)));
            verts[chunkID].Add((new Vector3(x + 1, y + 1, z + 0)));

            uvs[chunkID].Add(new Vector2((0 + xOffset) * blockWidth, (0 + yOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((1 + xOffset) * blockWidth, (0 + yOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((1 + xOffset) * blockWidth, (1 + yOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((0 + xOffset) * blockWidth, (1 + yOffset) * blockWidth));
        }
        else if(dir == FaceDir.Left)
        {
            triangles[chunkID].Add(verts[chunkID].Count + 1);
            triangles[chunkID].Add(verts[chunkID].Count + 2);
            triangles[chunkID].Add(verts[chunkID].Count + 0);

            triangles[chunkID].Add(verts[chunkID].Count + 2);
            triangles[chunkID].Add(verts[chunkID].Count + 3);
            triangles[chunkID].Add(verts[chunkID].Count + 0);

            verts[chunkID].Add((new Vector3(x + 0, y + 0, z + 0)));
            verts[chunkID].Add((new Vector3(x + 0, y + 0, z + 1)));
            verts[chunkID].Add((new Vector3(x + 0, y + 1, z + 1)));
            verts[chunkID].Add((new Vector3(x + 0, y + 1, z + 0)));

            uvs[chunkID].Add(new Vector2((0 + xOffset) * blockWidth, (0 + yOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((1 + xOffset) * blockWidth, (0 + yOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((1 + xOffset) * blockWidth, (1 + yOffset) * blockWidth));
            uvs[chunkID].Add(new Vector2((0 + xOffset) * blockWidth, (1 + yOffset) * blockWidth));
        }
    }

    public bool isBlockTransparent(int x, int y, int z, int chunkID)
    {
        if(x >= width || z >= width || y >= height || x < 0 || y < 0 || z < 0)
        {
            //return true;
            return GetWorldBlock(new Vector3(x,y + (chunkID * height), z) + chunkPos) == 0;
        }
        else
        {
            return(maps[chunkID][x,y,z] == 0);
        }
    }

    public static byte GetWorldBlock(Vector3 pos)
    {
        Chunk c = Chunk.GetChunk(pos);
        if(c == null) return 1;

        Vector3 localPos = pos - c.chunkPos;

        int chunkID = Mathf.FloorToInt(localPos.y / height);

        int x = (int)localPos.x;
        int y = (int)localPos.y - (chunkID * height);
        int z = (int)localPos.z;

        if (chunkID > 9 || chunkID < 0 || x < 0 || y < 0 || z < 0 || x > 15 || y > 15 || z > 15)
        {
            return 0;
        }
        else
        {
            byte block = c.maps[chunkID][x, y, z];
            return block;
        }
    }

    public static Chunk SetWorldBlock(Vector3 pos, byte blockID)
    {
        Chunk c = Chunk.GetChunk(pos);
        if(c == null) return null;

        Vector3 localPos = pos - c.chunkPos;

        int chunkID = Mathf.FloorToInt(localPos.y / height);

        if(chunkID >= chunkStack || chunkID < 0)
            return null;

        int x = (int)localPos.x;
        int y = (int)localPos.y - (chunkID * height);
        int z = (int)localPos.z;

        int worldY = ((chunkID * height) + y);

        c.maps[chunkID][x,y,z] = blockID;

        /*if(c.heightMap[x,z] < worldY)
        {
            c.heightMap[x,z] = (byte)worldY;
        }*/
        return c;
    }

    public static Chunk GetChunk(Vector3 pos)
    {
        int x = Mathf.FloorToInt(pos.x / width) * width;
        int y = 0;
        int z = Mathf.FloorToInt(pos.z / width) * width;

        Vector3 cPos = new Vector3(x, y, z);
        if(chunks.ContainsKey(cPos))
        {
            return chunks[cPos];
        }

        return null;
    }

    public static bool ChunkExists(Vector3 pos)
    {
        int x = Mathf.FloorToInt(pos.x / width) * width;
        int y = 0;
        int z = Mathf.FloorToInt(pos.z / width) * width;

        Vector3 cPos = new Vector3(x, y, z);
        if(chunks.ContainsKey(cPos))
        {
            return true;
        }

        return false;
    }

    public static bool AddChunk(Vector3 pos)
    {
        int x = Mathf.FloorToInt(pos.x / width) * width;
        int y = Mathf.FloorToInt(pos.y / width) * width;
        int z = Mathf.FloorToInt(pos.z / width) * width;

        Vector3 cPos = new Vector3(x, y, z);
        if(chunks.ContainsKey(cPos))
        {
            return false;
        }

        GameObject chunk = new GameObject("Chunk" + cPos);

        Chunk c = chunk.AddComponent<Chunk>();
        MeshRenderer mr = chunk.AddComponent<MeshRenderer>();
        chunk.AddComponent<MeshFilter>();

        chunk.transform.position = cPos;

        mr.material = World.mats;

        chunks.Add(cPos, c);
        return true;
    }
    public static bool RemoveChunk(Vector3 pos)
    {
        int x = Mathf.FloorToInt(pos.x / width) * width;
        int y = Mathf.FloorToInt(pos.y / width) * width;
        int z = Mathf.FloorToInt(pos.z / width) * width;

        Vector3 cPos = new Vector3(x, y, z);
        if(chunks.ContainsKey(cPos))
        {
            Destroy(chunks[cPos].gameObject);
            chunks.Remove(cPos);
            return true;
        }
        return false;
    }
}

public enum FaceDir
{
    Top,
    Bottom,
    Right,
    Left,
    Front,
    Back,
}

public class Block
{
    public static List<Block> blocks = new List<Block>();
    public string displayName;
    public string name;
    public byte id;

    public byte textureXSide;
    public byte textureYSide;

    public byte textureXTop;
    public byte textureYTop;

    public byte textureXBottom;
    public byte textureYBottom;

    public Block (string name, string displayName, byte tX, byte tY)
    {
        id = (byte)(blocks.Count + 1);
        this.name = name;
        this.displayName = displayName;

        textureXSide = tX;
        textureXTop = tX;
        textureXBottom = tX;

        textureYSide = tY;
        textureYTop = tY;
        textureYBottom = tY;
    }

    public Block (string name, string displayName, byte tX, byte tY, byte sX, byte sY)
    {
        id = (byte)(blocks.Count + 1);
        this.name = name;
        this.displayName = displayName;

        textureXSide = sX;
        textureXTop = tX;
        textureXBottom = tX;

        textureYSide = sY;
        textureYTop = tY;
        textureYBottom = tY;
    }

    public Block (string name, string displayName, byte tX, byte tY, byte sX, byte sY, byte bX, byte bY)
    {
        id = (byte)(blocks.Count + 1);
        this.name = name;
        this.displayName = displayName;

        textureXSide = sX;
        textureXTop = tX;
        textureXBottom = bX;

        textureYSide = sY;
        textureYTop = tY;
        textureYBottom = bY;
    }
}