#define _GNU_SOURCE
#include <sys/select.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <pty.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdbool.h>

#include <SDL2/SDL.h>
#include <SDL2/SDL_events.h>
#include <SDL2/SDL_ttf.h>
#include <SDL2/SDL_keycode.h>

typedef struct scrollback {
    float height;
    float ypos;
    int capacity;
    int length;
    char *buf;
} scrollback;

typedef struct file_descriptors {
    int master;
    int child;
} file_descriptors;

void spawn(file_descriptors *fds) {
    openpty(&fds->master, &fds->child, NULL, NULL, NULL);
    pid_t p = fork();
    if (p == 0) {
        close(fds->master);

        setsid();
        ioctl(fds->child, TIOCSCTTY, NULL);
        dup2(fds->child, 0);
        dup2(fds->child, 1);
        dup2(fds->child, 2);

        execle("/bin/bash", "-/bin/bash", (char *)NULL, (char *[]){ "TERM=dumb", NULL });
    } else {
        close(fds->child);
    }
}

const int SCREEN_WIDTH = 900;
const int SCREEN_HEIGHT = 700;
const SDL_Color WHITE = {255, 255, 255, 255};
const SDL_Color BLACK = {0, 0, 0, 255};
const SDL_Color RED = {255, 0, 0, 255};
const SDL_Color GREEN = {0, 255, 0, 255};
const SDL_Color BLUE = {0, 0, 255, 255};
const SDL_Color YELLOW = {255, 255, 0, 255};
const SDL_Color MAGENTA = {255, 0, 255, 255};
const SDL_Color SKYBLUE = {0, 255, 255, 255};
const SDL_Color RAYWHITE = {200, 200, 200, 255};

int read_pty(file_descriptors *fds, scrollback *sb) {
    ssize_t nread;
    char readbuf[256];
    switch (nread = read(fds->master, readbuf, sizeof(readbuf))) {
    case -1:
        if (errno == EAGAIN) {
            return 0;
        } else {
            return 0;
        }
    case 0:
        printf("EOF\n");
        return 0;
    default:
        if (sb->length + nread > sb->capacity) {
            sb->capacity *= 2;
            sb->buf = realloc(sb->buf, sb->capacity);
        }
        if (readbuf[nread - 1] == '\n') {
            nread--;
        }
        readbuf[nread] = '\0';
        strcat(sb->buf, readbuf);
        return nread;
    }
}

