/* SPDX-License-Identifier:BSD-3-Clause */
#include "context.h"
#include "../renderer.h"
#include "../../core/log.h"
#include <stdlib.h>
#include <stdio.h>

static const char *vertex_shader_src =
	"#version 330 core\n"
	"layout (location = 0) in vec2 in_position;\n"
	"layout (location = 1) in vec3 in_color;\n"
	"out vec3 frag_color;\n"
	"void main() {\n"
	"    gl_Position = vec4(in_position, 0.0, 1.0);\n"
	"    frag_color = in_color;\n"
	"}\n";

static const char *fragment_shader_src =
	"#version 330 core\n"
	"in vec3 frag_color;\n"
	"out vec4 out_color;\n"
	"void main() {\n"
	"    out_color = vec4(frag_color, 1.0);\n"
	"}\n";

static GLuint compile_shader(GLenum type, const char *source)
{
	GLuint shader = glCreateShader(type);
	glShaderSource(shader, 1, &source, NULL);
	glCompileShader(shader);

	GLint success;
	glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
	if (!success) {
		char info[512];
		glGetShaderInfoLog(shader, 512, NULL, info);
		log_error("Shader compilation failed: ");
		printf("%s\n", info);
	}

	return shader;
}

static GLuint create_shader_program(void)
{
	GLuint vert = compile_shader(GL_VERTEX_SHADER, vertex_shader_src);
	GLuint frag = compile_shader(GL_FRAGMENT_SHADER, fragment_shader_src);

	GLuint program = glCreateProgram();
	glAttachShader(program, vert);
	glAttachShader(program, frag);
	glLinkProgram(program);

	GLint success;
	glGetProgramiv(program, GL_LINK_STATUS, &success);
	if (!success) {
		char info[512];
		glGetProgramInfoLog(program, 512, NULL, info);
		log_error("Shader linking failed: ");
		printf("%s\n", info);
	}

	glDeleteShader(vert);
	glDeleteShader(frag);

	return program;
}

static void create_quad_buffers(struct renderer_context *context)
{
	f32 vertices[] = {
		-0.5f, -0.5f,  1.0f, 0.0f, 0.0f,
		 0.5f, -0.5f,  0.0f, 1.0f, 0.0f,
		 0.5f,  0.5f,  0.0f, 0.0f, 1.0f,
		-0.5f,  0.5f,  1.0f, 1.0f, 1.0f
	};

	u16 indices[] = { 0, 1, 2, 2, 3, 0 };

	glGenVertexArrays(1, &context->vao);
	glGenBuffers(1, &context->vbo);
	glGenBuffers(1, &context->ebo);

	glBindVertexArray(context->vao);

	glBindBuffer(GL_ARRAY_BUFFER, context->vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, context->ebo);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(f32), (void *)0);
	glEnableVertexAttribArray(0);

	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(f32), (void *)(2 * sizeof(f32)));
	glEnableVertexAttribArray(1);

	glBindVertexArray(0);

	log_info("Quad buffers created.\n");
}

struct renderer_context *renderer_context_init(RGFW_window *window)
{
	struct renderer_context *context = malloc(sizeof(struct renderer_context));
	context->window = window;

	context->shader_program = create_shader_program();
	log_info("Shader program created.\n");

	create_quad_buffers(context);

	glEnable(GL_FRAMEBUFFER_SRGB);

	return context;
}

void renderer_context_deinit(struct renderer_context *context)
{
	glDeleteVertexArrays(1, &context->vao);
	glDeleteBuffers(1, &context->vbo);
	glDeleteBuffers(1, &context->ebo);
	glDeleteProgram(context->shader_program);
	free(context);
}

struct mesh *renderer_build_chunk_mesh(void)
{
	return NULL;
}

void renderer_draw_mesh(struct renderer_context *context, struct mesh mesh)
{
	(void)context;
	(void)mesh;
}

void renderer_draw_chunk(struct renderer_context *context, struct mesh mesh)
{
	(void)context;
	(void)mesh;
}

void renderer_present(struct renderer_context *context)
{
	glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT);

	glUseProgram(context->shader_program);
	glBindVertexArray(context->vao);
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);

	RGFW_window_swapBuffers_OpenGL(context->window);
}