/* ************************************************************************** */
/*                                                                            */
/*                                                        ::::::::            */
/*   MLX42_Int.h                                        :+:      :+:    :+:   */
/*                                                     +:+                    */
/*   By: W2Wizard <w2.wizzard@gmail.com>              +#+                     */
/*                                                   +#+                      */
/*   Created: 2021/12/27 23:55:34 by W2Wizard      #+#    #+#                 */
/*   Updated: 2023/03/03 11:13:25 by ulayus           ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#ifndef MLX42_INT_H
# define MLX42_INT_H
# define LODEPNG_NO_COMPILE_ALLOCATORS
# include "MLX42.h"
# include "lodepng/lodepng.h"
# include "glad/glad.h"
# include "KHR/khrplatform.h"
# if defined(__APPLE__)
#  define GL_SILENCE_DEPRECATION
# endif
# include <GLFW/glfw3.h>
# include <stdlib.h>
# include <memory.h>
# include <stdio.h>
# if defined(__linux__)
#  include <linux/limits.h>
# else
#  include <limits.h>
# endif
# include <ctype.h> /* isspace, isprint, ... */
# include <string.h> /* strlen, memmove, ... */
# include <stdarg.h> /* va_arg, va_end, ... */
# include <assert.h> /* assert, static_assert, ... */
# ifndef MLX_SWAP_INTERVAL
#  define MLX_SWAP_INTERVAL 1
# endif
# ifndef MLX_BATCH_SIZE
#  define MLX_BATCH_SIZE 12000
# endif
# define BPP sizeof(int32_t) /* Only support RGBA */
# define GETLINE_BUFF 1280
# define MLX_MAX_STRING 512 /* Arbitrary string limit */
# define MLX_ASSERT(cond, msg) assert(cond && msg);
# define MLX_NONNULL(var) MLX_ASSERT(var, "Value can't be null"); /* Assert instead of attribute */

/**
 * The shader code is extracted from the shader files
 * and converted to a .c file as a single string at
 * compile time. This keeps shader files external but
 * still integrated into the program letting you use
 * the executable anywhere without having to take the
 * shaders with you.
 *
 * Most modern frameworks like .NET do this by having resource files
 * instead.
 *
 * See: https://bit.ly/3LJYG0r
 */

extern const char* vert_shader;
extern const char* frag_shader;

// Flag to indicate if the render queue has to be sorted.
extern bool sort_queue;

// Settings array, use the enum 'key' to get the value.
extern int32_t mlx_settings[MLX_SETTINGS_MAX];

//= Types =//

// A single vertex, identical to the layout in the shader.
typedef struct vertex
{
	float	x;
	float	y;
	float	z;
	float	u;
	float	v;
	int8_t	tex;
}	vertex_t;

// Layout for linked list.
typedef struct mlx_list
{
	void*				content;
	struct mlx_list*	next;
	struct mlx_list*	prev;
}	mlx_list_t;

//= Hook structs =//
/**
 * There are 2 types of hooks, special and generics.
 *
 * Specials: Specials are specific callback functions to a specific action
 * such as window resizing or key presses. These are attached to the
 * callbacks of glfw. In case MLX itself needs the callback we call
 * the specials in that callback since there can only ever be a single
 * callback.
 *
 * Generics: Generics are MLX42 specific hooks and can have multiple
 * hooks at the same time, these are executed every frame and can be
 * used as an alternative for keypresses or animations for instance.
 *
 * NOTE: Hooks could be achieved with va_args to have any amount
 * of args sized functor but we can't/don't want to let the user
 * deal with va_args and having to look up what args are what, etc...
 *
 * We want to keep it straightforward with functors already describing
 * what params they have.
 */

typedef struct mlx_srcoll
{
	void*			param;
	mlx_scrollfunc	func;
}	mlx_scroll_t;

typedef struct mlx_mouse
{
	void*			param;
	mlx_mousefunc	func;
}	mlx_mouse_t;

