#include "ascii.h"
#include <stdio.h>
#include <string>
#include <list>

std::list<std::string> code;

int current_editor = 0;

void init_terminal();
void do_terminal();

void init_code_editor();
void do_code_editor();

void loop() {
    if (btnp(KEY_TAB)) {
        current_editor = (++current_editor)%2;
        switch(current_editor) {
            case 0:
                init_terminal();
                break;
            case 1:
                init_code_editor();
                break;
        }
    }
    switch(current_editor) {
        case 0:
            do_terminal();
            break;
        case 1:
            do_code_editor();
            break;
    }
}

uint8_t get_char(uint8_t key) {
    SDL_Keymod mods = SDL_GetModState();
    if (key != KEY_UNKNOWN) {
        if (key < 30) {
            if ((mods & KMOD_SHIFT) || (mods & KMOD_CAPS)) {
                return key+61;
            } else {
                return key+93;
            }
        }
        else if (key == KEY_0) { if (mods & KMOD_SHIFT) { return '='; } else { return '0'; } }
        else if (key == KEY_1) { if (mods & KMOD_SHIFT) { return '!'; } else if (mods & KMOD_RALT) { return '|'; } else { return '1'; } }
        else if (key == KEY_2) { if (mods & KMOD_SHIFT) { return '"'; } else if (mods & KMOD_RALT) { return '@'; } else { return '2'; } }
        else if (key == KEY_3) { if (mods & KMOD_SHIFT) { return 144; } else if (mods & KMOD_RALT) { return '#'; } else { return '3'; } }
        else if (key == KEY_4) { if (mods & KMOD_SHIFT) { return '$'; } else if (mods & KMOD_RALT) { return '~'; } else { return '4'; } }
        else if (key == KEY_5) { if (mods & KMOD_SHIFT) { return '%'; } else if (mods & KMOD_RALT) { return 180; } else { return '5'; } }
        else if (key == KEY_6) { if (mods & KMOD_SHIFT) { return '&'; } else if (mods & KMOD_RALT) { return 173; } else { return '6'; } }
        else if (key == KEY_7) { if (mods & KMOD_SHIFT) { return '/'; } else { return '7'; } }
        else if (key == KEY_8) { if (mods & KMOD_SHIFT) { return '('; } else { return '8'; } }
        else if (key == KEY_9) { if (mods & KMOD_SHIFT) { return ')'; } else { return '9'; } }
        else if (key == KEY_SPACE) return 32;
        else if (key == KEY_MINUS) { if (mods & KMOD_SHIFT) { return '?'; } else { return '\''; } }
        else if (key == KEY_EQUALS) { if (mods & KMOD_SHIFT) { return 174; } else { return 175; } }
        else if (key == KEY_COMMA) { if (mods & KMOD_SHIFT) { return ';'; } else { return ','; } }
        else if (key == KEY_PERIOD) { if (mods & KMOD_SHIFT) { return ':'; } else { return '.'; } }
        else if (key == KEY_SLASH) { if (mods & KMOD_SHIFT) { return '_'; } else { return '-'; } }
        else if (key == KEY_LEFTBRACKET) { if (mods & KMOD_SHIFT) { return 160; } else if (mods & KMOD_RALT) { return '['; } else { return 96; } }
        else if (key == KEY_RIGHTBRACKET) { if (mods & KMOD_SHIFT) { return '*'; } else if (mods & KMOD_RALT) { return ']'; } else { return '+'; } }
        else if (key == KEY_APOSTROPHE) { if (mods & KMOD_SHIFT) { return 162; } else if (mods & KMOD_RALT) { return '{'; } else { return 161; } }
        else if (key == KEY_BACKSLASH) { if (mods & KMOD_SHIFT) { return 'C'; } else if (mods & KMOD_RALT) { return '}'; } else { return 'c'; } }
        else if (key == KEY_GRAVE) { if (mods & KMOD_SHIFT) { return '>'; } else  { return '<'; } }
        else if (key == KEY_NONUSBACKSLASH) { if (mods & KMOD_SHIFT) { return 164; } else if (mods & KMOD_RALT) { return '\\'; } else { return 163; } }
        else return 0;
    } else {
        return 0;
    }
}

void init_terminal() {
    setmode(0);
    cls();
}

void do_terminal() {
    //SDL_Keymod mods = SDL_GetModState();
    const uint8_t key = whichbtn();
    if (key != KEY_UNKNOWN) {
        if (key == KEY_RETURN or key == KEY_KP_ENTER) debug_get_cmd();
        else if (key == KEY_UP) next_cmd();
        else if (key == KEY_DOWN) prev_cmd();
        else if (key == KEY_BACKSPACE) debugchr(8);
        else {
            uint8_t chr = get_char(key);
            if (chr != 0) debugchr(chr);
        }
    }
}

