#include "src/app/terminal.h"
#include "src/app/cat.h"
#include "src/app/ls.h"
#include "src/fs.h"
#include "src/memory.h"
#include "src/path.h"
#include "src/process.h"
#include "src/string.h"
#include "src/util.h"

#include <stdint.h>

static void help(process_t *proc, uint8_t argc, char **argv);
static void cd(process_t *proc, uint8_t argc, char **argv);

#define PROMPT_LENGTH 255

static const char bs[PROMPT_LENGTH + 1];
static const char ws[PROMPT_LENGTH + 1];

static char prompt[PROMPT_LENGTH + 1];
static uint8_t prompt_length = 0;
static uint8_t prompt_offset = 0;

process_t *proc;

static uint8_t active = 1;

typedef struct {
  const char *name;
  app_t app;
} app_entry_t;

static app_entry_t apps[] = {
    {"help", help},
    {"cd", cd},
    {"ls", ls},
    {"cat", cat},
};

static void help(process_t *proc, uint8_t argc, __attribute__((unused)) char **argv) {
  if (argc > 1) {
    WRITE_S("help: accepts no arguments\n");
  }

  WRITE_S("Available commands:\n");
  for (uint64_t i = 0; i < sizeof(apps) / sizeof(app_entry_t); i++) {
    WRITE_D(apps[i].name);
    WRITE_S("\n");
  }
}

static void cd(process_t *proc, uint8_t argc, char **argv) {
  if (argc != 2) {
    WRITE_S("cd: requires a single path\n");
    return;
  }

  path_t *new = path_open(proc->root, proc->cwd, argv[1]);
  if (!new) {
    WRITE_S("cd: path does not exist\n");
    return;
  }

  path_close(proc->cwd);
  proc->cwd = new;
}

static void print_prompt() {
  WRITE_S("[");
  fs_node_t *curr = proc->cwd->depth ? proc->cwd->stack[proc->cwd->depth - 1] : proc->root;
  WRITE_D(curr->name);
  WRITE_S("]$ ");
}

static void on_home_pressed() {
  if (!prompt_offset) {
    return;
  }

  proc->stdout->write(proc->stdout, bs, prompt_offset);
  prompt_offset = 0;
}

static void on_left_pressed() {
  if (!prompt_offset) {
    return;
  }

  proc->stdout->write(proc->stdout, bs, 1);
  prompt_offset--;
}

static void on_right_pressed() {
  if (prompt_offset == prompt_length) {
    return;
  }

  proc->stdout->write(proc->stdout, prompt + prompt_offset, 1);
  prompt_offset++;
}

static void on_end_pressed() {
  if (prompt_offset == prompt_length) {
    return;
  }

  proc->stdout->write(proc->stdout, prompt + prompt_offset, prompt_length - prompt_offset);
  prompt_offset = prompt_length;
}

static void on_enter_pressed() {
  prompt[prompt_length] = '\0';

  char *argv[16];
  uint8_t argc = (uint8_t)string_split(prompt, ' ', 16, argv);

  WRITE_S("\n");

  uint8_t i;
  for (i = 0; i < sizeof(apps) / sizeof(app_entry_t); i++) {
    if (string_equal(argv[0], apps[i].name)) {
      apps[i].app(proc, argc, argv);
      break;
    }
  }
  if (i == sizeof(apps) / sizeof(app_entry_t)) {
    WRITE_S("Unknown command\n");
  }
  prompt_length = prompt_offset = 0;
  print_prompt();
}

static void on_cancel_pressed() {
  WRITE_S("^C\n");
  prompt_length = prompt_offset = 0;
  print_prompt();
}

static void on_disconnect_pressed() {
  WRITE_S("^D\n");
  active = 0;
}

static void on_ctrl_character_pressed(char c) {
  if (c == 'c') {
    on_cancel_pressed();
  } else if (c == 'd') {
    on_disconnect_pressed();
  }
}

static void redraw_from_cursor() {
  uint64_t tail = prompt_length - prompt_offset;
  proc->stdout->write(proc->stdout, prompt + prompt_offset, tail);
  proc->stdout->write(proc->stdout, ws, 1);        // erase the character past the end
  proc->stdout->write(proc->stdout, bs, tail + 1); // move back to cursor position
}

static void on_character_pressed(char c) {
  if (prompt_offset >= PROMPT_LENGTH)
    return;

  if (prompt_offset != prompt_length) {
    memory_move(prompt + prompt_offset, prompt_length - prompt_offset, prompt + prompt_offset + 1);
  }
  prompt[prompt_offset] = c;
  prompt_length++;
  prompt_offset++;

  proc->stdout->write(proc->stdout, &c, 1); // emit the character itself
  redraw_from_cursor();
}

static void on_backspace_pressed() {
  if (!prompt_offset)
    return;

  if (prompt_offset != prompt_length) {
    memory_move(prompt + prompt_offset, prompt_length - prompt_offset, prompt + prompt_offset - 1);
  }
  prompt_offset--;
  prompt_length--;

  proc->stdout->write(proc->stdout, bs, 1);
  redraw_from_cursor();
}

static void on_delete_pressed() {
  if (prompt_offset == prompt_length)
    return;

  memory_move(prompt + prompt_offset + 1, prompt_length - prompt_offset - 1, prompt + prompt_offset);
  prompt_length--;

  redraw_from_cursor();
}

typedef enum {
  PARSE_NORMAL,
  PARSE_ESC,
  PARSE_CSI,
} parse_state_t;

static parse_state_t parser_state = PARSE_NORMAL;
static char parser_csi_param[8];
static uint8_t parser_csi_len;

static void on_char_received(char c) {
  switch (parser_state) {
  case PARSE_NORMAL:
    if (c == '\x1B') {
      parser_state = PARSE_ESC;
    } else if (c == '\b' || c == '\x7F') {
      on_backspace_pressed();
    } else if (c == '\n' || c == '\r') {
      on_enter_pressed();
    } else if (c >= '\x01' && c <= '\x1A') {
      on_ctrl_character_pressed(c + 'a' - 1);
    } else if (c >= ' ') {
      on_character_pressed(c);
    }
    break;

  case PARSE_ESC:
    if (c == '[') {
      parser_state = PARSE_CSI;
      parser_csi_len = 0;
    } else {
      parser_state = PARSE_NORMAL;
    }
    break;

  case PARSE_CSI:
    if ((c >= '0' && c <= '9') || c == ';') {
      if (parser_csi_len < sizeof(parser_csi_param) - 1) {
        parser_csi_param[parser_csi_len++] = c;
      }
    } else {
      parser_state = PARSE_NORMAL;
      parser_csi_param[parser_csi_len] = '\0';

      switch (c) {
      case 'C':
        on_right_pressed();
        break;
      case 'D':
        on_left_pressed();
        break;
      case 'H':
        on_home_pressed();
        break;
      case 'F':
        on_end_pressed();
        break;
      case '~':
        if (parser_csi_param[0] == '3') {
          on_delete_pressed();
        }
        break;
      }
    }
    break;
  }
}

void terminal(process_t *p, __attribute__((unused)) uint8_t argc, __attribute__((unused)) char **argv) {
  memory_set('\b', PROMPT_LENGTH, (char *)bs);
  memory_set(' ', PROMPT_LENGTH, (char *)ws);

  proc = p;

  char *greeting = string_format("Welcome to FreywarOS v%s!\n\n", VERSION);
  WRITE_D(greeting);
  memory_free(greeting);

  print_prompt();

  while (active) {
    char c;
    if (proc->stdin->read(proc->stdin, 1, &c)) {
      on_char_received(c);
    }
  }

  proc = NUL;
}