/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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, either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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/>.
 *
 */

/*
 * This file is based on, or a modified version of code from TinyGL (C) 1997-2022 Fabrice Bellard,
 * which is licensed under the MIT license (see LICENSE).
 * It also has modifications by the ResidualVM-team, which are covered under the GPLv2 (or later).
 */

#ifndef TGL_ZGL_H
#define TGL_ZGL_H

#include "common/util.h"
#include "common/textconsole.h"
#include "common/array.h"
#include "common/list.h"
#include "common/scummsys.h"

#include "graphics/pixelformat.h"
#include "graphics/surface.h"
#include "graphics/tinygl/gl.h"
#include "graphics/tinygl/zbuffer.h"
#include "graphics/tinygl/zmath.h"
#include "graphics/tinygl/zblit.h"
#include "graphics/tinygl/zdirtyrect.h"
#include "graphics/tinygl/texelbuffer.h"

namespace TinyGL {

enum {

#define ADD_OP(a,b,c) OP_ ## a ,

#include "graphics/tinygl/opinfo.h"

	DUMMY
};

// initially # of allocated GLVertexes (will grow when necessary)
#define POLYGON_MAX_VERTEX 16

// Max # of specular light pow buffers
#define MAX_SPECULAR_BUFFERS 8
// # of entries in specular buffer
#define SPECULAR_BUFFER_SIZE 1024
// specular buffer granularity
#define SPECULAR_BUFFER_RESOLUTION 1024

#define MAX_MODELVIEW_STACK_DEPTH   35
#define MAX_PROJECTION_STACK_DEPTH  8
#define MAX_TEXTURE_STACK_DEPTH     8
#define MAX_NAME_STACK_DEPTH        64
#define MAX_TEXTURE_LEVELS          11
#define T_MAX_LIGHTS                32

#define VERTEX_HASH_SIZE 1031

#define MAX_DISPLAY_LISTS 1024
#define OP_BUFFER_MAX_SIZE 512

#define TGL_OFFSET_FILL    0x1
#define TGL_OFFSET_LINE    0x2
#define TGL_OFFSET_POINT   0x4

enum eDataType {
	kIntType,
	kInt4Type,
	kUintType,
	kFloatType,
	kFloat2Type,
	kFloat4Type,
	kFloat16Type
};

union uglValue {
	TGLint _int;
	TGLint _int4[4];
	TGLfloat _float;
	TGLfloat _float2[2];
	TGLfloat _float4[4];
	TGLfloat _float16[16];
};

struct GLSpecBuf {
	int shininess_i;
	int last_used;
	float buf[SPECULAR_BUFFER_SIZE + 1];
	struct GLSpecBuf *next;
};

struct GLLight {
	Vector4 ambient;
	Vector4 diffuse;
	Vector4 specular;
	bool has_specular;
	Vector4 position;
	Vector3 spot_direction;
	float spot_exponent;
	float spot_cutoff;
	float attenuation[3];
	// precomputed values
	float cos_spot_cutoff;
	Vector3 norm_spot_direction;
	Vector3 norm_position;
	// we use a linked list to know which are the enabled lights
	int enabled;
	struct GLLight *next, *prev;
};

struct GLMaterial {
	Vector4 emission;
	Vector4 ambient;
	Vector4 diffuse;
	Vector4 specular;
	bool has_specular;
	float shininess;
	// computed values
	int shininess_i;
	int do_specular;
};

struct GLViewport {
	int xmin, ymin, xsize, ysize;
	Vector3 scale;
	Vector3 trans;
	int updated;
};

union GLParam {
	int op;
	float f;
	int i;
	uint ui;
	void *p;
};

struct GLParamBuffer {
	GLParam ops[OP_BUFFER_MAX_SIZE];
	struct GLParamBuffer *next;
};

struct GLList {
	GLParamBuffer *first_op_buffer;
	// TODO: extensions for a hash table or a better allocating scheme
};

struct GLVertex {
	int edge_flag;
	Vector3 normal;
	Vector4 coord;
	Vector4 tex_coord;
	Vector4 color;
	float fog_factor;

