from math import pi, sin, cos

import random

import sys
from direct.showbase.ShowBase import ShowBase
from direct.task import Task
from panda3d.core import *

class Chunk(ShowBase):
    def __init__(self):
        ShowBase.__init__(self)
        self.disableMouse()

        self.node = GeomNode('Chunk')

        geo_node = self.create_chunk(4)

        self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")

    def spinCameraTask(self, task):
        angleDegrees = task.time * 60.0
        angleRadians = angleDegrees * (pi / 180.0)
        self.camera.setPos(20 * sin(angleRadians), -20.0 * cos(angleRadians), 3)
        self.camera.setHpr(angleDegrees, 0, 0)
        return Task.cont

    def list_3D(self, dim):
        return [[[None for _ in range(dim[2])] for _ in range(dim[1])] for _ in range(dim[0])]

    def create_chunk(self, world_size):
        chunk_data = self.list_3D([world_size, world_size, world_size])
        for i in range(world_size):
            for j in range(world_size):
                for k in range(world_size):
                    b = Block()
                    r = random.randint(0, 100)
                    if r < 25:
                        b.create_block('AIR', (i, j, k))
                    else:
                        b.create_block('DIRT', (i, j, k))
                    chunk_data[i][j][k] = b
        for i in range(world_size):
            for j in range(world_size):
                for k in range(world_size):
                    geo_node = chunk_data[i][j][k].draw_cube(chunk_data, i, j, k)
                    card = self.render.attachNewNode(geo_node)
                    tex = loader.loadTexture('dirt.png')
                    card.setTexture(tex)

