/**

 * ShaderShark

 * Copyright © 2023 František Kučera (Frantovo.cz, GlobalCode.info)

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, version 3 of the License.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program. If not, see <http://www.gnu.org/licenses/>.

 */

#include <iostream>

#include <iomanip>

#include <string>

#include <memory>

#include <functional>

#include <sstream>

#include <vector>

#include "x11.h"

#include "opengl.h"

#include "EPoll.h"

#include "Logger.h"

#include "MappedFile.h"

#include "ImageLoader.h"

#include "Shader.h"

#include "Program.h"

#include "FileMonitor.h"

#include "Shark.h"

class Shark::Impl {

public:

	struct {

		GLint aVertexXYZ = -2;

		GLint aTextureXY = -2;

		GLint fColor = -2;

		GLint uModel = -2;

		GLint uView = -2;

		GLint uProjection = -2;

		GLint uTexture = -2;

	} ProgAttr;

	struct {

		float yaw = -90.f;

		float pitch = 0.f;

		float roll = 0.f;

		float fov = 45.0f;

		glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 3.0f);

		glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);

		glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);

		void adjustFov(float diff) {

			fov += diff;

			if (fov < 1.0f) fov = 1.0f;

			else if (fov > 120.0f) fov = 120.0f;

			std::cerr << "field of view: " << fov << " °" << std::endl;

		}

		void moveForward(const float cameraSpeed) {

			cameraPos += cameraSpeed * cameraFront;

		}

		void moveBackward(const float cameraSpeed) {

			cameraPos -= cameraSpeed * cameraFront;

		}

		void moveLeft(const float cameraSpeed) {

			cameraPos -= glm::normalize(

					glm::cross(cameraFront, cameraUp)) * cameraSpeed;

		}

		void moveRight(const float cameraSpeed) {

			cameraPos += glm::normalize(

					glm::cross(cameraFront, cameraUp)) * cameraSpeed;

		}

		void moveUp(const float cameraSpeed) {

			cameraPos += cameraSpeed * glm::normalize(cameraUp);

		}

		void moveDown(const float cameraSpeed) {

			cameraPos -= cameraSpeed * glm::normalize(cameraUp);

		}

		void updateCameraFrontAndUp() {

			std::cerr << "--- updateCameraFrontAndUp() --------" << std::endl;

			dump("pitch, yaw, roll", glm::vec3(pitch, yaw, roll));

			dump("cameraPos", cameraPos);

			dump("cameraFront", cameraFront);

			const auto pitchR = glm::radians(pitch); // around X axis

			const auto yawR = glm::radians(yaw); //     around Y axis

			const auto rollR = glm::radians(roll); //   around Z axis

			cameraFront.x = cos(pitchR) * cos(yawR);

			cameraFront.y = sin(pitchR);

			cameraFront.z = cos(pitchR) * sin(yawR);

			cameraFront = glm::normalize(cameraFront);

			dump("cameraFront", cameraFront);

			dump("cameraUp", cameraUp);

			// TODO: review ROLL rotation and default angle

			glm::mat4 rollMatrix = glm::rotate(

					glm::mat4(1.0f), rollR, cameraFront);

			cameraUp = glm::mat3(rollMatrix) * glm::vec3(0., 1., 0.);

			dump("cameraUp", cameraUp);

			std::cerr << "-------------------------------------" << std::endl;

		}

		void limitPitch() {

			if (pitch > +89.0f) pitch = +89.0f;

			if (pitch < -89.0f) pitch = -89.0f;

		}

		void turnLeft(const float angleSpeed) {

			yaw -= angleSpeed;

			updateCameraFrontAndUp();

		}

		void turnRight(const float angleSpeed) {

			yaw += angleSpeed;

			updateCameraFrontAndUp();

		}

		void turnUp(const float angleSpeed) {

			pitch += angleSpeed;

			limitPitch();

			updateCameraFrontAndUp();

		}

		void turnDown(const float angleSpeed) {

			pitch -= angleSpeed;

			limitPitch();

			updateCameraFrontAndUp();

		}

		void rollLeft(const float angleSpeed) {

			roll += angleSpeed;

			updateCameraFrontAndUp();

		}

		void rollRight(const float angleSpeed) {

			roll -= angleSpeed;

			updateCameraFrontAndUp();

		}

	} initialCtx, ctx;

	class Texture {

	public:

		GLuint id;

		std::string fileName;

		int width;

		int height;

		GLfloat getRatio() const {

			return (GLfloat) width / (GLfloat) height;

		}

	};

	Display* dpy;

	Window win;

	XVisualInfo* vi;

	GLXContext glc;

	FileMonitor fileMonitor;

	std::vector<WatchedFile> watchedFiles;

	ImageLoader imageLoader;

	std::vector<std::shared_ptr<Shader>> shaders;

	std::shared_ptr<Program> shaderProgram;

	std::vector<Texture> textures;

	Configuration cfg;

	std::ostream& logOutput = std::cerr;

	Impl(Configuration cfg) : cfg(cfg) {

	}

	void run();

	void clear();

	void runShaders();

	Window getRootWindow(Window defaultValue);

	void log(LogLevel level, std::string message);

	int setNonBlocking(int fd);

	void loadVertices();

	Texture loadTexture(const std::string& fileName);

	void updateTexture(Texture& tex, const Buffer& file);

	bool reloadTexture(const std::string& fileName);

	void loadTextures();

	std::shared_ptr<Program> loadShaders();

	bool reloadShader(const std::string& fileName);

	void setTitle(const std::string& suffix = "");

	static const std::string getDefaultFile(const std::string& relativePath);

};