	// computed values
	Vector4 ec;           // eye coordinates
	Vector4 pc;           // coordinates in the normalized volume
	int clip_code;        // clip code
	ZBufferPoint zp;      // integer coordinates for the rasterization

	bool operator==(const GLVertex &other) const {
		return
			edge_flag == other.edge_flag &&
			normal == other.normal &&
			coord == other.coord &&
			tex_coord == other.tex_coord &&
			color == other.color &&
			ec == other.ec &&
			pc == other.pc &&
			clip_code == other.clip_code &&
			zp == other.zp;
	}

	bool operator!=(const GLVertex &other) const {
		return !(*this == other);
	}
};

struct GLImage {
	TexelBuffer *pixmap;
	int xsize, ysize;
};

// textures

#define TEXTURE_HASH_TABLE_SIZE 256

struct GLTexture {
	GLImage images[MAX_TEXTURE_LEVELS];
	uint handle;
	int versionNumber;
	struct GLTexture *next, *prev;
	bool disposed;
};

struct tglColorAssociation {
	Graphics::PixelFormat pf;
	TGLuint format;
	TGLuint type;
};

// shared state

struct GLSharedState {
	GLList **lists;
	GLTexture **texture_hash_table;
};

/**
 * A linear allocator implementation.
 * The allocator can be initialized to a specific buffer size only once.
 * The allocation scheme is pretty simple: pointers are returned relative to a current memory position,
 * the allocator starts with an offset of 0 and increases its offset by the allocated amount every time.
 * Memory is released through the method free(), care has to be taken to call the destructors of the deallocated objects either manually (for complex struct arrays) or
 * by overriding the delete operator (with an empty implementation).
 */
class LinearAllocator {
public:
	LinearAllocator() {
		_memoryBuffer = nullptr;
		_memorySize = 0;
		_memoryPosition = 0;
	}

	void initialize(size_t newSize) {
		assert(_memoryBuffer == nullptr);
		void *newBuffer = gl_malloc(newSize);
		if (newBuffer == nullptr) {
			error("Couldn't allocate memory for linear allocator.");
		}
		_memoryBuffer = newBuffer;
		_memorySize = newSize;
	}

	~LinearAllocator() {
		if (_memoryBuffer != nullptr) {
			gl_free(_memoryBuffer);
		}
	}

	void *allocate(size_t size) {
		if (_memoryPosition + size >= _memorySize) {
			error("Allocator out of memory: couldn't allocate more memory from linear allocator.");
		}
		size_t returnPos = _memoryPosition;
		_memoryPosition += size;
		return ((byte *)_memoryBuffer) + returnPos;
	}

	void reset() {
		_memoryPosition = 0;
	}
private:
	void *_memoryBuffer;
	size_t _memorySize;
	size_t _memoryPosition;
};

struct GLContext;

typedef void (*gl_draw_triangle_func)(GLContext *c, GLVertex *p0, GLVertex *p1, GLVertex *p2);

// display context

struct GLContext {
	// Z buffer
	FrameBuffer *fb;
	Common::Rect renderRect;

	// blending
	bool blending_enabled;
	int source_blending_factor;
	int destination_blending_factor;

	// alpha blending
	bool alpha_test_enabled;
	int alpha_test_func;
	int alpha_test_ref_val;

	// Internal texture size
	int _textureSize;

	// lights
	GLLight lights[T_MAX_LIGHTS];
	GLLight *first_light;
	Vector4 ambient_light_model;
	int local_light_model;
	bool lighting_enabled;
	int light_model_two_side;

	// materials
	GLMaterial materials[2];
	bool color_material_enabled;
	int current_color_material_mode;
	int current_color_material_type;

	// textures
	GLTexture *current_texture, *default_texture;
	uint maxTextureName;
	bool texture_2d_enabled;
	int texture_mag_filter;
	int texture_min_filter;
	uint texture_wrap_s;
	uint texture_wrap_t;
	Common::Array<struct tglColorAssociation> colorAssociationList;

	// shared state
	GLSharedState shared_state;

	// current list
	GLParamBuffer *current_op_buffer;
	int current_op_buffer_index;
	int exec_flag, compile_flag, print_flag;

