#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>

#include "../include/limine.h"

#include "acpi.h"
#include "common.h"
#include "print.h"

// credit owed to https://wiki.osdev.org/Limine_Bare_Bones for the limine setup code

__attribute__((used, section(".limine_requests")))
static volatile u64 limine_base_revision[] = LIMINE_BASE_REVISION(4);

__attribute__((used, section(".limine_requests")))
static volatile struct limine_framebuffer_request fb_req = {
  .id = LIMINE_FRAMEBUFFER_REQUEST_ID,
  .revision = 0
};


__attribute__((used, section(".limine_requests")))
static volatile struct limine_memmap_request mem_req = {
  .id = LIMINE_MEMMAP_REQUEST_ID,
  .revision = 0,
};

__attribute__((used, section(".limine_requests")))
static volatile struct limine_hhdm_request hhdm_req = {
  .id = LIMINE_HHDM_REQUEST_ID,
  .revision = 0
};

__attribute__((used, section(".limine_requests")))
static volatile struct limine_rsdp_request rsdp_req = {
  .id = LIMINE_RSDP_REQUEST_ID,
  .revision = 0
};

u64 hhdm_offset;

__attribute__((used, section(".limine_requests_start")))
static volatile u64 limine_requests_start_marker[] = LIMINE_REQUESTS_START_MARKER;

__attribute__((used, section(".limine_requests_end")))
static volatile u64 limine_requests_end_marker[] = LIMINE_REQUESTS_END_MARKER;

void* memcpy(void* restrict dst, const void* src, size_t n) {
  u8* restrict pdst = (u8* restrict)dst;
  const u8* restrict psrc = (const u8* restrict)src;

  for(size_t i = 0; i < n; i++) {
    pdst[i] = psrc[i];
  }

  return dst;
}

void* memset(void* s, int c, size_t n) {
  u8* p = (u8*) s;

  for(size_t i = 0; i < n; i++) {
    p[i] = (u8)c;
  }

  return s;
}

void* memmove(void* dst, const void* src, size_t n) {
  u8* restrict pdst = (u8* restrict)dst;
  const u8* restrict psrc = (const u8* restrict)src;

  if(src > dst) {
    for(size_t i = 0; i < n; i++) {
      pdst[i] = psrc[i];
    }    
  } else if(src < dst) {
    for(size_t i = n; i > 0; i--) {
      pdst[i-1] = psrc[i-1];
    }    
  }

  return dst;
}

int memcmp(const void* s1, const void* s2, size_t n) {
  const u8* p1 = (const u8* )s1;
  const u8* p2 = (const u8* )s2;

  for(size_t i = 0; i < n; i++) {
    if(p1[i] != p2[i]) {
      return p1[i] < p2[i] ? -1 : 1;
    }
  }

  return 0;
}

static void hang() {
  for(;;) {
    asm ("hlt");
  }
}


struct limine_framebuffer* fb;

void draw(u8 vect) {
  for(size_t y = 0; y < fb->height; y++) {
    for(size_t x = 0; x < fb->width; x++) {
      volatile u32* fb_ptr = fb->address;
      fb_ptr[y * fb->width + x] = (
        (x + y) * 0x00010000 |
        (x ^ y) * 0x00000100 |
        (x - y) * 0x00000001
      )*vect;
    }
  }
}

extern void init_idt(void);

extern u32 fg;
extern u32 bg;
void print_memmap_entry(struct limine_memmap_entry* entry) {
  u32 savefg = fg;
  u32 savebg = bg;
  static const char* type_strs[] = {
    "Usable",
    "Reserved",
    "ACPI Reclaimable",
    "ACPI NVS",
    "BAD!!!",
    "Bootloader Reclaimable",
    "Executable and Modules",
    "Framebuffer",
    "ACPI Tables",
  };

  static u32 type_colors[] = {
    0x00AF00,
    0xAF1F00,
    0x7f7f00,
    0x7f7f00,
    0xFF0000,
    0x007f7f,
    0x408000,
    0x0000FF,
    0x00FF00
  };

  bg = type_colors[entry->type];
  fg = ~bg;
  
  u64 addr = entry->base;
  u64 end = addr + entry->length;
  print("[");
  print(type_strs[entry->type]);
  print("]");
  print64(addr);
  print(" - ");
  print64(end);
  print("\n");
  fg = savefg;
  bg = savebg;
}



void kmain() {
  if(LIMINE_BASE_REVISION_SUPPORTED(limine_base_revision) == false) {
    hang();
  }

  if(fb_req.response == NULL || fb_req.response->framebuffer_count < 1) {
    hang();
  }

  fb = fb_req.response->framebuffers[0];

  print_init(fb);
  init_idt();

  if(!mem_req.response) {
    print("Failed to get memory map :(\n)");
    hang();
  }

  if(!hhdm_req.response) {
    print("Failed to get higher half direct mapping\n.");
    hang();
  }

  hhdm_offset = hhdm_req.response->offset;

  if(!rsdp_req.response) {
    print ("Failed to find rsdp\n.");
    hang();
  }

  rsdp = (struct acpi_rsdp_header*)(rsdp_req.response->address);

  for(size_t i = 0; i < mem_req.response->entry_count; i++) {
    print_memmap_entry(mem_req.response->entries[i]);
  }

  print("Found RSDP @ 0x");
  print64((u64)rsdp);
  put('\n');

  print("With signature: ");
  printn((char*)rsdp->signature, sizeof(rsdp->signature));
  
  hang();
  
}