int main(void) {
    scrollback sb = { 0 };
    file_descriptors fds = { 0 };

    spawn(&fds);

    if (SDL_Init(SDL_INIT_EVERYTHING) < 0) {
        printf("error initializing SDL: %s\n", SDL_GetError());
        return 1;
    }

    SDL_Window* window = SDL_CreateWindow( "bt",
                                           SDL_WINDOWPOS_UNDEFINED,
                                           SDL_WINDOWPOS_UNDEFINED,
                                           SCREEN_WIDTH,
                                           SCREEN_HEIGHT,
                                           SDL_WINDOW_SHOWN );
    if (window == NULL) {
        printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );
        return 1;
    }

    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    SDL_SetRenderDrawColor(renderer, 130, 163, 255, 1);

    TTF_Font* font = TTF_OpenFont( "./fira.ttf", 16);

    struct winsize sz;
    int result = ioctl(fds.master, TIOCGWINSZ, &sz);
    sz.ws_col = 200;
    sz.ws_row = 120;
    result = ioctl(fds.master, TIOCSWINSZ, &sz);

    // TODO: It would be nice to figure out how to do this in SDL
    // SetTargetFPS(60);

    sb.capacity = 2048;
    sb.buf = malloc(sb.capacity);
    sb.buf[0] = '\0';
    sb.length = 0;
    char buf[128];
    int buf_len = 0;

    int flags = fcntl(fds.master, F_GETFL);
    flags |= O_NONBLOCK;
    fcntl(fds.master, F_SETFL, flags);
    fd_set rset;
    FD_ZERO(&rset);
    FD_SET(fds.master, &rset);

    sb.ypos = 0;

    bool new_read = false;
    bool new_char = false;
    SDL_Event e;
    bool quit = false;
    while (quit == false) {
        while (SDL_PollEvent( &e)) {
            if (e.type == SDL_QUIT) {
                quit = true;
            } else if (e.type == SDL_KEYDOWN) {

            }
            char key = e.key.keysym.sym;
            // TODO: Translate this all to SDL2
            // int key = GetCharPressed();
            while (key > 0) {
                if ((key >= 32) && (key <= 125)) {
                    buf[buf_len] = (char)key;
                    buf[buf_len + 1] = '\0';
                    buf_len++;
                    sb.buf[sb.length] = (char)key;
                    sb.buf[sb.length + 1] = '\0';
                    sb.length++;
                }
                // TODO: Don't remember why I was doing this
                // key = GetCharPressed();
                // new_char = true;
            }

            if (key == SDLK_RETURN) {
                sb.length -= buf_len;
                sb.buf[sb.length] = '\0';
                write(fds.master, buf, buf_len);
                write(fds.master, "\r", 1);
                buf[0] = '\0';
                buf_len = 0;
                new_char = true;
            }
            if (key == SDLK_BACKSPACE) {
                if (buf_len > 0) {
                    buf_len--;
                    buf[buf_len] = '\0';
                    sb.length--;
                    sb.buf[sb.length] = '\0';
                }
                new_char = true;
            }
        }
        float scroll_speed = 35.5f;
        // TODO: We have to convert both these lines to SDL
        // sb.ypos += GetMouseWheelMoveV().y * scroll_speed;
        // sb.height = MeasureTextEx(*fontDefault, sb.buf, fontsize, 1).y;

        SDL_Surface* surfaceMessage =
            TTF_RenderText_Solid(font, "put your text here", WHITE); 

        // now you can convert it into a texture
        SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surfaceMessage);


        // TODO: This is probably related to the font height and scrolling up, we just need
        // the "fontsize" which I think is probably the height of the text
        if (new_read || new_char) {
            // if (sb.height - (float)abs((int)sb.ypos) + fontsize > (float)SCREEN_HEIGHT) {
            //     sb.ypos = -(sb.height - SCREEN_HEIGHT) - fontsize;
            // }
            new_read = false;
            new_char = false;
        } else {
            // if (sb.ypos > 0) {
            //     sb.ypos = 0;
            // } else if (abs((int)sb.ypos) > sb.height - fontsize) {
            //     sb.ypos = -(sb.height - fontsize);
            // }
        }


        // Drawing
        {
            int nread = read_pty(&fds, &sb);
            if (nread > 0) {
                sb.length += nread;
                new_read = true;
            }
            SDL_RenderClear(renderer);
            SDL_Color current_color = WHITE;
            int col_max = 200;
            char row_buf[col_max];
            int nrow = 0;
            int ncol = 0;
            int row_height = 18;
            float row_posx = 0;
            for (int c = 0; c <= sb.length; c++) {
                if (sb.buf[c] == '\r') {
                    continue;
                } else if (sb.buf[c] == '\n' || sb.buf[c] == '\0' || ncol >= col_max) {
                    row_buf[ncol] = '\0';
                    // TODO: Render new line or something?
                    // Vector2 pos = { row_posx, nrow * row_height + sb.ypos };
                    // DrawTextEx(*fontDefault, row_buf, pos, fontsize, 0, current_color);
                    nrow++;
                    ncol = 0;
                    row_posx = 0;
                } else if (sb.buf[c] == '\x1b') {
                    int c2 = c + 1;
                    // Control Sequence Introducer
                    int csi_args[16];
                    char csi_code;
                    int nargs = 0;
                    if (sb.buf[c2] == '[') {
                        char *esc_buf = sb.buf + c2 + 1;
                        while (true) {
                            char *substr;
                            long num = strtol(esc_buf, &substr, 10);
                            if (esc_buf != substr) {
                                csi_args[nargs++] = num;
                                esc_buf = substr;
                                if (substr[0] == ';') {
                                    esc_buf++;
                                }
                                continue;
                            }
                            csi_code = substr[0];
                            SDL_Color new_color = WHITE;
                            switch (csi_code) {
                                case 'm':
                                    for (int i = 0; i < nargs; i++) {
                                        if (csi_args[i] == 31) {
                                            new_color = RED;
                                        } else if (csi_args[i] == 32) {
                                            new_color = GREEN;
                                        } else if (csi_args[i] == 33) {
                                            new_color = YELLOW;
                                        } else if (csi_args[i] == 34) {
                                            new_color = BLUE;
                                        } else if (csi_args[i] == 35) {
                                            new_color = MAGENTA;
                                        } else if (csi_args[i] == 36) {
                                            new_color = SKYBLUE;
                                        } else if (csi_args[i] == 0) {
                                            new_color = RAYWHITE;
                                        }
                                    }
                                    row_buf[ncol] = '\0';
                                    // TODO: This looks like the actual place where we
                                    // draw the text at a line
                                    // Vector2 pos = { row_posx, nrow * row_height + sb.ypos };
                                    // DrawTextEx(*fontDefault, row_buf, pos, fontsize, 0, current_color);
                                    current_color = new_color;
                                    ncol = 0;
                                    c += (substr) - (sb.buf + c);
                                    // TODO: Get the text height
                                    // int width = MeasureTextEx(*fontDefault, row_buf, fontsize, 1).x;
                                    // row_posx += width + 0.85;
                                  break;
                            }
                            break;
                        }
                    }
                } else {
                    row_buf[ncol++] = sb.buf[c];
                }
            }
        }
    }

    // TODO: Figure out when to free this thing
    // SDL_FreeSurface(texture);

    TTF_CloseFont(font);
    TTF_Quit();

    SDL_Quit();
}