#include "UI.h"
#include <raylib.h>
#include <stdio.h>
#include "../resources/resources.h"

const int MAX_LINES = 8192;
const int SPACING_H = 1;

void DrawRecBordered(Rectangle rec, Color bg, Color border_color, int border_width) {
    DrawRectangleRounded(rec, ROUNDNESS, ROUNDNESS_SEGMENTS, bg); 
    DrawRectangleRoundedLinesEx(rec, ROUNDNESS, ROUNDNESS_SEGMENTS, border_width, border_color);
}

float MeasureChar(Font *font, int height, char symbol) {
    char buf[2] = { symbol, 0 };
    return MeasureTextEx(*font, buf, height, SPACING_H).x;
}

int CalculateSpans(Rectangle rec, char *text, Font *font, int height, int *spans) {
    spans[0] = 0;
    int ptr = 0, span_ptr = 1;
    int last_space_ptr = -1;
    float acc = 0;

    while (text[ptr] != 0x0) {
        char symbol = text[ptr];
        float char_width = MeasureChar(font, height, symbol);
        acc += char_width + SPACING_H;

        if (symbol == '\n') {
            spans[span_ptr] = ptr;
            spans += 1;
            ptr += 1;
            acc = 0;
            continue;
        }

        if (symbol == ' ') {
            last_space_ptr = ptr;
        }

        if (acc > rec.width) {
            if (last_space_ptr < spans[span_ptr - 1] || symbol == '\n' && last_space_ptr == -1) {
                spans[span_ptr] = (ptr > spans[span_ptr - 1]) ? ptr : ptr + 1;
                last_space_ptr = spans[span_ptr];
                ptr = spans[span_ptr] - 1;
            } else {
                if (spans[span_ptr - 1] == last_space_ptr) {
                    spans[span_ptr] = ptr;
                    last_space_ptr = ptr;
                } else {
                    spans[span_ptr] = last_space_ptr + 1;
                }
                ptr = last_space_ptr;
            }
            // printf("span %d = '%.*s'\n", span_ptr, spans[span_ptr] - spans[span_ptr - 1], text + spans[span_ptr - 1]);
            span_ptr++;
            acc = 0;
        }
        ptr++;
        if (span_ptr >= MAX_LINES) break;
    }

    spans[span_ptr] = ptr; 
    // printf("span %d = '%.*s'\n", span_ptr, spans[span_ptr] - spans[span_ptr - 1], text + spans[span_ptr - 1]);
    return span_ptr + 1;
}

bool IsMouseInRec(Rectangle rec) {
    Vector2 MousePos = GetMousePosition();
    return CheckCollisionPointRec(MousePos, rec);
}

void DrawTextInRec(Rectangle rec, char *text, Font *font, int height, Color color, float padding, int *scroll) {
    if (text == NULL) return;
    int spans[MAX_LINES];
    rec.x += padding;
    rec.y += padding;
    rec.width -= 2 * padding;
    rec.height -= 2 * padding;
    int lines = CalculateSpans(rec, text, font, height, spans);

    if (lines == 2) {
        Vector2 pos = {.x = rec.x, .y = rec.y};
        DrawTextEx(*font, text, pos, height, SPACING_H, color);
        return;
    }

    int vertical_acc = scroll == NULL ? rec.y : rec.y - *scroll;
    int text_height = lines * height;
    int max_scroll = text_height - rec.height;

    if (text_height >= rec.height && IsMouseInRec(rec)) {
        *scroll -= GetMouseWheelMove() * SCROLL_SENC;
        if (*scroll < 0) *scroll = 0;
        if (*scroll > max_scroll) *scroll = max_scroll;
    }

    BeginScissorMode(rec.x, rec.y, rec.width, rec.height);
    for (int i = 1; i < lines; i++) {
        if (i == MAX_LINES) break;
        Vector2 pos = { .x = rec.x, .y = vertical_acc };
        char *line_start = text + spans[i-1];
        int line_length = spans[i] - spans[i-1];
        // printf("Drawing text '%.*s' at %f;%f\n", line_length - 1, line_start, pos.x, pos.y);
        DrawTextEx(*font, 
                TextFormat("%.*s", line_length - 1, line_start), 
                pos, height, SPACING_H, color);
        vertical_acc += height;
    }
    // TraceLog(LOG_FATAL, "done");
    EndScissorMode();
}

void GetPanesSplit(Rectangle *pane1, Rectangle *pane2, Rectangle body, float proportion_h, float proportion_v) {
    if (body.height >= body.width) {
        // vertical split
        pane1->x = body.x;
        pane1->y = body.y;
        pane1->width = body.width;
        pane1->height = (body.height - PADDING) * proportion_v;

        pane2->x = body.x;
        pane2->y = body.y + pane1->height + PADDING;
        pane2->width = body.width;
        pane2->height = (body.height - PADDING) * (1 - proportion_v);
        return;
    }

    // horizontal split
    pane1->x = body.x;
    pane1->y = body.y;
    pane1->height = body.height;
    pane1->width = (body.width - PADDING) * proportion_h;

    pane2->y = body.y;
    pane2->x = body.x + pane1->width + PADDING;
    pane2->height = body.height;
    pane2->width = (body.width - PADDING) * (1 - proportion_h);
}

void DrawPageView(int y, unsigned int pages, unsigned int current_page) {
    if (pages == 0) return;
    float width = 2 * PAGE_DOTS_PADDING 
            + PAGE_DOTS_RADIUS * 2 * pages 
            + PAGE_DOTS_SPACING * (pages - 1);

    Rectangle rec = {
        .x = (GetScreenWidth() - width) / 2, // TODO
        .y = y,
        .height = PAGE_DOTS_RADIUS * 2 + 2 * PAGE_DOTS_PADDING,
        .width = width,
    };

    Color color = { 
        .r = COLORSCHEME_WHITE.r,
        .g = COLORSCHEME_WHITE.g,
        .b = COLORSCHEME_WHITE.b,
        .a = COLORSCHEME_WHITE.a & PAGE_DOTS_TRANSPARENCY };

    DrawRectangleRounded(rec, ROUNDNESS, ROUNDNESS_SEGMENTS, color); 

    int x_pos = (int)rec.x + PAGE_DOTS_PADDING + PAGE_DOTS_RADIUS;
    int y_pos = (int)rec.y + PAGE_DOTS_PADDING + PAGE_DOTS_RADIUS;
    for (int i = 0; i < pages; ++i) {
        Color color = i == current_page ? COLORSCHEME_ORANGE : COLORSCHEME_BROWN;
        DrawCircle(x_pos, y_pos, PAGE_DOTS_RADIUS, color);
        x_pos += PAGE_DOTS_SPACING + PAGE_DOTS_RADIUS * 2;
    }
}