#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <err.h>
#include <math.h>

#include "ugui.h"


#define SALT         0xbabb0cac
#define DEF_SCALE    1.0
#define DEF_PPI      96.0
#define STACK_STEP   64

#define PPI_PPM(ppi, scale)  (ppi * scale * 0.03937008)
#define PPI_PPD(ppi, scale)  (PPI_PPM(ppi, scale) * 0.3528)
#define IS_VALID_UNIT(u)     (u==UG_UNIT_PX||u==UG_UNIT_MM||u==UG_UNIT_PT)
#define UG_ERR(...)          err(errno, "__FUNCTION__: " __VA_ARGS__)
#define BETWEEN(x, min, max) (x <= max && x >= min)
#define INTERSECTS(v, r)     (BETWEEN(v.x, r.x, r.x+r.w) && BETWEEN(v.y, r.y, r.y+r.h))
#define CAP(x, s)            { if (x < s) x = s; }


// default style
// TODO: fill default style
static const ug_style_t default_style = {
	.text = {
		.color     = RGB_FORMAT(0xffffff),
		.alt_color = RGB_FORMAT(0xbbbbbb),
		.size      = SIZE_PX(16),
		.alt_size  = SIZE_PX(12),
	},
	.cnt = {
		.bg_color          = RGB_FORMAT(0x0000ff),
		.border.t          = SIZE_PX(3),
		.border.b          = SIZE_PX(3),
		.border.l          = SIZE_PX(3),
		.border.r          = SIZE_PX(3),
		.border.color      = RGB_FORMAT(0x00ff00),
		.titlebar.height   = SIZE_PX(20),
		.titlebar.bg_color = RGB_FORMAT(0xbababa),
	},
};

static const ug_vec2_t max_size = {{10e6}, {10e6}};

static ug_style_t style_cache = {0};


/*=============================================================================*
 *                          Common Functions                                   *
 *=============================================================================*/


// grow a stack
#define GROW_STACK(S)                                                                \
{                                                                              \
	S.items = realloc(S.items, (S.size+STACK_STEP)*sizeof(*(S.items)));    \
	if(!S.items)                                                           \
		UG_ERR("Could not allocate stack #S: %s", strerror(errno));    \
	memset(&(S.items[S.size]), 0, STACK_STEP*sizeof(*(S.items)));          \
	S.size += STACK_STEP;                                                  \
}


#define GET_FROM_STACK(S, c)                                                   \
{                                                                              \
	if (S.idx >= S.size)                                                   \
		GROW_STACK(S);                                                 \
	c = &(S.items[S.idx++]);                                               \
}


#define RESET_STACK(S)                                                         \
{                                                                              \
	memset(S.items, 0, S.idx*sizeof(*(S.items)));                          \
	S.idx = 0;                                                             \
}


#define MOUSEDOWN(ctx, btn) (ctx->mouse.press_mask &  ctx->mouse.down_mask & btn)
#define MOUSEUP(ctx, btn)   (ctx->mouse.press_mask & ~ctx->mouse.down_mask & btn)


// https://en.wikipedia.org/wiki/Jenkins_hash_function
static ug_id_t hash(const void *data, unsigned int size)
{
	if (!size)
		return 0;
	ug_id_t hash = SALT;
	unsigned char *v = (unsigned char *)data;

	for (; size; size--) {
		hash += v[size-1];
		hash += hash << 10;
		hash ^= hash >> 6;
	}
	hash += hash << 3;
  	hash ^= hash >> 11;
  	hash += hash << 15;
	
	return hash;
}


int size_to_px(ug_ctx_t *ctx, ug_size_t s)
{
	switch (s.unit) {
	case UG_UNIT_MM: return roundf(s.size.f * ctx->ppm);
	case UG_UNIT_PT: return roundf(s.size.f * ctx->ppd);
	case UG_UNIT_PX: return s.size.i;
	default: return 0;
	}
}


ug_rect_t div_to_rect(ug_ctx_t *ctx, ug_div_t *div)
{
	ug_rect_t r;
	r.x = size_to_px(ctx, div->x);
	r.y = size_to_px(ctx, div->y);
	r.w = size_to_px(ctx, div->w);
	r.h = size_to_px(ctx, div->h);
	return r;
}


// update the style cache with the correct sizes in pixels and colors
static void update_style_cache(ug_ctx_t *ctx)
{
	const ug_style_t *s = ctx->style;
	// FIME: use the correct units and convert, for now assume default style
	style_cache = *s;
}


