import pygame
from pygame.locals import *

from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.arrays import vbo
from OpenGL.GL import shaders
import numpy
import transformations
from math import pi, radians
from PIL import Image

def init(screen_size):
    screen = pygame.display.set_mode(screen_size, HWSURFACE | OPENGL | DOUBLEBUF)

    glViewport(0, 0, screen_size[0], screen_size[1])

    glShadeModel(GL_SMOOTH)
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)

    viewport = glGetIntegerv(GL_VIEWPORT)

    glEnable(GL_DEPTH_TEST)
    glDepthFunc(GL_LESS)

    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    #glFrustum(-1.0, 1.0,  1.0, -1.0,  1, 100.0)
    gluPerspective(45, 1, 1, 100)


    glMatrixMode(GL_MODELVIEW)
    glLoadIdentity()

        VERTEX_SHADER = shaders.compileShader(
    """
    #version 130
    in vec2 vertTexCoord;
    out vec2 fragTexCoord;

        void main() {
        fragTexCoord = vertTexCoord;
            gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
        }""", GL_VERTEX_SHADER)


        FRAGMENT_SHADER = shaders.compileShader(
    """#version 130
    uniform sampler2D tex;
    in vec2 fragTexCoord;
    out vec4 finalColor;

        void main() {
            finalColor = texture(tex, fragTexCoord);
        }""", GL_FRAGMENT_SHADER)


    return shaders.compileProgram(VERTEX_SHADER,FRAGMENT_SHADER)

def display(vertexbuffer, texturebuffer, texID, texloc, shader, zoom, x, y):
    glLoadIdentity()
    glClearColor(0.5, 0.5, 0.5, 1)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    gluLookAt(x, y+2, 5 + 0.1*zoom, x, y, 0, 0, 1, 0)
    shaders.glUseProgram(shader)

    vertexbuffer.bind()
    glEnableClientState(GL_VERTEX_ARRAY)
        glVertexPointer(3, GL_FLOAT, 16, vertexbuffer)


    texturebuffer.bind()



    glEnableClientState(GL_TEXTURE_COORD_ARRAY)
    glTexCoordPointer(2, GL_FLOAT, 0, texturebuffer)

    glActiveTexture(GL_TEXTURE0)
    glBindTexture(GL_TEXTURE_2D, texID)
    glUniform1i(texloc, 0)


    glDrawArrays(GL_TRIANGLES, 0, 36)
    vertexbuffer.unbind()
    texturebuffer.unbind()
        glDisableClientState(GL_VERTEX_ARRAY)
    glDisableClientState(GL_TEXTURE_COORD_ARRAY)
    shaders.glUseProgram(0)

    pygame.display.flip()





class Cube():
    def __init__(self, center, size, colors):
        self.v = numpy.array([
        [ center[0]-size/2, center[1]-size/2, center[2]-size/2, 1], #0 bottom lower left
        [ center[0]+size/2, center[1]-size/2, center[2]-size/2, 1], #1 bottom lower right
        [ center[0]+size/2, center[1]+size/2, center[2]-size/2, 1], #2 bottom upper right
        [ center[0]-size/2, center[1]+size/2, center[2]-size/2, 1], #3 bottom upper left
        [ center[0]-size/2, center[1]-size/2, center[2]+size/2, 1], #4 top lower left
        [ center[0]+size/2, center[1]-size/2, center[2]+size/2, 1], #5 top lower right
        [ center[0]+size/2, center[1]+size/2, center[2]+size/2, 1], #6 top upper right
        [ center[0]-size/2, center[1]+size/2, center[2]+size/2, 1]]) #7 top upper left
        self.colors = colors

    def get_trivertices(s):
        return numpy.array([
        s.v[0], s.v[1], s.v[5], #front bottom
        s.v[0], s.v[4], s.v[5], #front top

        s.v[1], s.v[2], s.v[5], #right bottom
        s.v[2], s.v[6], s.v[5], #right top

        s.v[2], s.v[3], s.v[6], #back bottom
        s.v[3], s.v[7], s.v[6], #back top

        s.v[0], s.v[4], s.v[7], #left bottom
        s.v[0], s.v[3], s.v[7], #left top

        s.v[4], s.v[5], s.v[7], #top bottom
        s.v[6], s.v[7], s.v[5], #top top

        s.v[0], s.v[1], s.v[3], #bottom bottom
        s.v[2], s.v[3], s.v[1]]) #bottom top


def main():
    pygame.init()
    shader = init([640, 640])

    Clock = pygame.time.Clock()

    camera_vel = [0, 0]
    camera_pos = [0, 0]

    camera_maxvel = 0.1
    camera_accel = 0.02
    camera_damping = 0.9

    vel_threshold = 0.001

    zoom_level = 0
    current_zoom = 0
    zoom_time = 1
    min_zoom = -35
    max_zoom = 100
    zoom_threshold = 0.01


    rotmatrix = transformations.rotation_matrix(radians(1), [0, 1, 0], [0, 0, 0])

    cube = Cube([0, 0, 0], 2, [[1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 1, 0], [0, 1, 1], [1, 0, 1]])


    #TEXTURE STUFF START
    pixels = numpy.array(list(Image.open("hazard.png").getdata()), 'B').astype('f')

    glEnable(GL_TEXTURE_2D)

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)

    glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB, 256, 256, 0, GL_RGBA, GL_INT, pixels)
    texturedata = [[0, 0], [1, 0], [0, 0.5]]*12

    texturebuffer = vbo.VBO(numpy.array(texturedata).astype('f'))

    texloc = glGetUniformLocation(shader, "tex")
    texID = glGenTextures(1)
    #TEXTURE STUFF END


    while True:
        events = pygame.event.get()
        for event in events:
            if event.type == MOUSEBUTTONUP:
                if event.button == 4:
                    zoom_level = max(min_zoom, zoom_level-1)
                if event.button == 5:
                    zoom_level = min(max_zoom, zoom_level+1)
            elif event.type == KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    exit()
        current_zoom -= (current_zoom - zoom_level)/float(zoom_time)

        if abs(current_zoom - zoom_level) < zoom_threshold:
            current_zoom = zoom_level
        keys = pygame.key.get_pressed()
        keys = [k for k, x in enumerate(keys) if x]
        if (K_LEFT in keys or K_RIGHT in keys) and not (K_LEFT in keys and K_RIGHT in keys):
            if K_LEFT in keys:
                camera_vel[0] -= camera_accel
            else:
                camera_vel[0] += camera_accel

        if (K_UP in keys or K_DOWN in keys) and not (K_UP in keys and K_DOWN in keys):
            if K_UP in keys:
                camera_vel[1] += camera_accel
            else:
                camera_vel[1] -= camera_accel

        camera_vel[0] *= camera_damping
        camera_vel[1] *= camera_damping

                if abs(camera_vel[0]) < vel_threshold:
                        camera_vel[0] = 0
                if abs(camera_vel[1]) < vel_threshold:
                        camera_vel[1] = 0

                camera_vel = map(lambda x: max(min(camera_maxvel, x), -camera_maxvel), camera_vel)

        camera_pos[0] += camera_vel[0]
        camera_pos[1] += camera_vel[1]

        cube.v = numpy.dot(cube.v, rotmatrix.T).astype('f')

        vertices = cube.get_trivertices()
        vertexbuffer = vbo.VBO(vertices)

        display(vertexbuffer, texturebuffer, texID, texloc, shader, current_zoom, *camera_pos)
        Clock.tick(60)

if __name__ == '__main__':
    main()