#ifndef COLORS_H
#define COLORS_H

#include "types.h"
#include <stdarg.h>
#include <strings.h>

#define VGA_WIDTH 80
#define VGA_HEIGHT 25

#define VGA_MEMORY_ADDRESS 0xB8000

/* IN VGA - Video Memory Arrya:
 * short
 * 1s byte (left most)  -> TEXT COLOR
 * 2s byte              -> BACK COLOR
 * 3rd and 4rt byte     -> TEXT (unsigned char) AKA CodePoint
 */

typedef struct __attribute__((packed)) _VGA {
	unsigned char codepoint; // 3rd and 4th byte
	unsigned char color;     // 1st byte: text color, 2nd byte: background color
	                         // LAST BIT IS BLINKING FLAG
} _VGA;

typedef enum _VGA_COLOR {
	BLACK = 0x0,
	BLUE = 0x1,
	GREEN = 0x2,
	CYAN = 0x3,
	RED = 0x4,
	MAGENTA = 0x5,
	BROWN = 0x6,
	LIGHT_GREY = 0x7,
	DARK_GREY = 0x8,
	LIGHT_BLUE = 0x9,
	LIGHT_GREEN = 0xA,
	LIGHT_CYAN = 0xB,
	LIGHT_RED = 0xC,
	LIGHT_MAGENTA = 0xD,
	YELLOW = 0xE,
	WHITE = 0xF
} _VGA_COLOR;

typedef struct _VGA_screen_space {
	unsigned int line;
	unsigned int column;

} _VGA_screen_space;

static _VGA_screen_space cursor_pos = {0, 0};
static _VGA_screen_space text_pos = {0, 0};

static unsigned int tab_pos = 0;

#define DEFAULT_BG BLUE
#define DEFAULT_FG WHITE

/*
 * END OF DECLARATIONS
 */



/*
 * START OF OUTPUT FUNCTIONS
 */

int printf(const char *fmt, ...);

// Convert _VGA_COLOR to color byte
static inline unsigned char __vga_color_byte(_VGA_COLOR fg, _VGA_COLOR bg, int blink) {
	unsigned char color = (bg << 4) | fg;
	if (blink) {
		color |= 0x80; // Set the blinking BIT
		               // to the highest bit
	}
	return color;
}

// Get pointer to VGA memory
static inline volatile _VGA *__vga_memory() {
	return (volatile _VGA *)VGA_MEMORY_ADDRESS;
}

static inline void __clear_screen() {
	volatile _VGA *vga = __vga_memory();
	for (int i = 0; i < VGA_WIDTH * VGA_HEIGHT; i++) {
		vga[i].codepoint = ' ';
		vga[i].color = __vga_color_byte(DEFAULT_FG, DEFAULT_BG, 0);
	}
}

static inline void __clear_screen_colored(_VGA_COLOR background) {
	volatile _VGA *vga = __vga_memory();
	for (int i = 0; i < VGA_WIDTH * VGA_HEIGHT; i++) {
		vga[i].codepoint = ' ';
		vga[i].color = __vga_color_byte(WHITE, background, 0);
	}
}

static inline int __put_char_VGA_POS(_VGA _c, _VGA_screen_space _position, int _blink) {
	if (_position.line > VGA_HEIGHT || _position.column > VGA_WIDTH)
		return 0;

	volatile _VGA *vga = __vga_memory();

	if (_c.codepoint == '\n') {
		text_pos.line++;
		text_pos.column = 0;
		return 1;
	}

	if (_c.codepoint == '\t') {
		int spaces = 4 - (_position.column % 4);
		if (spaces == 0)
			spaces = 4;

		int written = 0;
		while (spaces--) {
			if (_position.column >= VGA_WIDTH) {
				_position.column = 0;
				_position.line++;
				if (_position.line >= VGA_HEIGHT) {
					// TODO: scroll or wrap
					break;
				}
			}

			vga[(_position.line * VGA_WIDTH) + _position.column].codepoint = ' ';
			vga[(_position.line * VGA_WIDTH) + _position.column].color = _c.color;
			_position.column++;
			written++;
		}

		text_pos.line = _position.line;
		text_pos.column = _position.column;

		return written;
	}

	vga[(_position.line * VGA_WIDTH) + _position.column].codepoint = _c.codepoint;
	vga[(_position.line * VGA_WIDTH) + _position.column].color = _c.color;

	return 1;
}

static inline int __put_char(int column, int line, unsigned codepoint, _VGA_COLOR foreground, _VGA_COLOR background, int _blink) {
	_VGA __temp_vga;
	__temp_vga.color = __vga_color_byte(foreground, background, _blink);
	__temp_vga.codepoint = codepoint;

	_VGA_screen_space __temp_vga_space;
	__temp_vga_space.column = column;
	__temp_vga_space.line = line;

	return __put_char_VGA_POS(__temp_vga, __temp_vga_space, _blink);
}