void push_rect_command(ug_ctx_t *ctx, const ug_rect_t *rect, ug_color_t color)
{
	ug_cmd_t *c;
	GET_FROM_STACK(ctx->cmd_stack, c);
	c->type       = UG_CMD_RECT;
	c->rect.x     = rect->x;
	c->rect.y     = rect->y;
	c->rect.w     = rect->w;
	c->rect.h     = rect->h;
	c->rect.color = color;
}


/*=============================================================================*
 *                          Context Operations                                 *
 *=============================================================================*/


// creates a new context, fills with default values, ctx is ready for ug_start()
ug_ctx_t *ug_ctx_new(void)
{
	ug_ctx_t *ctx = malloc(sizeof(ug_ctx_t));
	if (!ctx)
		err(errno, "__FUNCTION__:" "Could not allocate context: %s", strerror(errno));
	memset(ctx, 0, sizeof(ug_ctx_t));

	ctx->unit      = UG_UNIT_PX;
	ctx->style     = &default_style;
	ctx->style_px  = &style_cache;
	ug_ctx_set_displayinfo(ctx, DEF_SCALE, DEF_PPI);

	// TODO: allocate stacks
	return ctx;
}


void ug_ctx_free(ug_ctx_t *ctx)
{
	if (!ctx) {
		warn("__FUNCTION__:" "Trying to free a null context");
		return;
	}

	free(ctx->cmd_stack.items);
	free(ctx->cnt_stack.items);

	free(ctx);

	// NOTE: do not free style since the default is statically allocated, let
	// the user take care of it instead
}


#define TEST_CTX(ctx) { if (!ctx) return -1; }

int ug_ctx_set_displayinfo(ug_ctx_t *ctx, float scale, float ppi)
{
	TEST_CTX(ctx);
	if (scale <= 0 || ppi < 20.0)
		return -1;
	
	ctx->last_ppi = ctx->ppi;
	ctx->last_ppm = ctx->ppd;
	ctx->last_ppd = ctx->ppm;

	ctx->ppm   = PPI_PPM(scale, ppi);
	ctx->ppd   = PPI_PPM(scale, ppi);
	ctx->ppi   = ppi;
	
	update_style_cache(ctx);

	return 0;
}


int ug_ctx_set_drawableregion(ug_ctx_t *ctx, ug_vec2_t size)
{
	TEST_CTX(ctx);
	if (size.w <= 0 || size.h <= 0)
		return -1;
	
	ctx->size.w = size.w;
	ctx->size.h = size.h;

	// FIXME: do I need to do something like update_container_size() here?
	//        maybe it is redundant since each frame not every conatiner is
	//        re-added
	return 0;
}


int ug_ctx_set_style(ug_ctx_t *ctx, const ug_style_t *style)
{
	TEST_CTX(ctx);
	if (!style)
		return -1;
	// TODO: validate style

	ctx->style = style;
	update_style_cache(ctx);
	
	return 0;
}


int ug_ctx_set_unit(ug_ctx_t *ctx, ug_unit_t unit)
{
	TEST_CTX(ctx);
	if (!IS_VALID_UNIT(unit))
		return -1;
	
	ctx->unit = unit;

	return 0;
}


/*=============================================================================*
 *                          Container Operations                               *
 *=============================================================================*/


// get a new or existing container handle
static ug_container_t *get_container(ug_ctx_t *ctx, ug_id_t id)
{
	ug_container_t *c = NULL;
	for (int i = 0; i < ctx->cnt_stack.idx; i++) {
		if (ctx->cnt_stack.items[i].id == id) {
			c = &(ctx->cnt_stack.items[i]);
			break;
		}
	}
	// if the container was not already there allocate a new one
	if (!c)
		GET_FROM_STACK(ctx->cnt_stack, c);

	return c;
}