void load_code() {
    FILE *f = fopen(get_filename(), "rb");
    fseek(f, 0, SEEK_END);
    long fsize = ftell(f);
    fseek(f, 0, SEEK_SET);  /* same as rewind(f); */
    char *buffer = (char*)malloc(fsize + 1);
    fread(buffer, 1, fsize, f);
    fclose(f);
    buffer[fsize] = 0;

    int start = 0;
    for (int pos=0;pos<fsize;++pos) {
        if (buffer[pos] == '\r') {
            buffer[pos]='\0';
            code.push_back(&buffer[start]);
            start=pos+2;
        }
    }
    free(buffer);
}

std::list<std::string>::iterator ls[28];
static int col = 0;
static int line = 0;
bool cursor_inverted = false;
int blink_wait = 30;

void refresh_code_editor() {
    color(COLOR_WHITE, COLOR_BLUE);
    cls();
    color(COLOR_BLACK, COLOR_LIGHT_GRAY);
    print("  File  Edit  Run                                                               ",0,0);
    print("                                                                               ",0,29);
    color(COLOR_WHITE, COLOR_BLUE);
    std::list<std::string>::iterator it = code.begin();
    int i=0;
    while (it != code.end() && i<28) {
        ls[i] = it;
        print((*it).c_str(), 0, i+1);
        ++i; ++it;
    }
}

void init_code_editor() {
    setmode(3);
    load_code();
    refresh_code_editor();
}

std::string get_current_line() {
    return *ls[line];
}

void invert_cursor() {
    cursor_inverted = !cursor_inverted;
    uint16_t pos = 0x1200 + col + (line+1)*80;
    uint8_t col = peek(pos);
    poke(pos, ((col >> 4) & 0x0f) + ((col << 4) & 0xf0) );
}

void move_cursor_up() {
    if (line > 0) {
        if (cursor_inverted) invert_cursor();
        line--;
        if (get_current_line().size() < col) col = get_current_line().size();
        blink_wait=1;
    }
}

void move_cursor_down() {
    if (line < code.size()-1) {
        if (cursor_inverted) invert_cursor();
        line++;
        if (get_current_line().size() < col) col = get_current_line().size();
        blink_wait=1;
    }
}

void move_cursor_right() {
    if ( col < get_current_line().size() ) {
        if (cursor_inverted) invert_cursor();
        col++;
        blink_wait=1;
    } else {
        if (line < code.size()-1) {
            col = 0;
            move_cursor_down();
        }
    }
}

void move_cursor_left() {
    if (col > 0) {
        if (cursor_inverted) invert_cursor();
        col--;
        blink_wait=1;
    } else {
        if (line > 0) {
            move_cursor_up();
            col = get_current_line().size();
        }
    }
}

void split_line() {
    std::string str = get_current_line();
    *ls[line] = str.substr(col);
    std::list<std::string>::iterator newline = ls[line]++;
    code.insert(newline, str.substr(0, col));

    if (cursor_inverted) invert_cursor();
    line++; col=0;
    blink_wait=1;
    refresh_code_editor();
}

void join_lines() {
    if (cursor_inverted) invert_cursor();
    std::string str = get_current_line();
    //std::list<std::string>::iterator prevline = ls[line]--;
    code.erase(ls[line]);
    line--;
    const int line_size = (*ls[line]).size();
    *ls[line] += str;
    col = line_size;
    blink_wait=1;
    refresh_code_editor();
}

void delete_char() {
    if (col == 0) {
        if (line > 0) join_lines();
    } else {
    if (cursor_inverted) invert_cursor();
        std::string str = get_current_line();
        std::string a = str.substr(0,col-1);
        std::string b = str.substr(col);
        *ls[line] = a+b;
        col--;
        blink_wait=1;
        refresh_code_editor();
    }
}

void do_code_editor() {
    const uint8_t key = whichbtn();
    if (key != KEY_UNKNOWN) {
        if (key == KEY_RETURN or key == KEY_KP_ENTER) {
            split_line();
        }
        else if (key == KEY_UP) move_cursor_up();
        else if (key == KEY_DOWN) move_cursor_down();
        else if (key == KEY_LEFT) move_cursor_left();
        else if (key == KEY_RIGHT) move_cursor_right();
        else if (key == KEY_BACKSPACE) delete_char(); 
        else {
            uint8_t chr = get_char(key);
            if (chr != 0) debugchr(chr);
        }
    }

    blink_wait--;
    if (blink_wait == 0) {
        blink_wait = 30;
        invert_cursor();
    }
}