	// matrix
	int matrix_mode;
	Matrix4 *matrix_stack[3];
	Matrix4 *matrix_stack_ptr[3];
	int matrix_stack_depth_max[3];

	Matrix4 matrix_model_view_inv;
	Matrix4 matrix_model_projection;
	int matrix_model_projection_updated;
	int matrix_model_projection_no_w_transform;
	int apply_texture_matrix;

	// viewport
	GLViewport viewport;

	// current state
	int polygon_mode_back;
	int polygon_mode_front;

	int current_front_face;
	int current_shade_model;
	int current_cull_face;
	bool cull_face_enabled;
	bool normalize_enabled;
	gl_draw_triangle_func draw_triangle_front, draw_triangle_back;

	// selection
	int render_mode;
	uint *select_buffer;
	int select_size;
	uint *select_ptr, *select_hit;
	int select_overflow;
	int select_hits;

	// names
	uint name_stack[MAX_NAME_STACK_DEPTH];
	int name_stack_size;

	// clear
	float clear_depth;
	Vector4 clear_color;
	int clear_stencil;

	// current vertex state
	Vector4 current_color;
	Vector4 current_normal;
	Vector4 current_tex_coord;
	int current_edge_flag;

	// glBegin / glEnd
	int in_begin;
	int begin_type;
	int vertex_n, vertex_cnt;
	int vertex_max;
	GLVertex *vertex;

	// opengl 1.1 arrays
	TGLvoid *vertex_array;
	int vertex_array_size;
	int vertex_array_stride;
	int vertex_array_type;
	TGLvoid *normal_array;
	int normal_array_stride;
	int normal_array_type;
	TGLvoid *color_array;
	int color_array_size;
	int color_array_stride;
	int color_array_type;
	TGLvoid *texcoord_array;
	int texcoord_array_size;
	int texcoord_array_stride;
	int texcoord_array_type;
	int client_states;

	// opengl 1.1 polygon offset
	float offset_factor;
	float offset_units;
	int offset_states;

	// specular buffer. could probably be shared between contexts,
	// but that wouldn't be 100% thread safe
	GLSpecBuf *specbuf_first;
	int specbuf_used_counter;
	int specbuf_num_buffers;

	// opaque structure for user's use
	void *opaque;
	// resize viewport function
	int (*gl_resize_viewport)(int *xsize, int *ysize);

	// depth test
	bool depth_test_enabled;
	int depth_func;
	bool depth_write_mask;

	// stencil
	bool stencil_buffer_supported;
	bool stencil_test_enabled;
	int stencil_test_func;
	int stencil_ref_val;
	uint stencil_mask;
	uint stencil_write_mask;
	int stencil_sfail;
	int stencil_dpfail;
	int stencil_dppass;

	bool color_mask_red;
	bool color_mask_green;
	bool color_mask_blue;
	bool color_mask_alpha;

	bool fog_enabled;
	int fog_mode;
	Vector4 fog_color;
	float fog_density;
	float fog_start;
	float fog_end;

	Common::Rect _scissorRect;

	bool _enableDirtyRectangles;

	// stipple
	bool polygon_stipple_enabled;
	byte polygon_stipple_pattern[128];

	// blit test
	Common::List<BlitImage *> _blitImages;

	// Draw call queue
	Common::List<DrawCall *> _drawCallsQueue;
	Common::List<DrawCall *> _previousFrameDrawCallsQueue;
	int _currentAllocatorIndex;
	LinearAllocator _drawCallAllocator[2];
	bool _debugRectsEnabled;
	bool _profilingEnabled;

	void gl_vertex_transform(GLVertex *v);
	void gl_calc_fog_factor(GLVertex *v);

	void gl_get_pname(TGLenum pname, union uglValue *data, eDataType &dataType);

public:
	// The glop* functions exposed to public, however they are only for internal use.
	// Calling them from outside of TinyGL is forbidden
	#define ADD_OP(a, b, d) void glop ## a (GLParam *p);
	#include "graphics/tinygl/opinfo.h"

	void gl_add_op(GLParam *p);
	void gl_compile_op(GLParam *p);

