#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>

const int SCREEN_WIDTH = 900;
const int SCREEN_HEIGHT = 700;
const int SCROLLBACK_DEFAULT_SIZE = 4096;
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};

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

typedef struct {
    int parent;
    int child;
} FileDescriptors;

typedef struct {
    Scrollback* sb;
    char *readline;
    int rline_len;
    TTF_Font* font;
    SDL_Renderer* renderer;
} Context;

void
die(const char *errstr, ...)
{
	va_list ap;

	va_start(ap, errstr);
	vfprintf(stderr, errstr, ap);
	va_end(ap);
	exit(1);
}
void spawn(FileDescriptors *fds) {
    if (openpty(&fds->parent, &fds->child, NULL, NULL, NULL)) {
        fprintf(stderr, "openpty() failed: %s\n", strerror(errno));
        exit(1);
    }
    // pid_t p = forkpty(&fds->parent, NULL, NULL, NULL);
    // int _stdout = dup(STDOUT_FILENO);
    // dup2(fds->child, STDOUT_FILENO);
    pid_t p = fork();
    if (p == 0) {

        setsid();
        if (ioctl(fds->child, TIOCSCTTY, NULL))
			die("ioctl TIOCSCTTY failed: %s\n", strerror(errno));
        dup2(fds->child, STDIN_FILENO);
        dup2(fds->child, STDOUT_FILENO);
        dup2(fds->child, STDERR_FILENO);

        close(fds->parent);
        close(fds->child);
        char **args = NULL;
        execvp("/usr/bin/bash", args);
        // execvp("/usr/bin/dash", args);
    } else {
        fds->child = p;
        close(fds->child);
    }
}

int read_pty(FileDescriptors *fds, Scrollback *sb) {
    char readbuf[512];
    ssize_t nread = read(fds->parent, readbuf, sizeof(readbuf));
    switch (nread) {
    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;
            void *buf = realloc(sb->buf, sb->capacity);
            if (buf == NULL) {
                fprintf(stderr, "We couldn't get anymore memory");
                exit(1);
            }
            sb->buf = buf;
            printf("Reallocated scrollback buffer\n");
        }
        if (readbuf[nread - 1] == '\n') {
            printf("are you firing when you shouldnt?\n");
            nread--;
        }
        for (int i = 0; i < nread; i++) {
            if (readbuf[i] == '\r') {
                readbuf[i] = '\n';
            }
        }
        memcpy(sb->buf + sb->length, readbuf, nread);
        sb->length += nread;
        sb->buf[sb->length+1] = '\0';
        return nread;
    }
}

void render_scrollback(Context* ctx) {
    SDL_RenderClear(ctx->renderer);

    // SDL_Color current_color = WHITE;
    int col_max = 120;
    char row_buf[col_max];
    int nrow = 0;
    int ncol = 0;
    int last_xpos = 0;
    Scrollback sb = *ctx->sb;
    for (int c = 0; c < sb.length; c++) {
        if ((sb.buf[c] == '\n' && ncol > 0) || c == sb.length - 1) {
            row_buf[ncol] = '\0';
            SDL_Surface* surface =
                TTF_RenderText_Blended(ctx->font, row_buf, WHITE);

            if (surface == NULL) {
                fprintf(stderr, "DONT PRINT THERES AN ERROR");
                return;
            }

            // now you can convert it into a texture
            SDL_Texture* texture = SDL_CreateTextureFromSurface(ctx->renderer, surface);

            SDL_Rect rect;
            rect.x = 0;
            rect.y = nrow * 20;

            rect.w = surface->w;
            rect.h = surface->h;

            last_xpos = surface->w;

            SDL_RenderCopy(ctx->renderer, texture, NULL, &rect);

            SDL_DestroyTexture(texture);
            SDL_FreeSurface(surface);

            if (c < sb.length - 1) {
                nrow++;
                ncol = 0;
            }

        // Control sequence
        } 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 if (sb.buf[c] != '\n') {
            row_buf[ncol++] = sb.buf[c];
        }
    }

    // We drew the scrollback buffer, now draw the user's prompt
    if (ctx->rline_len > 0) {
        SDL_Surface* surface =
            TTF_RenderText_Blended(ctx->font, ctx->readline, WHITE);

        if (surface == NULL) {
            fprintf(stderr, "DONT PRINT THERES AN ERROR");
            return;
        }

        // now you can convert it into a texture
        SDL_Texture* texture = SDL_CreateTextureFromSurface(ctx->renderer, surface);

        SDL_Rect rect;
        rect.x = last_xpos + 10;
        rect.y = nrow * 20;

        rect.w = surface->w;
        rect.h = surface->h;


        SDL_RenderCopy(ctx->renderer, texture, NULL, &rect);

        SDL_DestroyTexture(texture);
        SDL_FreeSurface(surface);
        
    }

    SDL_RenderPresent(ctx->renderer);
}

int main(void) {
    Scrollback sb = { 0 };
    FileDescriptors fds = { 0 };

    spawn(&fds);

    if (SDL_Init(SDL_INIT_EVERYTHING) < 0) {
        printf("error initializing SDL: %s\n", SDL_GetError());
        return 1;
    }
    int start_x = 20;
    int start_y = 20;
    SDL_Window* window = SDL_CreateWindow("bt",
                                          start_x,
                                          start_y,
                                          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_Init();
    TTF_Font* font = TTF_OpenFont( "./fira.ttf", 16);

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

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

    sb.capacity = SCROLLBACK_DEFAULT_SIZE;
    sb.buf = malloc(sb.capacity);
    sb.buf[0] = '\0';
    sb.length = 0;

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

    sb.ypos = 0;

    Context ctx = {
        .sb = &sb,
        .font = font,
        .renderer = renderer,
        .readline = malloc(256),
        .rline_len = 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();
                // TODO: Don't remember why I was doing this
                // key = GetCharPressed();
                // new_char = true;
                if (key == SDL_SCANCODE_F1) {
                    printf("Debug Printing Scrollback Length %d:\n", sb.length);
                    printf("%s\n", sb.buf);
                    printf("============\n");
                } else if ((key >= 32) && (key <= 125)) {
                    ctx.readline[ctx.rline_len] = (char)key;
                    ctx.rline_len++;
                    ctx.readline[ctx.rline_len] = '\0';
                }

                if (key == SDLK_RETURN) {
                    ctx.readline[ctx.rline_len] = '\r';
                    ctx.rline_len++;
                    write(fds.parent, ctx.readline, ctx.rline_len);
                    ctx.rline_len = 0;
                    new_char = true;
                }
                if (key == SDLK_BACKSPACE) {
                    if (ctx.rline_len > 0) {
                        ctx.rline_len--;
                        ctx.readline[ctx.rline_len] = '\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;

        // 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);
            // }
        }


        int nread = read_pty(&fds, &sb);
        if (nread > 0) {
            new_read = true;
        }

        // if (nread > 0) {
            render_scrollback(&ctx);
        // }
    }

    free(sb.buf);
    free(ctx.readline);
    TTF_CloseFont(font);
    TTF_Quit();
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);

    SDL_Quit();
}