package demos.nehe.lesson27;

import javax.media.opengl.*;
import javax.media.opengl.glu.GLUquadric;
import javax.media.opengl.glu.GLU;

import java.io.IOException;

class Renderer implements GLEventListener {
    private GLUquadric quadric;
    private Object3D object3D;

    private float[] LightPos = {0.0f, 5.0f, -4.0f, 1.0f};   // Light Position
    private boolean LightUp, LightDown, LightLeft, LightRight, LightForward, LightBackward;
    private float[] LightAmb = {0.2f, 0.2f, 0.2f, 1.0f};   // Ambient Light Values
    private float[] LightDif = {0.6f, 0.6f, 0.6f, 1.0f};   // Diffuse Light Values
    private float[] LightSpc = {-0.2f, -0.2f, -0.2f, 1.0f}; // Specular Light Values

    private float[] MatAmb = {0.4f, 0.4f, 0.4f, 1.0f};    // Material - Ambient Values
    private float[] MatDif = {0.2f, 0.6f, 0.9f, 1.0f};    // Material - Diffuse Values
    private float[] MatSpc = {0.0f, 0.0f, 0.0f, 1.0f};    // Material - Specular Values
    private float[] MatShn = {0.0f};                      // Material - Shininess

    private float[] SpherePos = {-4.0f, -5.0f, -6.0f};
    private boolean SphereUp, SphereDown, SphereLeft, SphereRight, SphereForward, SphereBackward;
    private float[] ObjPos = {-2.0f, -2.0f, -5.0f};         // Object Position
    private boolean ObjUp, ObjDown, ObjLeft, ObjRight, ObjForward, ObjBackward;

    private float xspeed;                                    // X Rotation Speed
    private boolean increaseXspeed;
    private boolean decreaseXspeed;

    private float yspeed;                                    // Y Rotation Speed
    private boolean increaseYspeed;
    private boolean decreaseYspeed;

    private float xrot;                                      // X Rotation
    private float yrot;                                      // Y Rotation

    private GLU glu = new GLU();

    private boolean initGLObjects() throws IOException {                               // Initialize Objects
        object3D = Object3D.readObject("demos/data/models/object2.txt");
        return object3D != null;                                      // If Failed Return False
    }

    public void translateSphereUp(boolean state) {
        SphereUp = state;
    }

    public void translateSphereDown(boolean state) {
        SphereDown = state;
    }

    public void translateSphereLeft(boolean state) {
        SphereLeft = state;
    }

    public void translateSphereRight(boolean state) {
        SphereRight = state;
    }

    public void translateSphereForward(boolean state) {
        SphereForward = state;
    }

    public void translateSphereBackward(boolean state) {
        SphereBackward = state;
    }

    public void translateLightUp(boolean state) {
        LightUp = state;
    }

    public void translateLightDown(boolean state) {
        LightDown = state;
    }

    public void translateLightLeft(boolean state) {
        LightLeft = state;
    }

    public void translateLightRight(boolean state) {
        LightRight = state;
    }

    public void translateLightForward(boolean state) {
        LightForward = state;
    }

    public void translateLightBackward(boolean state) {
        LightBackward = state;
    }

    public void translateObjectUp(boolean state) {
        ObjUp = state;
    }

    public void translateObjectDown(boolean state) {
        ObjDown = state;
    }

    public void translateObjectLeft(boolean state) {
        ObjLeft = state;
    }

    public void translateObjectRight(boolean state) {
        ObjRight = state;
    }

    public void translateObjectForward(boolean state) {
        ObjForward = state;
    }

    public void translateObjectBackward(boolean state) {
        ObjBackward = state;
    }

    public void increaseXspeed(boolean increase) {
        increaseXspeed = increase;
    }

    public void decreaseXspeed(boolean decrease) {
        decreaseXspeed = decrease;
    }

    public void increaseYspeed(boolean increase) {
        increaseYspeed = increase;
    }

    public void decreaseYspeed(boolean decrease) {
        decreaseYspeed = decrease;
    }

    public void init(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();

        try {
            initGLObjects();
        } catch (IOException e) {
            System.out.println("Couldn't load model");
            throw new RuntimeException(e);
        }

        gl.glShadeModel(GL.GL_SMOOTH);                              // Enable Smooth Shading
        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);                    // Black Background
        gl.glClearDepth(1.0f);                                      // Depth Buffer Setup
        gl.glClearStencil(0);                                       // Stencil Buffer Setup
        gl.glEnable(GL.GL_DEPTH_TEST);                              // Enables Depth Testing
        gl.glDepthFunc(GL.GL_LEQUAL);                               // The Type Of Depth Testing To Do
        gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);  // Really Nice Perspective Calculations

        gl.glLightfv(GL.GL_LIGHT1, GL.GL_POSITION, LightPos, 0);        // Set Light1 Position
        gl.glLightfv(GL.GL_LIGHT1, GL.GL_AMBIENT, LightAmb, 0);        // Set Light1 Ambience
        gl.glLightfv(GL.GL_LIGHT1, GL.GL_DIFFUSE, LightDif, 0);        // Set Light1 Diffuse
        gl.glLightfv(GL.GL_LIGHT1, GL.GL_SPECULAR, LightSpc, 0);        // Set Light1 Specular
        gl.glEnable(GL.GL_LIGHT1);                                  // Enable Light1
        gl.glEnable(GL.GL_LIGHTING);                                // Enable Lighting

        gl.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, MatAmb, 0);         // Set Material Ambience
        gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, MatDif, 0);         // Set Material Diffuse
        gl.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, MatSpc, 0);        // Set Material Specular
        gl.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, MatShn, 0);       // Set Material Shininess

        gl.glCullFace(GL.GL_BACK);                                  // Set Culling Face To Back Face
        gl.glEnable(GL.GL_CULL_FACE);                               // Enable Culling
        gl.glClearColor(0.1f, 1.0f, 0.5f, 1.0f);                    // Set Clear Color (Greenish Color)

        quadric = glu.gluNewQuadric();                              // Initialize Quadratic
        glu.gluQuadricNormals(quadric, GL.GL_SMOOTH);                      // Enable Smooth Normal Generation
        glu.gluQuadricTexture(quadric, false);                             // Disable Auto Texture Coords
    }

    private void drawRoom(GL gl) {                        // Draw The Room (Box)
        gl.glBegin(GL.GL_QUADS);                // Begin Drawing Quads
        // Floor
        gl.glNormal3f(0.0f, 1.0f, 0.0f);      // Normal Pointing Up
        gl.glVertex3f(-10.0f, -10.0f, -20.0f);  // Back Left
        gl.glVertex3f(-10.0f, -10.0f, 20.0f);  // Front Left
        gl.glVertex3f(10.0f, -10.0f, 20.0f);  // Front Right
        gl.glVertex3f(10.0f, -10.0f, -20.0f);  // Back Right