class Block:
    def __init__(self):
        self.types = ['GRASS', 'DIRT', 'STONE', 'AIR']
        self.sides = ['BOTTOM', 'TOP', 'LEFT', 'RIGHT', 'FRONT', 'BACK']

        self.block_type = None
        self.block_position = None
        self.is_solid = None

        self.node = GeomNode('Cube')

    def create_block(self, block_type, block_position):
        self.block_type = block_type
        self.block_position = block_position

        if self.block_type == 'AIR':
            self.is_solid = False
        else:
            self.is_solid = True

    def create_cube(self, cube_side, empty):
        format = GeomVertexFormat.getV3n3t2()

        n_forward = (0, 0, 1)
        n_back = (0, 0, -1)
        n_up = (0, 1, 0)
        n_down = (0, -1, 0)
        n_right = (1, 0, 0)
        n_left = (-1, 0, 0)

        p0 = (-0.5, -0.5, 0.5)
        p1 = (0.5, -0.5,  0.5)
        p2 = (0.5, -0.5, -0.5)
        p3 = (-0.5, -0.5, -0.5)
        p4 = (-0.5, 0.5, 0.5)
        p5 = (0.5, 0.5, 0.5)
        p6 = (0.5, 0.5, -0.5)
        p7 = (-0.5, 0.5, -0.5)

        p0 = tuple(l * r for l, r in zip(p0, self.block_position))
        p1 = tuple(l * r for l, r in zip(p1, self.block_position))
        p2 = tuple(l * r for l, r in zip(p2, self.block_position))
        p3 = tuple(l * r for l, r in zip(p3, self.block_position))
        p4 = tuple(l * r for l, r in zip(p4, self.block_position))
        p5 = tuple(l * r for l, r in zip(p5, self.block_position))
        p6 = tuple(l * r for l, r in zip(p6, self.block_position))
        p7 = tuple(l * r for l, r in zip(p7, self.block_position))

        uv00 = (0, 0)
        uv10 = (1, 0)
        uv01 = (0, 1)
        uv11 = (1, 1)

        vertexData = GeomVertexData('Quad', format, Geom.UHStatic)

        vertexData.setNumRows(24)

        vertices = GeomVertexWriter(vertexData, 'vertex')
        normals = GeomVertexWriter(vertexData, 'normal')
        texcoord = GeomVertexWriter(vertexData, 'texcoord')

        geom = Geom(vertexData)

        primitive = GeomTriangles(Geom.UHStatic)

        if cube_side == 'BOTTOM':
            vertices.addData3f(p0)
            vertices.addData3f(p1)
            vertices.addData3f(p2)
            vertices.addData3f(p3)

            normals.addData3f(n_down)
            normals.addData3f(n_down)
            normals.addData3f(n_down)
            normals.addData3f(n_down)
        elif cube_side == 'TOP':
            vertices.addData3f(p7)
            vertices.addData3f(p6)
            vertices.addData3f(p5)
            vertices.addData3f(p4)

            normals.addData3f(n_up)
            normals.addData3f(n_up)
            normals.addData3f(n_up)
            normals.addData3f(n_up)
        elif cube_side == 'LEFT':
            vertices.addData3f(p7)
            vertices.addData3f(p4)
            vertices.addData3f(p0)
            vertices.addData3f(p3)

            normals.addData3f(n_left)
            normals.addData3f(n_left)
            normals.addData3f(n_left)
            normals.addData3f(n_left)
        elif cube_side == 'RIGHT':
            vertices.addData3f(p5)
            vertices.addData3f(p6)
            vertices.addData3f(p2)
            vertices.addData3f(p1)

            normals.addData3f(n_right)
            normals.addData3f(n_right)
            normals.addData3f(n_right)
            normals.addData3f(n_right)
        elif cube_side == 'FRONT':
            vertices.addData3f(p4)
            vertices.addData3f(p5)
            vertices.addData3f(p1)
            vertices.addData3f(p0)

            normals.addData3f(n_forward)
            normals.addData3f(n_forward)
            normals.addData3f(n_forward)
            normals.addData3f(n_forward)
        elif cube_side == 'BACK':
            vertices.addData3f(p6)
            vertices.addData3f(p7)
            vertices.addData3f(p3)
            vertices.addData3f(p2)

            normals.addData3f(n_back)
            normals.addData3f(n_back)
            normals.addData3f(n_back)
            normals.addData3f(n_back)

        if not empty:
            texcoord.addData2f(uv11)
            texcoord.addData2f(uv01)
            texcoord.addData2f(uv00)
            texcoord.addData2f(uv10)

        primitive.addVertices(3, 1, 0)
        primitive.addVertices(3, 2, 1)

        geom.addPrimitive(primitive)

        return geom

    def draw_cube(self, chunks, x, y, z):
        if chunks[x][y][z].block_type == 'AIR':
            for side in self.sides:
                geom = self.create_cube(side, True)
                self.node.addGeom(geom)
            return self.node
        try:
            if not chunks[x][y][z+1].is_solid:
                geom = self.create_cube('FRONT', False)
                self.node.addGeom(geom)
        except:
              geom = self.create_cube('FRONT', True)
              self.node.addGeom(geom)
        try:
            if not chunks[x][y][z-1].is_solid:
                geom = self.create_cube('BACK', False)
                self.node.addGeom(geom)
        except:
            geom = self.create_cube('BACK', True)
            self.node.addGeom(geom)
        try:
            if not chunks[x][y+1][z].is_solid:
                geom = self.create_cube('TOP', False)
                self.node.addGeom(geom)
        except:
            geom = self.create_cube('TOP', True)
            self.node.addGeom(geom)
        try:
            if not chunks[x][y-1][z].is_solid:
                geom = self.create_cube('BOTTOM', False)
                self.node.addGeom(geom)
        except:
            geom = self.create_cube('BOTTOM', True)
            self.node.addGeom(geom)
        try:
            if not chunks[x+1][y][z].is_solid:
                geom = self.create_cube('RIGHT', False)
                self.node.addGeom(geom)
        except:
            geom = self.create_cube('RIGHT', True)
            self.node.addGeom(geom)
        try:
            if not chunks[x-1][y][z].is_solid:
                geom = self.create_cube('LEFT', False)
                self.node.addGeom(geom)
        except:
            geom = self.create_cube('LEFT', True)
            self.node.addGeom(geom)

        return self.node

app = Chunk()
app.run()