Shark::Shark(const Configuration& configuration) :

impl(new Impl(configuration)) {

}

Shark::~Shark() {

	// TODO: more SBRM

	impl->shaders.clear();

	impl->shaderProgram = nullptr;

	XFree(impl->vi);

	// for (auto page : pdfTextures) glDeleteTextures(1, &page.texture);

	glXMakeCurrent(impl->dpy, None, NULL);

	glXDestroyContext(impl->dpy, impl->glc);

	XDestroyWindow(impl->dpy, impl->win);

	XCloseDisplay(impl->dpy);

	delete impl;

	// std::cerr << "~Shark()" << std::endl;

}

void Shark::Impl::setTitle(const std::string& suffix) {

	std::stringstream title;

	title << "ShaderShark";

	if (suffix.size()) title << ": " << suffix.c_str();

	XStoreName(dpy, win, title.str().c_str());

	XFlush(dpy);

}

void Shark::run() {

	impl->run();

}

void Shark::Impl::run() {

	dpy = XOpenDisplay(NULL);

	if (dpy == NULL) throw std::logic_error("Unable to connect to X server");

	GLint att[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};

	vi = glXChooseVisual(dpy, 0, att);

	Window root = DefaultRootWindow(dpy);

	Window parent = cfg.rootWindow ? cfg.rootWindow : root;

	XSetWindowAttributes swa;

	swa.colormap = XCreateColormap(dpy, parent, vi->visual, AllocNone);

	swa.event_mask = ExposureMask | KeyPressMask | PointerMotionMask

			| ButtonPressMask

			| StructureNotifyMask;

	bool full = false;

	unsigned int width = 1600;

	unsigned int height = 1200;

	if (parent != root) {

		XWindowAttributes parentAttr;

		XGetWindowAttributes(dpy, parent, &parentAttr);

		width = parentAttr.width;

		height = parentAttr.height;

	}

	win = XCreateWindow(

			dpy, parent, 0, 0, width, height, 0,

			vi->depth, InputOutput, vi->visual,

			CWColormap | CWEventMask, &swa);

	XMapWindow(dpy, win);

	setTitle();

	setX11PID(dpy, win);

	// XSetWindowBackground(dpy, win, 0) vs. glClearColor()

	glc = glXCreateContext(dpy, vi, NULL, GL_TRUE);

	glXMakeCurrent(dpy, win, glc);

	glEnable(GL_DEPTH_TEST);

	glEnable(GL_BLEND);

	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	clear();

	glXSwapBuffers(dpy, win);

	// Load GLSL shaders:

	shaderProgram = loadShaders();

	loadTextures();

	loadVertices();

	auto toggleFullscreen = [&]() {

		full = setFullscreen(dpy, win, !full);

	};

	auto resetView = [&]() {

		ctx = initialCtx;

		ctx.updateCameraFrontAndUp();

	};

	// root can reize our window

	// or we can listen to root resize and then resize our window ourselves

	bool listenToRootResizes = true;

	if (listenToRootResizes) XSelectInput(dpy, parent, StructureNotifyMask);

	bool keepRunningX11 = true;

	int x11fd = XConnectionNumber(dpy);

	EPoll epoll;

	epoll.add(x11fd);

	epoll.add(fileMonitor.getFD());

	try {

		epoll.add(setNonBlocking(STDIN_FILENO));

	} catch (const EPoll::Exception& e) {

		logOutput << "Will not monitor events on STDIN: " << e.what() << "\n";

	}

	// rended the 3D scene even before the first event:

	runShaders();

	glXSwapBuffers(dpy, win);

	for (XEvent xev; keepRunningX11;) {

		int epollEventCount = epoll.wait();

		//std::cout << "trace: epoll.wait() = " << epollEventCount << std::endl;

		for (int epollEvent = 0; epollEvent < epollEventCount; epollEvent++) {

			bool redraw = false;

			if (epoll[epollEvent].data.fd == x11fd) {

				if (!XPending(dpy)) {

					// otherwise STDIN events are held until the first X11 event

					logOutput << "trace: no pending X11 event" << std::endl;

					break;

				}

				XWindowAttributes gwa;

				XNextEvent(dpy, &xev);

				if (xev.type == Expose) {

					std::cout << "XEvent: Expose" << std::endl;

					XGetWindowAttributes(dpy, win, &gwa);

					glViewport(0, 0, gwa.width, gwa.height);

					redraw = true;

				} else if (xev.type == KeyPress) {

					DecodedKey key = decodeKeycode(dpy, xev.xkey.keycode);

					std::cout << "XEvent: KeyPress:"

							<< " keycode=" << key.code

							<< " key=" << key.name

							<< std::endl;

					const float cSp = 0.05f; // camera speed

					const float aSp = 5.f; // angle speed

					if (key.matches(XK_q, XK_Escape)) keepRunningX11 = false;

					else if (key.matches(XK_Left, XK_s)) ctx.turnLeft(aSp);

					else if (key.matches(XK_Right, XK_f)) ctx.turnRight(aSp);

					else if (key.matches(XK_Up, XK_e)) ctx.moveForward(cSp);

					else if (key.matches(XK_Down, XK_d)) ctx.moveBackward(cSp);

					else if (key.matches(XK_w)) ctx.rollLeft(aSp);

					else if (key.matches(XK_r)) ctx.rollRight(aSp);

					else if (key.matches(XK_t)) ctx.turnUp(aSp);

					else if (key.matches(XK_g)) ctx.turnDown(aSp);

					else if (key.matches(XK_m)) ctx.moveLeft(cSp);

					else if (key.matches(XK_comma)) ctx.moveRight(cSp);

					else if (key.matches(XK_l)) ctx.moveUp(cSp);

					else if (key.matches(XK_period)) ctx.moveDown(cSp);

					else if (key.matches(XK_j)) ctx.moveLeft(cSp * 5);

					else if (key.matches(XK_k)) ctx.moveRight(cSp * 5);

					else if (key.matches(XK_u)) ctx.moveLeft(cSp * 10);

					else if (key.matches(XK_i)) ctx.moveRight(cSp * 10);

					else if (key.matches(XK_x)) resetView();

					else if (key.matches(XK_F11, XK_y)) toggleFullscreen();

					redraw = true;

				} else if (xev.type == ButtonPress) {

					std::cout << "XEvent: ButtonPress:"

							<< " button=" << xev.xbutton.button

							<< std::endl;

					if (xev.xbutton.button == 1);

					else if (xev.xbutton.button == 4) ctx.adjustFov(-1.0);

					else if (xev.xbutton.button == 5) ctx.adjustFov(+1.0);

					else if (xev.xbutton.button == 8) resetView();

					else if (xev.xbutton.button == 9) keepRunningX11 = false;

					redraw = true;

				} else if (xev.type == MotionNotify) {

					// printCursorInfo(xev.xmotion);

				} else if (xev.type == ConfigureNotify) {

					std::cout << "XEvent: ConfigureNotify:"

							<< " window=" << xev.xconfigure.window

							<< " height=" << xev.xconfigure.height

							<< " width=" << xev.xconfigure.width

							<< std::endl;

					if (listenToRootResizes

							&& xev.xconfigure.window == parent) {

						XResizeWindow(dpy, win,

								xev.xconfigure.width, xev.xconfigure.height);

					}

				} else if (xev.type == UnmapNotify) {

					std::cout << "XEvent: UnmapNotify" << std::endl;

				} else if (xev.type == DestroyNotify) {

					std::cout << "XEvent: DestroyNotify → finish" << std::endl;

					break;

				} else {

					std::cout << "XEvent: type=" << xev.type << std::endl;

				}

			} else if (epoll[epollEvent].data.fd == STDIN_FILENO) {

				int epollFD = epoll[epollEvent].data.fd;

				logOutput << "other event: fd=" << epollFD << " data=";

				for (char ch; read(epollFD, &ch, 1) > 0;) {

					std::stringstream msg;

					msg

							<< std::hex

							<< std::setfill('0')

							<< std::setw(2)

							<< (int) ch;

					logOutput << msg.str();

				}

				logOutput << std::endl;

			} else if (epoll[epollEvent].data.fd == fileMonitor.getFD()) {

				std::cout << "FileMonitor event:" << std::endl;

				for (FileEvent fe; fileMonitor.readEvent(fe);) {

					logOutput << "   "

							<< " file=" << fe.fileName

							<< " mask=" << fe.mask

							<< std::endl;

					try {

						redraw |= reloadTexture(fe.fileName);

						redraw |= reloadShader(fe.fileName);

						setTitle();

					} catch (const std::exception& e) {

						setTitle("[ERROR]");

						logOutput << "error while reloading '"

								<< fe.fileName.c_str()

								<< "': " << e.what() << std::endl;

					}

				}

			} else {

				logOutput

						<< "error: event on an unexpected FD: "

						<< epoll[epollEvent].data.fd

						<< std::endl;

			}

			if (redraw) {

				runShaders();

				glXSwapBuffers(dpy, win);

			}

		}

	}

}

