/*
 * Copyright (C) 2025 dwlr <dweller@cabin.digital>
 *
 * BSD 3-Clause License (BSD-3-Clause)
 * See LICENSE for details
 */

#define _DEFAULT_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <time.h>
#include <stdarg.h>
#include <ctype.h>

#include <endian.h>

#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include <X11/Xresource.h>

#include "bits.c"
#include "log.c"
#include "tga.c"
#include "x11.c"

#include "chip8.c"
#include "meta/disasm.c"
#include "meta/exec.c"


typedef struct
{
    void* usr;

    usize hot;
    usize active;
    usize kbdfocus;

    /* mouse */
    u16 x;
    u16 y;

    u8 pbtns;
    u8 btns;

} iui;

void iui_start(iui* ui, void* usr)
{
    assert(ui);

    ui->usr = usr;
    ui->hot = 0;
}

void iui_end(iui* ui)
{
    assert(ui);

    if(!ui->btns) ui->active = 0;
    else
    {
        if(!ui->active) ui->kbdfocus = 0;
    }

    ui->pbtns = ui->btns;
}

bool iui_mouse_inside(iui* ui, u16 x, u16 y, u16 w, u16 h)
{
    return !(ui->x < x || ui->y < y || ui->x >= x + w || ui->y >= y + h);
}

int iui_button(iui* ui, u16 x, u16 y, int w, int h, char* label)
{
    xctx*  x11 = (xctx*)ui->usr;
    usize   id = (usize)label;
    bool imhot, imactive;

    if(iui_mouse_inside(ui, x, y, w, h))
    {
        bool click = ui->btns & bit(1) && !(ui->pbtns & bit(1));
        if(!ui->active && click) ui->active = id;
        ui->hot = id;
    }

    imhot    = ui->hot    == id;
    imactive = ui->active == id;

    {
        XGCValues gcvals = {0};

        if(imhot) gcvals.line_width = 2;
        else gcvals.line_width = 1;

        if(imactive) gcvals.foreground = x11->cols.as.fg;
        else gcvals.foreground = x11->cols.as.bg;

        XChangeGC(x11->disp, x11->gc, GCForeground | GCLineWidth, &gcvals);
        XFillRectangle(x11->disp, x11->wnd, x11->gc, x, y, w, h);

        XSetForeground(x11->disp, x11->gc, x11->cols.as.fg);
        XDrawLine(x11->disp, x11->wnd, x11->gc, x, y, x, y + h);
        XDrawLine(x11->disp, x11->wnd, x11->gc, x + w, y, x, y);

        XSetForeground(x11->disp, x11->gc, x11->cols.as.fg);
        XDrawLine(x11->disp, x11->wnd, x11->gc, x, y + h, x + w, y + h);
        XDrawLine(x11->disp, x11->wnd, x11->gc, x + w, y + h, x + w, y);
    }

    {
        usize len;
        int xx, yy;
        int di, fa, fd;
        int width, height;
        XCharStruct chs = {0};

        len = strlen(label);
        XTextExtents(x11->xfs, label, len, &di, &fa, &fd, &chs);
        width  = chs.rbearing - chs.lbearing;
        height = chs.ascent   + chs.descent;

        xx = x + w / 2 - width / 2;
        yy = y + h / 2 + height / 2;

        if(imactive) XSetForeground(x11->disp, x11->gc, x11->cols.as.bg);
        else XSetForeground(x11->disp, x11->gc, x11->cols.as.fg);
        XDrawString(x11->disp, x11->wnd, x11->gc, xx, yy, label, len);
    }

    return imhot && imactive && !(ui->btns & bit(1));
}