// update the container dimensions and position according to the context information,
// also handle resizing, moving, ect. if allowed by the container
static void update_container(ug_ctx_t *ctx, ug_container_t *cnt)
{
	ug_rect_t *rect, *rca;
	rect = &cnt->rect;
	rca  = &cnt->rca;

	if (ctx->ppi != ctx->last_ppi) {
		// if the scale has been updated than we need to scale the container
		// as well
		float scale = ctx->ppi / ctx->last_ppi;
		rect->x = roundf(rect->x * scale);
		rect->y = roundf(rect->y * scale);
		rect->w = roundf(rect->w * scale);
		rect->h = roundf(rect->h * scale);
	}

	*rca = *rect;

	/*
	 * Container style:
	 * 
	 * rca
	 * v 
	 * +-----------------------------------------------+
	 * |          Titlebar                             |
	 * +-----------------------------------------------+
	 * |+---------------------------------------------+|
	 * ||\              ^ Border Top ^                ||
	 * || \_ rect(0,0)                                ||
	 * ||                                             ||
	 * ||                                             ||
	 * ||                                             ||
	 * ||                                             ||
	 * ||                                             ||
	 * ||                                             ||
	 * ||                                             ||
	 * || < Border Left                               ||
	 * ||                              Border Right > ||
	 * ||                                             ||
	 * ||                                             ||
	 * ||                                             ||
	 * ||                                             ||
	 * |+---------------------------------------------+|
	 * +-----------------------------------------------+
	 *                  ^ Border Bottom ^ 
	 */
	
	const ug_style_t *s = ctx->style_px;
	int bl = s->cnt.border.l.size.i;
	int br = s->cnt.border.r.size.i;
	int bt = s->cnt.border.t.size.i;
	int bb = s->cnt.border.b.size.i;
	int hh = s->cnt.titlebar.height.size.i;
	int cw = ctx->size.w;
	int ch = ctx->size.h;

	// 0 -> take all the space, <0 -> take absolute
	if (rect->w < 0)  rca->w = -rect->w;
	if (rect->h < 0)  rca->h = -rect->h;

	// handle relative position
	// and move to fit borders
	if (rect->w == 0) rca->w = cw - br - bl;
	else rca->w += bl + br;
	if (rect->h == 0) rca->h = ch - bt - bb;
	else if (cnt->flags & UG_CNT_MOVABLE) rca->h += hh + 2*bt + bb;
	else rca->h += bt + bb;

	// <0 -> relative to the right margin
	if (rect->x < 0) rca->x = cw - rca->w + rca->x;
	if (rect->y < 0) rca->y = ch - rca->h + rca->y;

	// if we had focus the frame before, then do shit
	if (ctx->hover.cnt_last != cnt->id)
		goto cnt_draw;

	// mouse pressed handle resize, for simplicity containers can only 
	// be resized from the bottom and right border
	// TODO: bring selected container to the top of the stack
	if (!(ctx->mouse.down_mask & UG_BTN_LEFT) ||
	    !(cnt->flags & (UG_CNT_RESIZABLE | UG_CNT_MOVABLE)))
		goto cnt_draw;
	
	ug_vec2_t mpos = ctx->mouse.pos;
	int minx, maxx, miny, maxy;
	
	// handle movable windows
	if (cnt->flags & UG_CNT_MOVABLE) {
		minx = rca->x;
		maxx = rca->x + rca->w - br;
		miny = rca->y;
		maxy = rca->y + bt + hh;
		if (BETWEEN(mpos.x, minx, maxx) && BETWEEN(mpos.y, miny, maxy)) {
			// if a relative container has been moved consider it no 
			// longer relative
			if (rect->x < 0)
				rect->x = cw + rect->x - rect->w - bl - br;
			if (rect->y < 0)
				rect->y = ch + rect->y - rect->h - 2*bt - bb - hh;

			rect->x += ctx->mouse.delta.x;
			rect->y += ctx->mouse.delta.y;
			rca->x += ctx->mouse.delta.x;
			rca->y += ctx->mouse.delta.y;
		}
	}

	if (cnt->flags & UG_CNT_RESIZABLE) {
		// right border resize
		minx = rca->x + rca->w - br;
		maxx = rca->x + rca->w;
		miny = rca->y;
		maxy = rca->y + rca->h;
		if (BETWEEN(mpos.x, minx, maxx) && BETWEEN(mpos.y, miny, maxy)) {
			rect->w += ctx->mouse.delta.x;
			rca->w += ctx->mouse.delta.x;
		}

		// bottom border resize
		minx = rca->x;
		maxx = rca->x + rca->w;
		miny = rca->y + rca->h - bb;
		maxy = rca->y + rca->h;
		if (BETWEEN(mpos.x, minx, maxx) && BETWEEN(mpos.y, miny, maxy)) {
			rect->h += ctx->mouse.delta.y;
			rca->h += ctx->mouse.delta.y;
		}
	}

	// TODO: what if I want to close a floating container?
	//       Maybe add a UG_CNT_CLOSABLE flag?

	// TODO: what about scrolling? how do we know if we need to draw
	//       a scroll bar? Maybe add that information inside the
	//       container structure

	// push the appropriate rectangles to the drawing stack
	ug_rect_t draw_rect;
	cnt_draw:
	
	// push outline
	draw_rect = *rca;
	push_rect_command(ctx, &draw_rect, s->cnt.border.color);
	
	// titlebar
	if (cnt->flags & UG_CNT_MOVABLE) {
		draw_rect.x += bl;
		draw_rect.y += bt;
		draw_rect.w -= bl + br;
		draw_rect.h  = hh;
		push_rect_command(ctx, &draw_rect, s->cnt.titlebar.bg_color);
	}
	
	// push main body
	draw_rect = *rca;
	draw_rect.x += bl;
	draw_rect.y += bt;
	draw_rect.w -= bl + br;
	draw_rect.h -= bt + bb;
	if (cnt->flags & UG_CNT_MOVABLE) {
		draw_rect.y += bt + hh;
		draw_rect.h -= bt + hh;
	}
	push_rect_command(ctx, &draw_rect, s->cnt.bg_color);
	// TODO: push other rects
}


