/*
George Zhang
Window class.
*/

package geetransit.minecraft05.engine;

import org.lwjgl.glfw.*;
import org.lwjgl.opengl.*;

import static org.lwjgl.glfw.Callbacks.*;
import static org.lwjgl.glfw.GLFW.*;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.system.MemoryUtil.*;

public class Window {
	private long handle;
	private Timer timer;
	private Object lock;
	public final Bucket next;
	
	private String title;
	private int xPos;
	private int yPos;
	private int width;
	private int height;
	private int mode;
	
	public static final int WINDOWED = 0;
	public static final int BORDERLESS = 1;
	public static final int FULLSCREEN = 2;
	
	private boolean vSync;
	private int targetFps;
	private int targetUps;
	
	private float elapsedTime;
	private float accumulatedTime;
	
	private boolean destroyed = false;
	
	private long monitor;
	private GLFWVidMode vidmode;
	
	public Window(
		String title,
		int width,
		int height,
		int mode,
		boolean vSync,
		int targetFps,
		int targetUps
	) {
		this.title = title;
		this.width = width;
		this.height = height;
		this.mode = mode;
		
		this.vSync = vSync;
		this.targetFps = targetFps;
		this.targetUps = targetUps;
		
		this.timer = new Timer();
		this.lock = new Object();
		this.next = new Bucket();
	}
	
	public void createWindow() {
		// Setup an error callback. The default implementation
		// will print the error message in System.err.
		GLFWErrorCallback.createPrint(System.err).set();

		// Initialize GLFW. Most GLFW functions will not work before doing this.
		if (!glfwInit())
			throw new IllegalStateException("Unable to initialize GLFW");

		// Configure our window
		glfwDefaultWindowHints(); // optional, the current window hints are already the default
		glfwWindowHint(GLFW_VISIBLE, GL_FALSE); // the window will stay hidden after creation
		glfwWindowHint(GLFW_RESIZABLE, GL_TRUE); // the window will be resizable
		glfwWindowHint(GLFW_FOCUSED, GL_TRUE); // get focus when shown

		// Get the resolution of the primary monitor
		this.monitor = glfwGetPrimaryMonitor();
		this.vidmode = glfwGetVideoMode(monitor);
		
		// Create the window
		this.handle = glfwCreateWindow(this.width, this.height, this.title, NULL, NULL);
		if (this.handle == NULL)
			throw new RuntimeException("Failed to create the GLFW window");

        // Setup resize callback
        glfwSetFramebufferSizeCallback(this.handle, (window, width, height) -> {
			if (width > 0 && height > 0)
				this.next.add("size", () -> {
					if (this.isWindowed())
						this.setSize(width, height);
				});
        });

		// Center our window
		this.xPos = this.getCenteredXPos();
		this.yPos = this.getCenteredYPos();
		this.updateWindowMonitor();
	}
	
	public void eventThread() {
		this.eventLoop();
		this.eventDestroy();
		this.eventTerminate();
	}
	
	private void eventLoop() {
		// Make the window visible
		glfwShowWindow(this.handle);
		
		while (!glfwWindowShouldClose(this.handle)) {
			// Only force focus when in borderless fullscreen
			if (this.isBorderless())
				glfwFocusWindow(this.handle);
			// This will block until an event occurs.
			// (Helps reduce CPU usage.)
			glfwWaitEvents();
		}
	}
	
	private void eventDestroy() {
		synchronized (this.lock) {
			this.destroyed = true;
			// Release window (safely)
			glfwDestroyWindow(this.handle);
		}
		// Release window callbacks
		glfwFreeCallbacks(this.handle);
	}
	
	public void eventTerminate() {
		// Terminate GLFW and release the error function
		glfwTerminate();
		glfwSetErrorCallback(null).free();
	}
	
	public void renderThread(Scene scene) {
		try {
			this.renderInit(scene);
			this.renderLoop(scene);
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		} finally {
			scene.cleanup();
		}
	}
	
	private void renderInit(Scene scene) throws Exception {
		// This adds the OpenGL context into this function.
		glfwMakeContextCurrent(this.handle);
		
		// This line is critical for LWJGL's interoperation with GLFW's
		// OpenGL context, or any context that is managed externally.
		// LWJGL detects the context that is current in the current thread,
		// creates the ContextCapabilities instance and makes the OpenGL
		// bindings available for use.
		GL.createCapabilities();
		
		// Check vSync
		glfwSwapInterval(this.isVSync() ? 1 : 0);
		
		// init
		scene.init(this);
		
		// Start timer.
		this.timer.init();
	}
	
	// Render loop.
	private void renderLoop(Scene scene) {
		while (!this.isDestroyed()) {
			this.elapsedTime = this.timer.getElapsedTime();
			this.accumulatedTime += this.elapsedTime;
			
			// bucket
			this.next.run("mode");
			this.next.run("size");
			this.next.run("vSync");
			this.next.run("inputMode");
			this.next.run("attrib");
			this.next.run("targetFps");
			this.next.run("targetUps");
			
			// input
			scene.input(this);
			
			// update
			float interval = 1f / this.getTargetUps();
			while (this.accumulatedTime >= interval) {
				scene.update(interval);
				this.accumulatedTime -= interval;
			}
			
			// render
			scene.render(this);
			this.renderUpdate();
			if (!this.isVSync())
				this.renderSync();
		}
	}
	