int iui_textbox(iui* ui, u16 x, u16 y, int w, int h, char* buf, usize buflen)
{
    xctx*  x11 = (xctx*)ui->usr;
    usize   id = (usize)buf;
    bool imhot, imactive;
    usize len;

    len = strlen(buf);

    if(iui_mouse_inside(ui, x, y, w, h))
    {
        bool click = ui->btns & bit(1) && !(ui->pbtns & bit(1));
        if(!ui->active && click) ui->active = id;
        ui->hot = id;
    }

    imhot    = ui->hot    == id;
    imactive = ui->active == id;

    {
        XGCValues gcvals = {0};

        if(imhot) gcvals.line_width = 2;
        else gcvals.line_width = 1;

        gcvals.foreground = x11->cols.as.bg;

        XChangeGC(x11->disp, x11->gc, GCForeground | GCLineWidth, &gcvals);
        XFillRectangle(x11->disp, x11->wnd, x11->gc, x, y, w, h);

        XSetForeground(x11->disp, x11->gc, x11->cols.as.fg);
        XDrawLine(x11->disp, x11->wnd, x11->gc, x, y, x, y + h);
        XDrawLine(x11->disp, x11->wnd, x11->gc, x + w, y, x, y);

        XSetForeground(x11->disp, x11->gc, x11->cols.as.fg);
        XDrawLine(x11->disp, x11->wnd, x11->gc, x, y + h, x + w, y + h);
        XDrawLine(x11->disp, x11->wnd, x11->gc, x + w, y + h, x + w, y);
    }

    if(imactive) ui->kbdfocus = id;
    if(ui->kbdfocus == id)
    {

        XGCValues gcvals = {0};
        gcvals.foreground = x11->cols.as.fg;

        XChangeGC(x11->disp, x11->gc, GCForeground, &gcvals);
        XFillRectangle(x11->disp, x11->wnd, x11->gc, x + 6 + (6 * len), y + 6, 10, h - 12);
    }
    else
    {
        XGCValues gcvals = {0};
        gcvals.foreground = x11->cols.as.fg;
        gcvals.line_width = 1;

        XChangeGC(x11->disp, x11->gc, GCForeground | GCLineWidth, &gcvals);
        XDrawRectangle(x11->disp, x11->wnd, x11->gc, x + 6 + (6 * len), y + 6, 9, h - 13);
    }

    {
        int xx, yy;
        int di, fa, fd;
        int width, height;
        XCharStruct chs = {0};

        XTextExtents(x11->xfs, buf, buflen, &di, &fa, &fd, &chs);
        height = chs.ascent   + chs.descent;

        xx = x + 6;
        yy = y + h / 2 + height / 2;


        if(imactive) XSetForeground(x11->disp, x11->gc, x11->cols.as.bg);
        else XSetForeground(x11->disp, x11->gc, x11->cols.as.fg);
        XDrawString(x11->disp, x11->wnd, x11->gc, xx, yy, buf, len);
    }

    return imhot && imactive && !(ui->btns & bit(1));
}


int main(int argc, char** argv)
{
    xctx x11 = {0};
    iui   ui = {0};
    bool run = true;
    char txtbuf[256] = {0};

    x11_init(800, 600, "xip-8", argc, argv, &x11);

    while(run)
    {
        XEvent ev;

        while(XCheckTypedWindowEvent(x11.disp, x11.wnd, ClientMessage, &ev))
            if((Atom)ev.xclient.data.l[0] == x11.xa_delwnd) run = false;

        while(XCheckWindowEvent(x11.disp, x11.wnd, max_u32, &ev))
        {
            bool keyup = false;
            switch(ev.type)
            {
                case KeymapNotify:
                    XRefreshKeyboardMapping(&ev.xmapping);
                    break;

                case KeyRelease:
                    keyup = true;
                    /* fall through */
                case KeyPress:
                {
                    KeySym ks;
                    char name[32] = {0};
                    int len = 0;

                    len = XLookupString(&ev.xkey, name, sizeof(name) - 1, &ks, NULL);
                    if(keyup && ks == XK_Escape) run = false;
                    if(!keyup && len == 1)
                    {
                        if(ui.kbdfocus && (isgraph(name[0]) || name[0] == ' '))
                            strcat((char*)ui.kbdfocus, name);
                    }
                    if(!keyup && ks == XK_BackSpace)
                    {
                        if(ui.kbdfocus)
                        {
                            ssize i = strlen((char*)ui.kbdfocus) - 1;
                            if(i >= 0) ((char*)ui.kbdfocus)[i] = '\0';
                        }
                    }
                }
                break;

                case ButtonPress:
                    if(ev.xbutton.button == Button1) ui.btns |= bit(1);
                    if(ev.xbutton.button == Button2) ui.btns |= bit(2);
                    if(ev.xbutton.button == Button3) ui.btns |= bit(3);
                    break;

                case ButtonRelease:
                    if(ev.xbutton.button == Button1) ui.btns &= ~bit(1);
                    if(ev.xbutton.button == Button2) ui.btns &= ~bit(2);
                    if(ev.xbutton.button == Button3) ui.btns &= ~bit(3);
                    break;

                case MotionNotify:
                    ui.x = ev.xmotion.x;
                    ui.y = ev.xmotion.y;
                    break;

                case Expose:
                {
                    XWindowAttributes wa = {0};
                    XGCValues gcvals = {0};

                    gcvals.line_width = 1;
                    gcvals.foreground = x11.cols.as.bg;

                    XGetWindowAttributes(x11.disp, x11.wnd, &wa);

                    XChangeGC(x11.disp, x11.gc, GCForeground | GCLineWidth, &gcvals);
                    XFillRectangle(x11.disp, x11.wnd, x11.gc, 0, 0, wa.width, wa.height);

                    /* TODO: draw ui
                     * for ui draw cmds
                     *  draw cmd
                     */
                }
                break;

                default:
                    break;
            }
        }

        {
            int len = 0;
            char buf[512] = {0};
            XGCValues gcvals = {0};

            gcvals.foreground = x11.cols.as.bg;
            XChangeGC(x11.disp, x11.gc, GCForeground | GCLineWidth, &gcvals);
            XFillRectangle(x11.disp, x11.wnd, x11.gc, 0, 0, 800, 600);

            XSetForeground(x11.disp, x11.gc, x11.cols.as.fg);
            len = snprintf(buf, lengthof(buf), "hot: %p", (void*)ui.hot);
            XDrawString(x11.disp, x11.wnd, x11.gc, 650, 25, buf, len);

            len = snprintf(buf, lengthof(buf), "act: %p", (void*)ui.active);
            XDrawString(x11.disp, x11.wnd, x11.gc, 650, 45, buf, len);

            len = snprintf(buf, lengthof(buf), "cur: %dx%d", ui.x, ui.y);
            XDrawString(x11.disp, x11.wnd, x11.gc, 650, 65, buf, len);

            len = snprintf(buf, lengthof(buf), "btn: %d%d%d",
                    ui.btns & bit(1) ? 1 : 0,
                    ui.btns & bit(2) ? 2 : 0,
                    ui.btns & bit(3) ? 3 : 0);
            XDrawString(x11.disp, x11.wnd, x11.gc, 650, 85, buf, len);

            len = snprintf(buf, lengthof(buf), "old: %d%d%d",
                    ui.pbtns & bit(1) ? 1 : 0,
                    ui.pbtns & bit(2) ? 2 : 0,
                    ui.pbtns & bit(3) ? 3 : 0);
            XDrawString(x11.disp, x11.wnd, x11.gc, 650, 105, buf, len);

            len = snprintf(buf, lengthof(buf), "kbd: %p", (void*)ui.kbdfocus);
            XDrawString(x11.disp, x11.wnd, x11.gc, 650, 125, buf, len);
        }

        iui_start(&ui, &x11);
            if(iui_button(&ui, 25, 25, 100, 35, "Click ME!"))  report(DBG, "CLICK!\n");
            if(iui_button(&ui, 150, 25, 100, 35, "NOT ME!!!")) report(DBG, "WHYYYYYY!\n");

            iui_textbox(&ui, 25, 75, 225, 35, txtbuf, lengthof(txtbuf));
            if(iui_button(&ui, 275, 75, 100, 35, "OK")) report(DBG, "textbox: '%s'!\n", txtbuf);
        iui_end(&ui);

        usleep(10000);
    }

    x11_cleanup(&x11);
    return 0;
}