void Shark::Impl::clear() {

	glClearColor(

			(cfg.backgroundColor >> 16 & 0xFF) / 256.,

			(cfg.backgroundColor >> 8 & 0xFF) / 256.,

			(cfg.backgroundColor & 0xFF) / 256.,

			1.0);

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

}

void Shark::Impl::runShaders() {

	shaderProgram->use();

	checkError(&std::cerr);

	clear();

	GLint viewport[4];

	glGetIntegerv(GL_VIEWPORT, viewport);

	GLfloat width = viewport[2];

	GLfloat height = viewport[3];

	glm::mat4 projection = glm::perspective(

			glm::radians(ctx.fov),

			width / height,

			0.1f, 100.0f);

	glUniformMatrix4fv(ProgAttr.uProjection, 1, GL_FALSE, &projection[0][0]);

	glm::mat4 view = glm::lookAt(

			ctx.cameraPos,

			ctx.cameraPos + ctx.cameraFront,

			ctx.cameraUp);

	glUniformMatrix4fv(ProgAttr.uView, 1, GL_FALSE, &view[0][0]);

	// glBindVertexArray(vao);

	glm::mat4 model = glm::mat4(1.0f); // identity matrix

	// model = glm::translate(model, glm::vec3(0., 0., 0.));

	// float angle = 20.0f;

	// glm::vec3 xxx = glm::vec3(1.0f, 0.3f, 0.5f);

	// model = glm::rotate(model, glm::radians(angle), xxx);

	glUniformMatrix4fv(ProgAttr.uModel, 1, GL_FALSE, &model[0][0]);

	glDrawArrays(GL_TRIANGLES, 0, 2 * 3); // viz loadVertices() kde plníme data

	std::cerr << "GLSL: glDrawArrays()" << std::endl;

}

void Shark::Impl::log(LogLevel level, std::string message) {

	::log(logOutput, level, message);

}

int Shark::Impl::setNonBlocking(int fd) {

	int flags = fcntl(fd, F_GETFL, 0);

	fcntl(fd, F_SETFL, flags | O_NONBLOCK);

	return fd;

}

void Shark::Impl::loadVertices() {

	for (int i = 0; i < textures.size(); i++) {

		const Texture& tex = textures[i];

		GLfloat ratio = tex.getRatio();

		const std::vector<GLfloat> vertices = {

			// Vertex XYZ                      Texture XY

			-0.80f * ratio, +0.80f, +0.0, /**/ 0.0, 0.0,