	// Sync with target FPS.
	private void renderSync() {
		float loopSlot = 1f / this.getTargetFps();
		double endTime = this.timer.getLastLoopTime() + loopSlot;
		while (timer.getTime() < endTime && this.next.empty()) {
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
			}
		}
	}
	
	private void renderUpdate() {
		// This can fail if not sync'd. (Can only swap when window exists)
		synchronized (this.lock) {
			if (!this.destroyed)
				glfwSwapBuffers(this.handle); // swap the color buffers
		}
	}
	
	protected void updateWindowPos() {
		int[] xPos = new int[1];
		int[] yPos = new int[1];
		glfwGetWindowPos(this.getHandle(), xPos, yPos);
		this.xPos = xPos[0];
		this.yPos = yPos[0];
	}
	
	protected void updateWindowMonitor() {
		this.setAttrib(GLFW_DECORATED, this.isBorderless() ? 0 : 1);
		glfwSetWindowMonitor(
			this.getHandle(), this.getCurrentMonitor(), this.getXPos(), this.getYPos(),
			this.getWidth(), this.getHeight(), GLFW_DONT_CARE
		);
	}
	
	protected void updateSwapInterval(boolean vSync) { glfwSwapInterval(vSync ? 1 : 0); }
	protected void updateSwapInterval() { this.updateSwapInterval(this.isVSync()); }
	protected long getCurrentMonitor() { return this.isFullscreen() ? this.monitor : NULL; }
	
	public void setShouldClose(boolean shouldClose) { glfwSetWindowShouldClose(this.getHandle(), true); }
	public void clear(int bits) { glClear(bits); }
	public void clearColor(float r, float g, float b, float a) { glClearColor(r, g, b, a); }
	
	public GLFWKeyCallback setKeyCallback(GLFWKeyCallbackI keyCallback) { return glfwSetKeyCallback(this.getHandle(), keyCallback); }
	public void setAttrib(int attrib, int value)  { glfwSetWindowAttrib(this.getHandle(), attrib, value); }
	public long getAttrib(int attrib)             { return glfwGetWindowAttrib(this.getHandle(), attrib); }
	public void setInputMode(int mode, int value) { glfwSetInputMode(this.getHandle(), mode, value); }
	public long getInputMode(int mode)            { return glfwGetInputMode(this.getHandle(), mode); }
	public int getKey(int key)                    { return glfwGetKey(this.getHandle(), key); }
	public boolean isKeyDown(int key)             { return (this.getKey(key) == GLFW_PRESS); }
	public void postEmptyEvent()                  { glfwPostEmptyEvent(); }
	
	public long getHandle()           { return this.handle; }
	public Object getLock()           { return this.lock; }
	public boolean isDestroyed()      { return this.destroyed; }
	public float getElapsedTime()     { return this.elapsedTime; }
	public float getAccumulatedTime() { return this.accumulatedTime; }
	
	public int getTargetFps()               { return this.targetFps; }
	public int getTargetUps()               { return this.targetUps; }
	public void setTargetFps(int targetFps) { this.targetFps = targetFps; }
	public void setTargetUps(int targetFps) { this.targetUps = targetUps; }
	
	// width, height
	public int getWidth()        { return !this.isWindowed() ? this.getScreenWidth() : this.getWindowWidth(); }
	public int getHeight()       { return !this.isWindowed() ? this.getScreenHeight() : this.getWindowHeight(); }
	public int getWindowWidth()  { return this.width; }
	public int getWindowHeight() { return this.height; }
	public int getScreenWidth()  { return this.vidmode.width(); }
	public int getScreenHeight() { return this.vidmode.height(); }
	// xpos, ypos
	public int getXPos()         { return !this.isWindowed() ? this.getScreenXPos() : this.getWindowXPos(); }
	public int getYPos()         { return !this.isWindowed() ? this.getScreenYPos() : this.getWindowYPos(); }
	public int getWindowXPos()   { return this.xPos; }
	public int getWindowYPos()   { return this.yPos; }
	public int getScreenXPos()   { return 0; }
	public int getScreenYPos()   { return 0; }
	public int getCenteredXPos() { return !this.isWindowed() ? 0 : (this.getScreenWidth() - this.getWindowWidth()) / 2; }
	public int getCenteredYPos() { return !this.isWindowed() ? 0 : (this.getScreenHeight() - this.getWindowHeight()) / 2; }
	// setter
	public void setSize(int width, int height) {
		this.width = width;
		this.height = height;
		this.updateWindowPos();
		glViewport(0, 0, this.getWidth(), this.getHeight());
		this.updateWindowMonitor();
	}
	
	public int getMode()          { return this.mode; }
	public boolean isWindowed()   { return this.mode == WINDOWED; }
	public boolean isBorderless() { return this.mode == BORDERLESS; }
	public boolean isFullscreen() { return this.mode == FULLSCREEN; }
	public void setMode(int mode) {
		if (this.isWindowed())
			this.updateWindowPos();
		this.mode = mode;
		if (this.isFullscreen())
			// workaround to ensure vSync is correct after real fullscreen
			this.next.add("vSync", () -> this.setVSync(this.isVSync()));
		glViewport(0, 0, this.getWidth(), this.getHeight());
		this.updateWindowMonitor();
	}
	
	public boolean isVSync() { return this.vSync; }
	public void setVSync(boolean vSync) {
		this.vSync = vSync;
		this.updateSwapInterval();
	}
}