int main2(int argc, char** argv)
{
    u64   sz = 0;
    FILE*  f = NULL;
    chip8 c8 = {0};

    srand(time(NULL));

    c8_reset(&c8);

    if(argc > 1)
    {
        u64 got = 0;

        f = fopen(argv[1], "r");
        if(!f) return 1;

        fseek(f, 0, SEEK_END);
        sz = (u64)ftell(f);
        rewind(f);

        if(sz >= (sizeof(c8.RAM) - 512)) return 2;

        got = fread(c8.RAM + C8_RESET_VECTOR, 1, sz, f);
        if(got != sz) return 3;

        fclose(f);
    }
    else
    {
        c8.RAM[C8_RESET_VECTOR + iota] = 0x60;
        c8.RAM[C8_RESET_VECTOR + iota] = 0x04;

        c8.RAM[C8_RESET_VECTOR + iota] = 0x61;
        c8.RAM[C8_RESET_VECTOR + iota] = 0x03;

        c8.RAM[C8_RESET_VECTOR + iota] = 0x72;
        c8.RAM[C8_RESET_VECTOR + iota] = 0x01;

        c8.RAM[C8_RESET_VECTOR + iota] = 0x80;
        c8.RAM[C8_RESET_VECTOR + iota] = 0x14;

        c8.RAM[C8_RESET_VECTOR + iota] = 0x30;
        c8.RAM[C8_RESET_VECTOR + iota] = 0x10;

        c8.RAM[C8_RESET_VECTOR + iota] = 0x12;
        c8.RAM[C8_RESET_VECTOR + iota] = 0x04;

        sz = iota;
    }

    printf("Disasm:\n");
    {
        u64 i;
        char buf[512] = {0};

        for(i = 0; i < sz; i += 2)
        {
            u16 pc = C8_RESET_VECTOR + i;
            c8_disasm(c8.RAM, pc, buf);
            printf("%04X:   %s\n", pc, buf);
        }
    }

    printf("\nExec:\n");
    while(c8.running)
    {
        char buf[512] = {0};


        c8_disasm(c8.RAM, c8.pc, buf);
        printf("%04X:   %s\n", c8.pc, buf);

        c8_exec(c8.RAM, c8.pc, &c8);
        c8_dump_state(&c8, false);
    }

    return 0;
}