#include <fstream>
#include <iostream>
#include <iterator>
#include <string>

#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include <imgui.h>
#include <imgui_impl_glfw.h>
#include <imgui_impl_opengl3.h>
#include <imgui_md.h>

ImFont * g_font_regular;
ImFont * g_font_bold;
ImFont * g_font_bold_large;

struct Markdown : public imgui_md
{
	ImFont * get_font() const override
	{
		if (m_is_table_header)
		{
			return g_font_bold;
		}
		switch (m_hlevel)
		{
		case 0:
			return m_is_strong ? g_font_bold : g_font_regular;
		case 1:
			return g_font_bold_large;
		default:
			return g_font_bold;
		}
	}
};

static void glfw_error_callback(int error, const char * description)
{
	std::cerr << "glfw (" << error << "): " << description << std::endl;
}

static void markdown(const char * str, const char * str_end)
{
	static Markdown s_printer;
	s_printer.print(str, str_end);
}

ImVec2 g_window_size;

static void resized(GLFWwindow *, int width, int height)
{
	g_window_size.x = static_cast<float>(width);
	g_window_size.y = static_cast<float>(height);
}

static void print_usage(const char * program)
{
	std::cerr << "Usage: " << program << " FILE" << std::endl;
}

int main(int argc, char ** argv)
{
	if (2 != argc)
	{
		print_usage(argv[0]);
		return 2;
	}

	glfwSetErrorCallback(glfw_error_callback);
	if (!glfwInit())
		return 1;

	const char * glsl_version = "#version 130";
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);

	GLFWwindow * window = glfwCreateWindow(1280, 720, "Markdown", nullptr, nullptr);
	if (nullptr == window)
		return 1;
	glfwMakeContextCurrent(window);
	glfwSwapInterval(1);
	glfwSetWindowSizeCallback(window, resized);

	if (GLEW_OK != glewInit())
		return 1;

	IMGUI_CHECKVERSION();
	ImGui::CreateContext();
	ImGuiIO & io = ImGui::GetIO();
	io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
	io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
	g_font_regular = io.Fonts->AddFontFromFileTTF("OpenSans-Regular.ttf", 18);
	g_font_bold = io.Fonts->AddFontFromFileTTF("OpenSans-Bold.ttf", 18);
	g_font_bold_large = io.Fonts->AddFontFromFileTTF("OpenSans-Bold.ttf", 26);

	ImGui::StyleColorsDark();
	ImGui_ImplGlfw_InitForOpenGL(window, true);
	ImGui_ImplOpenGL3_Init(glsl_version);

	std::ifstream in;
	in.open(argv[1]);
	std::string text(std::istreambuf_iterator<char>(in), {});
	in.close();

	while (!glfwWindowShouldClose(window))
	{
		glfwPollEvents();
		ImGui_ImplOpenGL3_NewFrame();
		ImGui_ImplGlfw_NewFrame();
		ImGui::NewFrame();

		ImGui::SetNextWindowPos({0, 0});
		ImGui::SetNextWindowSize(g_window_size);
		ImGui::Begin(
			"Markdown",
			nullptr,
			ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
				ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoSavedSettings
		);
		markdown(text.data(), text.data() + text.size());
		ImGui::End();

		ImGui::Render();
		int display_w, display_h;
		glfwGetFramebufferSize(window, &display_w, &display_h);
		glViewport(0, 0, display_w, display_h);
		glClearColor(0, 0, 0, 0);
		glClear(GL_COLOR_BUFFER_BIT);
		ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

		glfwSwapBuffers(window);
	}

	ImGui_ImplOpenGL3_Shutdown();
	ImGui_ImplGlfw_Shutdown();
	ImGui::DestroyContext();

	glfwDestroyWindow(window);
	glfwTerminate();
}