#ifndef PLAND_SYSCALL_H
#define PLAND_SYSCALL_H

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

typedef uint32_t _file_handle_t;
typedef uint32_t _task_handle_t;
typedef uint32_t _drive_number_t;
typedef uint32_t _process_handle_t;

typedef enum {
  _KEY_LSHIFT = 0x00000100,
  _KEY_RSHIFT = 0x00000200,
  _KEY_CAPS   = 0x00000400,
  _KEY_INSERT = 0x00000800,
  _KEY_NUM    = 0x00001000,
  _KEY_SCROLL = 0x00002000,
  _KEY_LALT   = 0x00004000,
  _KEY_RALT   = 0x00008000,
  _KEY_LCTRL  = 0x00010000,
  _KEY_RCTRL  = 0x00020000,
  _KEY_LMETA  = 0x00040000,
  _KEY_RMETA  = 0x00080000,

  _KEY_SHIFT  = 0x00000300,
  _KEY_SCAPS  = 0x00000700,
  _KEY_ALT    = 0x0000c000,
  _KEY_CTRL   = 0x00030000,
  _KEY_META   = 0x000c0000,

  _KEY_BEGIN_CAPS = 0x80,
  _KEY_BEGIN_INSERT,
  _KEY_BEGIN_NUM,
  _KEY_BEGIN_SCROLL,
  _KEY_BEGIN_LSHIFT,
  _KEY_BEGIN_RSHIFT,
  _KEY_BEGIN_LALT,
  _KEY_BEGIN_RALT,
  _KEY_BEGIN_LCTRL,
  _KEY_BEGIN_RCTRL,
  _KEY_BEGIN_LMETA,
  _KEY_BEGIN_RMETA,
  /* 0x8c - 0x97 reserved */
  /* 0x98 - 0x9f unassigned */
  _KEY_F1 = 0xa0,
  _KEY_F2,
  _KEY_F3,
  _KEY_F4,
  _KEY_F5,
  _KEY_F6,
  _KEY_F7,
  _KEY_F8,
  _KEY_F9,
  _KEY_F10,
  _KEY_F11,
  _KEY_F12,
  /* 0xac - 0xaf unassigned */
  _KEY_NUM0 = 0xb0,
  _KEY_NUM1,
  _KEY_NUM2,
  _KEY_NUM3,
  _KEY_NUM4,
  _KEY_NUM5,
  _KEY_NUM6,
  _KEY_NUM7,
  _KEY_NUM8,
  _KEY_NUM9,
  _KEY_NTIMES,
  _KEY_NPLUS,
  _KEY_NENTER,
  _KEY_NMINUS,
  _KEY_NDOT,
  _KEY_NSLASH,
  /* 0xc0 unassigned */
  _KEY_DELETE,
  _KEY_HOME,
  _KEY_END,
  _KEY_PUP,
  _KEY_PDOWN,
  _KEY_UP,
  _KEY_DOWN,
  _KEY_LEFT,
  _KEY_RIGHT,
  _KEY_ESC,
  _KEY_MENU,
  _KEY_PAUSE,
  _KEY_PRSCR,
  /* 0xce - 0xef unassigned */
} _key_code_t;

typedef enum {
  _COLOR_FG_BLACK   = 0x00,
  _COLOR_FG_BLUE    = 0x01,
  _COLOR_FG_GREEN   = 0x02,
  _COLOR_FG_CYAN    = 0x03,
  _COLOR_FG_RED     = 0x04,
  _COLOR_FG_MAGENTA = 0x05,
  _COLOR_FG_BROWN   = 0x06,
  _COLOR_FG_LGRAY   = 0x07,

  _COLOR_FG_DGRAY   = 0x08,
  _COLOR_FG_LBLUE   = 0x09,
  _COLOR_FG_LGREEN  = 0x0a,
  _COLOR_FG_LCYAN   = 0x0b,
  _COLOR_FG_LRED    = 0x0c,
  _COLOR_FG_PINK    = 0x0d,
  _COLOR_FG_YELLOW  = 0x0e,
  _COLOR_FG_WHITE   = 0x0f,

  _COLOR_BG_BLACK   = 0x00,
  _COLOR_BG_BLUE    = 0x10,
  _COLOR_BG_GREEN   = 0x20,
  _COLOR_BG_CYAN    = 0x30,
  _COLOR_BG_RED     = 0x40,
  _COLOR_BG_MAGENTA = 0x50,
  _COLOR_BG_BROWN   = 0x60,
  _COLOR_BG_LGRAY   = 0x70
} _vga_color_t;

typedef struct __attribute__ ((packed)) {
  char name[100];
  uint32_t size;
  bool is_dir;
  uint8_t pad[23];
} _dir_info_entry_t;

enum _scn {
  _SCN_OPEN_FILE,
  _SCN_CLOSE_FILE,
  _SCN_FILE_READ,
  _SCN_FILE_SIZE,
  _SCN_START_TASK,
  _SCN_LOG_STRING,
  _SCN_GET_KEY,
  _SCN_ALLOCATE_RAM,
  _SCN_MEMORY_INFO,
  _SCN_WAIT_FOR_TASK,
  _SCN_ENUMERATE_DIR,
  _SCN_PRINT_AT,
  _SCN_COUNT_OF_DIR,
  _SCN_CLEAR_SCREEN,
  _SCN_SET_COLOR
};