	void gl_eval_viewport();
	void gl_transform_to_viewport(GLVertex *v);
	void gl_draw_triangle(GLVertex *p0, GLVertex *p1, GLVertex *p2);
	void gl_draw_line(GLVertex *p0, GLVertex *p1);
	void gl_draw_point(GLVertex *p0);

	static void gl_draw_triangle_point(GLContext *c, GLVertex *p0, GLVertex *p1, GLVertex *p2);
	static void gl_draw_triangle_line(GLContext *c, GLVertex *p0, GLVertex *p1, GLVertex *p2);
	static void gl_draw_triangle_fill(GLContext *c, GLVertex *p0, GLVertex *p1, GLVertex *p2);
	static void gl_draw_triangle_select(GLContext *c, GLVertex *p0, GLVertex *p1, GLVertex *p2);
	void gl_draw_triangle_clip(GLVertex *p0, GLVertex *p1, GLVertex *p2, int clip_bit);

	void gl_add_select(uint zmin, uint zmax);
	void gl_add_select1(int z1, int z2, int z3);
	void gl_enable_disable_light(int light, int v);
	void gl_shade_vertex(GLVertex *v);

	void gl_GetIntegerv(TGLenum pname, TGLint *data);
	void gl_GetFloatv(TGLenum pname, TGLfloat *data);
	void gl_GetDoublev(TGLenum pname, TGLdouble *data);
	void gl_GetBooleanv(TGLenum pname, TGLboolean *data);

	void gl_EnableClientState(GLParam *p);
	void gl_DisableClientState(GLParam *p);
	void gl_VertexPointer(GLParam *p);
	void gl_ColorPointer(GLParam *p);
	void gl_NormalPointer(GLParam *p);
	void gl_TexCoordPointer(GLParam *p);

	GLTexture *alloc_texture(uint h);
	GLTexture *find_texture(uint h);
	void free_texture(GLTexture *t);
	void gl_GenTextures(TGLsizei n, TGLuint *textures);
	void gl_DeleteTextures(TGLsizei n, const TGLuint *textures);
	void gl_PixelStore(TGLenum pname, TGLint param);

	void issueDrawCall(DrawCall *drawCall);
	void disposeResources();
	void disposeDrawCallLists();

	void presentBufferDirtyRects(Common::List<Common::Rect> &dirtyAreas);
	void presentBufferSimple(Common::List<Common::Rect> &dirtyAreas);

	void debugDrawRectangle(Common::Rect rect, int r, int g, int b);

	GLSpecBuf *specbuf_get_buffer(const int shininess_i, const float shininess);
	void specbuf_cleanup();

	TGLint gl_RenderMode(TGLenum mode);
	void gl_SelectBuffer(TGLsizei size, TGLuint *buffer);

	GLList *alloc_list(int list);
	GLList *find_list(uint list);
	void delete_list(int list);
	void gl_NewList(TGLuint list, TGLenum mode);
	void gl_EndList();
	TGLboolean gl_IsList(TGLuint list);
	TGLuint gl_GenLists(TGLsizei range);

	void initSharedState();
	void endSharedState();

	void init(int screenW, int screenH, Graphics::PixelFormat pixelFormat, int textureSize,
	          bool enableStencilBuffer, bool dirtyRectsEnable, uint32 drawCallMemorySize);
	void deinit();

	void gl_print_matrix(const float *m);
	void gl_debug(int mode) {
		print_flag = mode;
	}
};

extern GLContext *gl_ctx;
GLContext *gl_get_context();

#define VERTEX_ARRAY    0x0001
#define COLOR_ARRAY     0x0002
#define NORMAL_ARRAY    0x0004
#define TEXCOORD_ARRAY  0x0008

// this clip epsilon is needed to avoid some rounding errors after
// several clipping stages

#define CLIP_EPSILON (1E-5)

static inline int gl_clipcode(float x, float y, float z, float w1) {
	float w;

	w = (float)(w1 * (1.0 + CLIP_EPSILON));
	return (x < -w) | ((x > w) << 1) | ((y < -w) << 2) | ((y > w) << 3) | ((z < -w) << 4) | ((z > w) << 5);
}

static inline float clampf(float a, float min, float max) {
	if (a < min)
		return min;
	if (a > max)
		return max;
	else
		return a;
}

} // end of namespace TinyGL

#endif