typedef struct mlx_cursor
{
	void*			param;
	mlx_cursorfunc	func;
}	mlx_cursor_t;

typedef struct mlx_close
{
	void*			param;
	mlx_closefunc	func;
}	mlx_close_t;

typedef struct mlx_resize
{
	void*			param;
	mlx_resizefunc	func;
}	mlx_resize_t;

typedef struct mlx_key
{
	void*			param;
	mlx_keyfunc		func;
}	mlx_key_t;

typedef struct mlx_hook
{
	void*	param;
	void	(*func)(void*);
}	mlx_hook_t;

//= Rendering =//
/**
 * For rendering we need to store most of OpenGL's stuff
 * such as the vertex array object, vertex buffer object &
 * the shader program as well as hooks and the zdepth level.
 *
 * Additionally we represent draw calls with a linked list
 * queue that points to the image and the index of its instance.
 * Again, instances only carry XYZ data, so coupled with the image it
 * lets us know where to draw a copy of the image.
 *
 * Texture contexts are kept in a struct alongside the capacity
 * of the array of instances, since the array is realloced like a vector.
 */

// MLX instance context.
typedef struct mlx_ctx
{
	GLuint			vao;
	GLuint			vbo;
	GLuint			shaderprogram;

	uint32_t		initialWidth;
	uint32_t		initialHeight;

	mlx_list_t*		hooks;
	mlx_list_t*		images;
	mlx_list_t*		render_queue;

	mlx_scroll_t	scroll_hook;
	mlx_mouse_t		mouse_hook;
	mlx_cursor_t	cursor_hook;
	mlx_key_t		key_hook;
	mlx_resize_t	resize_hook;
	mlx_close_t		close_hook;

	int32_t			zdepth;
	int32_t			bound_textures[16];
	int32_t			batch_size;
	vertex_t		batch_vertices[MLX_BATCH_SIZE];
}	mlx_ctx_t;

// Draw call queue entry.
typedef struct draw_queue
{
	mlx_image_t*	image;
	int32_t			instanceid;
}	draw_queue_t;

// Image context.
typedef struct mlx_image_ctx
{
	GLuint	texture;
	size_t	instances_capacity;
}	mlx_image_ctx_t;

//= Functions =//
/**
 * All sorts of internal functions shared in the library that
 * should not be accessible to the user! No touch!
 */

//= Linked List Functions =//

mlx_list_t* mlx_lstnew(void* content);
mlx_list_t* mlx_lstlast(mlx_list_t* lst);
int32_t mlx_lstsize(mlx_list_t* lst);
void mlx_lstclear(mlx_list_t** lst, void (*del)(void*));
void mlx_lstadd_back(mlx_list_t** lst, mlx_list_t* new);
void mlx_lstadd_front(mlx_list_t** lst, mlx_list_t* new);
mlx_list_t* mlx_lstremove(mlx_list_t** lst, void* value, bool (*comp)(void*, void*));
void mlx_sort_renderqueue(mlx_list_t** lst);

//= Misc functions =//

bool mlx_equal_image(void* lstcontent, void* value);
bool mlx_equal_inst(void* lstcontent, void* value);
void mlx_draw_pixel(uint8_t* pixel, uint32_t color);

//= Error/log Handling Functions =//

bool mlx_error(mlx_errno_t val);
bool mlx_freen(int32_t count, ...);

//= OpenGL Functions =//

void mlx_update_matrix(const mlx_t* mlx, int32_t width, int32_t height);
void mlx_draw_instance(mlx_ctx_t* mlx, mlx_image_t* img, mlx_instance_t* instance);
void mlx_flush_batch(mlx_ctx_t* mlx);

// Utils Functions =//

bool mlx_getline(char** out, size_t* out_size, FILE* file);
uint32_t mlx_rgba_to_mono(uint32_t color);
int32_t mlx_atoi_base(const char* str, int32_t base);
uint64_t mlx_fnv_hash(char* str, size_t len);
#endif