static inline uint32_t _sc0(enum _scn eax) {
  uint32_t out;
  asm volatile (
    "int $0x30"
  : "=a" (out) : "a" (eax) : "ecx", "edx");
  return out;
}

static inline uint32_t _sc1(enum _scn eax, uint32_t ebx) {
  uint32_t out;
  asm volatile (
    "int $0x30"
  : "=a" (out) : "a" (eax), "b" (ebx) : "ecx", "edx");
  return out;
}

static inline uint32_t _sc2(enum _scn eax, uint32_t ebx, uint32_t ecx) {
  uint32_t out;
  uint32_t dummy;
  asm volatile (
    "int $0x30"
  : "=a" (out), "=c" (dummy) : "a" (eax), "b" (ebx), "c" (ecx) : "edx");
  return out;
}

static inline uint32_t _sc3(enum _scn eax, uint32_t ebx, uint32_t ecx, uint32_t edx) {
  uint32_t out;
  uint32_t dummy;
  asm volatile (
    "int $0x30"
  : "=a" (out), "=c" (dummy), "=d" (dummy) : "a" (eax), "b" (ebx), "c" (ecx), "d" (edx));
  return out;
}

static inline uint32_t _sc4(enum _scn eax, uint32_t ebx, uint32_t ecx, uint32_t edx, uint32_t esi) {
  uint32_t out;
  uint32_t dummy;
  asm volatile (
    "int $0x30"
  : "=a" (out), "=c" (dummy), "=d" (dummy) : "a" (eax), "b" (ebx), "c" (ecx), "d" (edx), "S" (esi));
  return out;
}

static inline uint32_t _sc5(enum _scn eax, uint32_t ebx, uint32_t ecx, uint32_t edx, uint32_t esi, uint32_t edi) {
  uint32_t out;
  uint32_t dummy;
  asm volatile (
    "int $0x30"
  : "=a" (out), "=c" (dummy), "=d" (dummy) : "a" (eax), "b" (ebx), "c" (ecx), "d" (edx), "S" (esi), "D" (edi));
  return out;
}

static inline void _yield_task() {
  asm volatile (
    "int $0x39"
  : : : "eax");
}

__attribute__ ((noreturn))
static inline void _exit_task() {
  asm volatile (
    "int $0x38"
  );
  __builtin_unreachable();
}

static inline _file_handle_t _open_file(_drive_number_t drive_number, const char *path) {
  return _sc2(_SCN_OPEN_FILE, drive_number, (uint32_t)path);
}

static inline void _close_file(_file_handle_t handle) {
  _sc1(_SCN_CLOSE_FILE, handle);
}

static inline uint32_t _file_read(_file_handle_t handle, uint32_t file_offset, uint32_t count, void *buffer) {
  return _sc4(_SCN_FILE_READ, handle, file_offset, count, (uint32_t)buffer);
}

static inline uint32_t _file_size(_file_handle_t handle) {
  return _sc1(_SCN_FILE_SIZE, handle);
}

static inline _process_handle_t _start_task(_drive_number_t drive_number, const char *path, const char *pass) {
  return _sc3(_SCN_START_TASK, drive_number, (uint32_t)path, (uint32_t)pass);
}

static inline void _log_string(const char *sz) {
  _sc1(_SCN_LOG_STRING, (uint32_t)sz);
}

static inline _key_code_t _get_key() {
  return _sc0(_SCN_GET_KEY);
}

static inline void *_allocate_ram(uint32_t pages) {
  return (void *)_sc1(_SCN_ALLOCATE_RAM, pages);
}

static inline uint32_t _kernel_dynamic_area_size() {
  return _sc1(_SCN_MEMORY_INFO, 0x0);
}

static inline uint32_t _kernel_dynamic_area_left() {
  return _sc1(_SCN_MEMORY_INFO, 0x1);
}

static inline uint32_t _total_userspace_size() {
  return _sc1(_SCN_MEMORY_INFO, 0x2);
}

static inline uint32_t _total_userspace_left() {
  return _sc1(_SCN_MEMORY_INFO, 0x3);
}

static inline uint32_t _this_process_memory_left() {
  return _sc1(_SCN_MEMORY_INFO, 0x4);
}

static inline void _wait_for_task(_process_handle_t handle) {
  _sc1(_SCN_WAIT_FOR_TASK, handle);
}

static inline uint32_t _enumerate_dir(_drive_number_t drive_number, const char *path, _dir_info_entry_t *buffer, uint32_t max_count) {
  return _sc4(_SCN_ENUMERATE_DIR, drive_number, (uint32_t)path, (uint32_t)buffer, max_count);
}

static inline void _print_at(uint8_t row, uint8_t col, const char *sz) {
  _sc2(_SCN_PRINT_AT, (row << 8) | col, (uint32_t)sz);
}

static inline uint32_t _count_of_dir(uint8_t drive_number, const char *path) {
  return _sc2(_SCN_COUNT_OF_DIR, drive_number, (uint32_t)path);
}

static inline void _clear_screen() {
  _sc0(_SCN_CLEAR_SCREEN);
}

static inline void _set_color(_vga_color_t color) {
  _sc1(_SCN_SET_COLOR, color);
}

#endif