// a floating container can be placed anywhere and can be resized, acts like a
// window inside another window
int ug_container_floating(ug_ctx_t *ctx, const char *name, ug_div_t div)
{	
	TEST_CTX(ctx);
	// TODO: verify div

	ug_id_t id = name ? hash(name, strlen(name)) : hash(&div, sizeof(ug_div_t));
	ug_container_t *cnt = get_container(ctx, id);
	
	if (cnt->id) {
		// nothing? maybe we can skip updating all dimensions and stuff
	} else {
		cnt->id = id;
		cnt->max_size = max_size;
		cnt->rect = div_to_rect(ctx, &div);
		cnt->flags = UG_CNT_MOVABLE  | UG_CNT_RESIZABLE |
			     UG_CNT_SCROLL_X | UG_CNT_SCROLL_Y  ;
	}

	update_container(ctx, cnt);
	
	return 0;
}


/*=============================================================================*
 *                            Input Handling                                   *
 *=============================================================================*/


int ug_input_mousemove(ug_ctx_t *ctx, int x, int y)
{
	TEST_CTX(ctx)
	if (x < 0 || y < 0)
		return 0;
	
	ctx->mouse.pos = (ug_vec2_t){.x = x, .y = y};

	return 0;
}


int ug_input_mousedown(ug_ctx_t *ctx, unsigned int mask)
{
	TEST_CTX(ctx);

	ctx->mouse.press_mask |= mask;
	ctx->mouse.down_mask  |= mask;

	return 0;
}


int ug_input_mouseup(ug_ctx_t *ctx, unsigned int mask)
{
	TEST_CTX(ctx);

	ctx->mouse.down_mask &= ~mask;

	return 0;
}



/*=============================================================================*
 *                            Frame Handling                                   *
 *=============================================================================*/


// At the beginning of a frame assume that all input has been passed to the context
// update the mouse delta and reset the command stack
int ug_frame_begin(ug_ctx_t *ctx)
{
	TEST_CTX(ctx);

	// TODO: add a way to mark a container for removal from the stack, and then
	//       remove it here to save space

	// update mouse delta
	ctx->mouse.delta.x = ctx->mouse.pos.x - ctx->mouse.last_pos.x;
	ctx->mouse.delta.y = ctx->mouse.pos.y - ctx->mouse.last_pos.y;
	
	// clear command stack
	RESET_STACK(ctx->cmd_stack);

	// update hover index
	ug_vec2_t v = ctx->mouse.pos;
//	printf("mouse: x=%d, y=%d\n", ctx->mouse.pos.x, ctx->mouse.pos.x);
	for (int i = 0; i < ctx->cnt_stack.idx; i++) {
		ug_rect_t r = ctx->cnt_stack.items[i].rca;
		if (INTERSECTS(v, r)) {
			ctx->hover.cnt = ctx->cnt_stack.items[i].id;
//			printf("intersects! %.8x\n", ctx->hover.cnt);
		}
	}

	return 0;
}


// At the end of a frame reset inputs
int ug_frame_end(ug_ctx_t *ctx)
{
	TEST_CTX(ctx);

	ctx->input_text[0]      = '\0';
	ctx->key.press_mask     = 0;
	ctx->mouse.press_mask   = 0;
	ctx->mouse.scroll_delta = (ug_vec2_t){0};
	ctx->mouse.last_pos     = ctx->mouse.pos;

	// reset hover, it has to be calculated at frame beginning
	ctx->hover.cnt_last  = ctx->hover.cnt;
	ctx->hover.elem_last = ctx->hover.elem;
	ctx->hover.cnt       = 0;
	ctx->hover.elem      = 0;

	ctx->last_ppi = ctx->ppi;
	ctx->last_ppm = ctx->ppm;
	ctx->last_ppd = ctx->ppd;

	ctx->frame++;

	return 0;
}