static inline int __put_string(int column, int line, const char *__args, _VGA_COLOR foreground, _VGA_COLOR background, int _blink) {
	unsigned long _counter = 0;

	while (*__args != '\0') {

		if (column >= VGA_WIDTH) {
			column = 0;
			line++;

			if (line >= VGA_HEIGHT) {
				// TODO: SCROLL OR LOOP...
			}
		}

		_counter += __put_char(column++, line, *__args++, foreground, background, _blink);
	}

	return _counter;
}

static inline int __print_string(const char *__args, _VGA_COLOR foreground, _VGA_COLOR background, int _blink) {
	unsigned long _counter = 0;

	while (*__args != '\0') {

		if (text_pos.column >= VGA_WIDTH) {
			text_pos.column = 0;
			text_pos.line++;

			if (text_pos.line >= VGA_HEIGHT) {
				// TODO: SCROLL OR LOOP...
			}
		}

		_counter += __put_char(text_pos.column++, text_pos.line, *__args++, foreground, background, _blink);
	}

	return _counter;
}

// TODO: Implement later on the (argc, ...) to allow for stuff like printf("%d", number);
static inline int printf_s(const char *args) {
	// by defeault we dont blink lol
	return __print_string(args, DEFAULT_FG, DEFAULT_BG, 0);
}

static int __printf_internal(const char *fmt, va_list args) {
	int count = 0;

	while (*fmt) {
		if (*fmt != '%') {
			__put_char(text_pos.column++, text_pos.line, *fmt++, DEFAULT_FG, DEFAULT_BG, 0);
			count++;
			continue;
		}

		fmt++; // skip %

		switch (*fmt) {
		case 'c': {
			char c = (char)va_arg(args, int);
			__put_char(text_pos.column++, text_pos.line, c, DEFAULT_FG, DEFAULT_BG, 0);
			count++;
			break;
		}

		case 's': {
			const char *s = va_arg(args, const char *);
			count += __print_string(s, DEFAULT_FG, DEFAULT_BG, 0);
			break;
		}

		case 'd': {
			int n = va_arg(args, int);
			char buf[32];
			count += __print_string(itoa(n, buf), DEFAULT_FG, DEFAULT_BG, 0);
			break;
		}

		case 'u': {
			unsigned n = va_arg(args, unsigned);
			char buf[32];
			count += __print_string(utoa(n, buf), DEFAULT_FG, DEFAULT_BG, 0);
			break;
		}

		case 'o': {
			unsigned n = va_arg(args, unsigned);
			char buf[32];
			count += __print_string(otoa(n, buf), DEFAULT_FG, DEFAULT_BG, 0);
			break;
		}

		case 'x': {
			unsigned n = va_arg(args, unsigned);
			char buf[32];
			count += __print_string(__utoa(n, buf, 16), DEFAULT_FG, DEFAULT_BG, 0);
			break;
		}

			/*
			 * TODO: Enable floating point support later
			 * This requires enabling FPU in the kernel
			case 'f': {
			    double f = va_arg(args, double);
			    char buf[64];
			    count += __print_string(ftoa(f, buf), DEFAULT_FG, DEFAULT_BG, 0);
			    break;
			}
			*/

		case '%': {
			__put_char(text_pos.column++, text_pos.line, '%', DEFAULT_FG, DEFAULT_BG, 0);
			count++;
			break;
		}

		default:
			__put_char(text_pos.column++, text_pos.line, *fmt, DEFAULT_FG, DEFAULT_BG, 0);
			count++;
			break;
		}

		fmt++;
	}

	return count;
}

int printf(const char *fmt, ...) {
	va_list args;
	va_start(args, fmt);
	int result = __printf_internal(fmt, args);
	va_end(args);
	return result;
}

/*
 * END OF OUTPUT FUNCTIONS
 */ 




/*
 * START OF INPUT FUNCTIONS
 */

static inline void outb(unsigned short port, unsigned char val) {
    __asm__ volatile ("outb %0, %1" : : "a"(val), "Nd"(port));
}

static inline void __VGA_set_cursor_internal(unsigned int column, unsigned int line) {
    if (column >= VGA_WIDTH) column = VGA_WIDTH - 1;
    if (line >= VGA_HEIGHT) line = VGA_HEIGHT - 1;

    unsigned short pos = line * VGA_WIDTH + column;

    // Send high byte
    outb(0x3D4, 0x0E);
    outb(0x3D5, (pos >> 8) & 0xFF);

    // Send low byte
    outb(0x3D4, 0x0F);
    outb(0x3D5, pos & 0xFF);

    cursor_pos.column = column;
    cursor_pos.line = line;

    text_pos.column = column;
    text_pos.line = line;
}

static void __VGA_set_cursor_VGA_pos(_VGA_screen_space pos) {
    __VGA_set_cursor_internal(pos.column, pos.line);
}

static _VGA_screen_space get_cursor_pos() {
    _VGA_screen_space __temp = {cursor_pos.column, cursor_pos.line};
    return __temp; 
}

void scursor(unsigned int column, unsigned int line) {
    __VGA_set_cursor_internal(column, line);
}





#endif