package com.jogamp.opencl.demos.julia3d;

import com.jogamp.opencl.demos.julia3d.structs.RenderingConfig;
import com.jogamp.opengl.util.awt.TextRenderer;
import java.awt.Canvas;
import java.awt.Font;
import java.nio.FloatBuffer;
import java.util.Timer;
import java.util.TimerTask;
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;

import static com.jogamp.common.nio.Buffers.*;
import static javax.media.opengl.GL2.*;
import static java.lang.String.*;

/**
 * JOGL renderer for displaying the julia set.
 * @author Michael Bien
 */
public class Renderer implements GLEventListener {

    public final static int MU_RECT_SIZE = 80;

    private final Julia3d julia3d;
    private final GLCanvas canvas;
    private final RenderingConfig config;
    private final FloatBuffer juliaSlice;
    private final UserSceneController usi;
    private final TextRenderer textRenderer;

    private TimerTask task;
    private final Timer timer;

    public Renderer(final Julia3d julia3d) {
        
        this.julia3d = julia3d;
        this.config = julia3d.config;

        timer = new Timer(true);

        juliaSlice = newDirectFloatBuffer(MU_RECT_SIZE * MU_RECT_SIZE * 4);

        canvas = new GLCanvas(new GLCapabilities(GLProfile.get(GLProfile.GL2)));
        canvas.addGLEventListener(this);

        usi = new UserSceneController();
        usi.init(this, canvas, config);

        textRenderer = new TextRenderer(new Font("Helvetica", Font.BOLD, 14), true, true, null, false);

    }

    public void init(GLAutoDrawable drawable) {
        drawable.getGL().getGL2().glMatrixMode(GL_PROJECTION);
    }

    void update() {
        julia3d.update(false);
        canvas.display();
    }

    public void display(GLAutoDrawable drawable) {

        //compute
        julia3d.compute(config.getActvateFastRendering() == 1);

        GL2 gl = drawable.getGL().getGL2();
        gl.glClear(GL_COLOR_BUFFER_BIT);

        // draw julia set
	gl.glRasterPos2i(0, 0);
	gl.glDrawPixels(config.getWidth(), config.getHeight(), GL_RGB, GL_FLOAT, julia3d.getPixelBuffer());


        // Draw Mu constant
        int width = config.getWidth();
        int height = config.getHeight();
        float[] mu = config.getMu();

	gl.glEnable(GL_BLEND);
            gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
            int baseMu1 = width - MU_RECT_SIZE - 2;
            int baseMu2 = 1;
            drawJuliaSlice(gl, baseMu1, baseMu2, mu[0], mu[1]);
            int baseMu3 = width - MU_RECT_SIZE - 2;
            int baseMu4 = MU_RECT_SIZE + 2;
            drawJuliaSlice(gl, baseMu3, baseMu4, mu[2], mu[3]);
	gl.glDisable(GL_BLEND);

	gl.glColor3f(1, 1, 1);
	int mu1 = (int) (baseMu1 + MU_RECT_SIZE * (mu[0] + 1.5f) / 3.f);
	int mu2 = (int) (baseMu2 + MU_RECT_SIZE * (mu[1] + 1.5f) / 3.f);
	gl.glBegin(GL_LINES);
            gl.glVertex2i(mu1 - 4, mu2);
            gl.glVertex2i(mu1 + 4, mu2);
            gl.glVertex2i(mu1, mu2 - 4);
            gl.glVertex2i(mu1, mu2 + 4);
	gl.glEnd();

	int mu3 = (int) (baseMu3 + MU_RECT_SIZE * (mu[2] + 1.5f) / 3.f);
	int mu4 = (int) (baseMu4 + MU_RECT_SIZE * (mu[3] + 1.5f) / 3.f);
	gl.glBegin(GL_LINES);
            gl.glVertex2i(mu3 - 4, mu4);
            gl.glVertex2i(mu3 + 4, mu4);
            gl.glVertex2i(mu3, mu4 - 4);
            gl.glVertex2i(mu3, mu4 + 4);
	gl.glEnd();

        // info text
        textRenderer.beginRendering(width, height);
        textRenderer.draw(format("Epsilon %.5f - Max. Iter. %d", config.getEpsilon(), config.getMaxIterations()), 8, 10);
        textRenderer.draw(format("Mu = (%.3f, %.3f, %.3f, %.3f)", mu[0], mu[1], mu[2], mu[3]), 8, 25);
        textRenderer.draw(format("Shadow %s - SuperSampling %dx%d - Fast rendering %s",
			config.getEnableShadow() == 1 ? "on" : "off",
                        config.getSuperSamplingSize(), config.getSuperSamplingSize(),
			config.getActvateFastRendering() == 1 ? "on" : "off"), 8, 40);
        textRenderer.endRendering();

        // timer task scheduling, delay gpu intensive high quality rendering
        if(task != null) {
            task.cancel();
        }
        if(config.getActvateFastRendering() == 1) {
            task = new TimerTask() {
                @Override
                public void run() {
                    config.setActvateFastRendering(0);
                    update();
                    config.setActvateFastRendering(1);
                }
            };
            timer.schedule(task, 2000);
        }
    }

    private void drawJuliaSlice(GL2 gl, int origX, int origY, float cR, float cI) {

        int index = 0;
        float invSize = 3.0f / MU_RECT_SIZE;
        for (int i = 0; i < MU_RECT_SIZE; ++i) {
            for (int j = 0; j < MU_RECT_SIZE; ++j) {

                float x = i * invSize - 1.5f;
                float y = j * invSize - 1.5f;

                int iter;
                for (iter = 0; iter < 64; ++iter) {
                    float x2 = x * x;
                    float y2 = y * y;
                    if (x2 + y2 > 4.0f) {
                        break;
                    }

                    float newx = x2 - y2 + cR;
                    float newy = 2.f * x * y + cI;
                    x = newx;
                    y = newy;
                }
                
                juliaSlice.put(index++, iter / 64.0f);
                juliaSlice.put(index++, 0.0f);
                juliaSlice.put(index++, 0.0f);
                juliaSlice.put(index++, 0.5f);
            }
        }

	gl.glRasterPos2i(origX, origY);
	gl.glDrawPixels(MU_RECT_SIZE, MU_RECT_SIZE, GL_RGBA, GL_FLOAT, juliaSlice);
    }


    public void reshape(GLAutoDrawable drawable, int x, int y, int newWidth, int newHeight) {

        config.setWidth(newWidth);
	config.setHeight(newHeight);

        GL2 gl = drawable.getGL().getGL2();

	gl.glViewport(0, 0, newWidth, newHeight);
	gl.glLoadIdentity();
	gl.glOrtho(-0.5f, newWidth - 0.5f, -0.5f, newHeight - 0.5f, -1.0f, 1.0f);

        julia3d.update(true);

    }

    public void dispose(GLAutoDrawable drawable) {
    }

    public Canvas getCanvas() {
        return canvas;
    }


}