#include "lua.h"
#include "lua/lua.hpp"
#include "mini.h"
#include "jfile.h"

#include <filesystem>
namespace fs = std::filesystem;

extern "C" {

    // surface
    // ===============================================

    static int cpp_surf_new(lua_State *L) {
        int w = luaL_checknumber(L, 1);
        int h = luaL_checknumber(L, 2);
        lua_pushinteger(L, newsurf(w, h));
        return 1;
    }

    static int cpp_surf_load(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        lua_pushinteger(L, loadsurf(str));
        return 1;
    }

    static int cpp_surf_save(lua_State *L) {
        uint8_t surface = luaL_checkinteger(L, 1);
        const char* str = luaL_checkstring(L, 2);

        if (lua_istable(L, -1)) {
            const int len = SDL_min(256, lua_rawlen(L, -1));
            uint8_t *pal = (uint8_t*)malloc(len*3);
            uint8_t *p=pal;
            for (int i=1;i<=len;++i) {
                lua_rawgeti(L, -1, i);
                lua_getfield(L, -1, "r");
                *(p++) = luaL_checknumber(L, -1);
                lua_pop(L, 1);
                lua_getfield(L, -1, "g");
                *(p++) = luaL_checknumber(L, -1);
                lua_pop(L, 1);
                lua_getfield(L, -1, "b");
                *(p++) = luaL_checknumber(L, -1);
                lua_pop(L, 1);
                lua_pop(L, 1);
                //pal[i-1] = (r<<16)+(g<<8)+b;
            }
            savesurf(surface, str, pal, len-1);
        } else {
            savesurf(surface, str, nullptr);
        }

        return 0;
    }

    static int cpp_surf_free(lua_State *L) {
        uint8_t surface = luaL_checkinteger(L, 1);
        freesurf(surface);
        return 0;
    }

    static int cpp_surf_size(lua_State *L) {
        uint8_t surface = luaL_checkinteger(L, 1);
        lua_pushinteger(L, surfw(surface));
        lua_pushinteger(L, surfh(surface));
        return 2;
    }

    static int cpp_surf_target(lua_State *L) {
        const int numargs = lua_gettop(L);
        switch (numargs) {
            case 0: {
                setdest(0);
                return 0;
            }
            case 1: {
                uint8_t surface = luaL_checkinteger(L, 1);
                setdest(surface);
                return 0;
            }
            default:
                return luaL_error(L, "Function 'surface.target' Unexpected number of parameters.");
        };
    }

    static int cpp_surf_source(lua_State *L) {
        const int numargs = lua_gettop(L);
        switch (numargs) {
            case 0: {
                setsource(0);
                return 0;
            }
            case 1: {
                uint8_t surface = luaL_checkinteger(L, 1);
                setsource(surface);
                return 0;
            }
            default:
                return luaL_error(L, "Function 'surface.source' Unexpected number of parameters.");
        };
    }

    static int cpp_surf_cls(lua_State *L) {
        uint8_t color = luaL_optinteger(L, 1, 0);
        cls(color);
        return 0;
    }

    static int cpp_surf_pixel(lua_State *L) {
        if (lua_gettop(L)==2) {
            int x = luaL_checknumber(L, 1);
            int y = luaL_checknumber(L, 2);
            lua_pushinteger(L, sget(x, y));
            return 1;
        } else {
            int x = luaL_checknumber(L, 1);
            int y = luaL_checknumber(L, 2);
            uint8_t color = luaL_checkinteger(L, 3);
            pset(x, y, color);
            return 0;
        }
    }

    // map
    // ===============================================

    /*
    static int cpp_map_new(lua_State *L) {
        int w = luaL_checknumber(L, 1);
        int h = luaL_checknumber(L, 2);
        uint8_t s = newsurf(w, h);
        uint8_t old = getmap(); if (old) freesurf(old);
        setmap(s);
        return 0;
    }

    static int cpp_map_load(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        uint8_t s = loadsurf(str);
        uint8_t old = getmap(); if (old) freesurf(old);
        setmap(s);
        return 0;
    }

    static int cpp_map_save(lua_State *L) {
        uint8_t surface = getmap();
        const char* str = luaL_checkstring(L, 1);
        savesurf(surface, str, nullptr);
        return 0;
    }
    */

    static int cpp_map_surf(lua_State *L) {
        if (lua_gettop(L)==1) {
            uint8_t surface = luaL_checkinteger(L, 1);
            setmap(surface);
        } else {
            lua_pushinteger(L, getmap());
            return 1;
        }

        return 0;
    }

    static int cpp_map_draw(lua_State *L) {
        /*uint8_t celx = luaL_checknumber(L, 1);
        uint8_t cely = luaL_checknumber(L, 2);
        int sx = luaL_checknumber(L, 3);
        int sy = luaL_checknumber(L, 4);
        uint8_t celw = luaL_checknumber(L, 5);
        uint8_t celh = luaL_checknumber(L, 6);
        uint8_t layer = luaL_optinteger(L, 7, 0);*/
        //uint8_t surface = luaL_checkinteger(L, 1);
        //setsource(surface);
        map(); //celx, cely, sx, sy, celw, celh, layer);
        return 0;
    }

    static int cpp_map_tile(lua_State *L) {
        if (lua_gettop(L)==2) {
            int celx = luaL_checknumber(L, 1);
            int cely = luaL_checknumber(L, 2);
            lua_pushinteger(L, mget(celx, cely));
            return 1;
        } else {
            int celx = luaL_checknumber(L, 1);
            int cely = luaL_checknumber(L, 2);
            uint8_t snum = luaL_checkinteger(L, 3);
            mset(celx, cely, snum);
            return 0;
        }
    }
 

    // palette
    // ===============================================

    static int cpp_pal_load(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        uint16_t size;
        uint32_t *pal = loadpal(str, &size);
        lua_createtable(L, 2, 0);
        for (int i=0;i<size;++i) {
            uint32_t color = pal[i];
            lua_createtable(L, 0, 3);

            lua_pushinteger(L, (color>>16)&0xff);
            lua_setfield(L, -2, "r");

            lua_pushinteger(L, (color>>8)&0xff);
            lua_setfield(L, -2, "g");

            lua_pushinteger(L, color&0xff);
            lua_setfield(L, -2, "b");

            lua_rawseti(L, -2, i+1);
        }
        free(pal);
        return 1;
    }

    static int cpp_pal_set(lua_State *L) {
        int r,g,b;
        if (lua_istable(L, -1)) {
            uint32_t pal[256];
            const int len = SDL_min(256, lua_rawlen(L, -1));
            for (int i=0;i<len;++i) {
                lua_rawgeti(L, -1, i+1);
                lua_getfield(L, -1, "r");
                r = luaL_checknumber(L, -1);
                lua_pop(L, 1);
                lua_getfield(L, -1, "g");
                g = luaL_checknumber(L, -1);
                lua_pop(L, 1);
                lua_getfield(L, -1, "b");
                b = luaL_checknumber(L, -1);
                lua_pop(L, 1);
                lua_pop(L, 1);
                pal[i] = (r<<16)+(g<<8)+b;
            }
            setpal(pal);
        }
        return 0;
    }

    static int cpp_pal_color(lua_State *L) {
        //if (lua_gettop(L) != 1) return luaL_error(L, "Function 'mini.palette.getColor' Unexpected number of parameters.");
        if (lua_gettop(L) == 1) {
            uint8_t index = luaL_checkinteger(L, 1);
            uint32_t color = getcolor(index);
            lua_pushinteger(L, (color>>16)&0xff);
            lua_pushinteger(L, (color>>8)&0xff);
            lua_pushinteger(L, color&0xff);
            return 3;
        } else {
            uint8_t index = luaL_checkinteger(L, 1);
            uint8_t r = luaL_checkinteger(L, 2);
            uint8_t g = luaL_optinteger(L, 3, 0);
            uint8_t b = luaL_optinteger(L, 4, 0);
            uint32_t color = (r<<16) + (g<<8) + b;
            setcolor(index, color);
            return 0;
        }
    }

    static int cpp_pal_trans(lua_State *L) {
        if (lua_gettop(L) == 0) {
            lua_pushinteger(L, gettrans());
            return 1;
        } else {
            uint8_t index = luaL_checkinteger(L, 1);
            settrans(index);
            return 0;
        }
    }

    static int cpp_pal_subpal(lua_State *L) {
        const int num_params = lua_gettop(L);
        uint8_t index, index2, color;
        switch (num_params) {
            case 0:
                reset_subpal();
                break;
            case 1:
                index = luaL_checkinteger(L, 1);
                subpal(index,index);
                break;
            case 2:
                index = luaL_checkinteger(L, 1);
                color = luaL_checkinteger(L, 2);
                subpal(index, color);
                break;
            case 3:
                index = luaL_checkinteger(L, 1);
                index2 = luaL_checkinteger(L, 2);
                color = luaL_checkinteger(L, 3);
                for (int i=index;i<=index2;++i) subpal(i, color);
                break;
        }
        return 0;
    }

    // viewport
    // ===============================================

    static int cpp_viewport_clip(lua_State *L) {
        if (lua_gettop(L)==0) {
            clip();
            return 0;
        } else {
            int x = luaL_checknumber(L, 1);
            int y = luaL_checknumber(L, 2);
            int w = luaL_checknumber(L, 3);
            int h = luaL_checknumber(L, 4);
            clip(x, y, w, h);
            return 0;
        }
    }

    static int cpp_viewport_origin(lua_State *L) {
        if (lua_gettop(L) == 0) {
            lua_pushinteger(L, camx());
            lua_pushinteger(L, camy());
            return 2;
        } else {
            int x = luaL_checknumber(L, 1);
            int y = luaL_checknumber(L, 2);
            origin(x, y);
            return 0;
        }
    }

    static int cpp_viewport_tolocal(lua_State *L) {
        int x = luaL_checknumber(L, 1);
        int y = luaL_checknumber(L, 2);
        lua_pushinteger(L, x+camx());
        lua_pushinteger(L, y+camy());
        return 2;
    }


    // draw
    // ===============================================

    /*static int cpp_draw_pen(lua_State *L) {
        uint8_t col = luaL_optinteger(L, 1, 6);
        color(col);
        return 0;
    }

    static int cpp_draw_paper(lua_State *L) {
        uint8_t col = luaL_optinteger(L, 1, 6);
        bcolor(col);
        return 0;
    }*/

    static int cpp_draw_line(lua_State *L) {
        int x0 = luaL_checknumber(L, 1);
        int y0 = luaL_checknumber(L, 2);
        int x1 = luaL_checknumber(L, 3);
        int y1 = luaL_checknumber(L, 4);
        uint8_t color = luaL_checkinteger(L, 5);
        line(x0, y0, x1, y1, color);
        return 0;
    }

    static int cpp_draw_hline(lua_State *L) {
        int x0 = luaL_checknumber(L, 1);
        int y = luaL_checknumber(L, 2);
        int x1 = luaL_checknumber(L, 3);
        uint8_t color = luaL_checkinteger(L, 4);
        hline(x0, y, x1, color);
        return 0;
    }

    static int cpp_draw_vline(lua_State *L) {
        int x = luaL_checknumber(L, 1);
        int y0 = luaL_checknumber(L, 2);
        int y1 = luaL_checknumber(L, 3);
        uint8_t color = luaL_checkinteger(L, 4);
        vline(x, y0, y1, color);
        return 0;
    }

    static int cpp_draw_rect(lua_State *L) {
        int x = luaL_checknumber(L, 1);
        int y = luaL_checknumber(L, 2);
        int w = luaL_checknumber(L, 3);
        int h = luaL_checknumber(L, 4);
        uint8_t color = luaL_checkinteger(L, 5);
        rect(x, y, w, h, color);
        return 0;
    }

    static int cpp_draw_rectfill(lua_State *L) {
        int x = luaL_checknumber(L, 1);
        int y = luaL_checknumber(L, 2);
        int w = luaL_checknumber(L, 3);
        int h = luaL_checknumber(L, 4);
        uint8_t color = luaL_checkinteger(L, 5);
        rectfill(x, y, w, h, color);
        return 0;
    }

    static int cpp_draw_circ(lua_State *L) {
        int x = luaL_checknumber(L, 1);
        int y = luaL_checknumber(L, 2);
        int r = luaL_optnumber(L, 3, 4);
        uint8_t color = luaL_checkinteger(L, 4);
        circ(x, y, r, color);
        return 0;
    }

    static int cpp_draw_circfill(lua_State *L) {
        int x = luaL_checknumber(L, 1);
        int y = luaL_checknumber(L, 2);
        int r = luaL_optnumber(L, 3, 4);
        uint8_t color = luaL_checkinteger(L, 4);
        circfill(x, y, r, color);
        return 0;
    }

    static int cpp_draw_oval(lua_State *L) {
        int x0 = luaL_checknumber(L, 1);
        int y0 = luaL_checknumber(L, 2);
        int x1 = luaL_checknumber(L, 3);
        int y1 = luaL_checknumber(L, 4);
        uint8_t color = luaL_checkinteger(L, 5);
        oval(x0, y0, x1, y1, color);
        return 0;
    }

    static int cpp_draw_ovalfill(lua_State *L) {
        int x0 = luaL_checknumber(L, 1);
        int y0 = luaL_checknumber(L, 2);
        int x1 = luaL_checknumber(L, 3);
        int y1 = luaL_checknumber(L, 4);
        uint8_t color = luaL_checkinteger(L, 5);
        ovalfill(x0, y0, x1, y1, color);
        return 0;
    }

    static int cpp_draw_pattern(lua_State *L) {
        uint16_t pat = luaL_checkinteger(L, 1);
        bool transparent = lua_toboolean(L, 2);
        fillp(pat, transparent);
        return 0;
    }

    /*static int cpp_draw_tline(lua_State *L) {
        int x0 = luaL_checknumber(L, 1);
        int y0 = luaL_checknumber(L, 2);
        int x1 = luaL_checknumber(L, 3);
        int y1 = luaL_checknumber(L, 4);
        float mx = luaL_checknumber(L, 5);
        float my = luaL_checknumber(L, 6);
        float mdx = luaL_optnumber(L, 7, 0.125f);
        float mdy = luaL_optnumber(L, 8, 0.0f);
        tline(x0, y0, x1, y1, mx, my, mdx, mdy);
        return 0;
    }

    static int cpp_draw_thline(lua_State *L) {
        int x0 = luaL_checknumber(L, 1);
        int y = luaL_checknumber(L, 2);
        int x1 = luaL_checknumber(L, 3);
        float mx = luaL_checknumber(L, 4);
        float my = luaL_checknumber(L, 5);
        float mdx = luaL_optnumber(L, 6, 0.125f);
        float mdy = luaL_optnumber(L, 7, 0.0f);
        thline(x0, y, x1, mx, my, mdx, mdy);
        return 0;
    }

    static int cpp_draw_tvline(lua_State *L) {
        int x = luaL_checknumber(L, 1);
        int y0 = luaL_checknumber(L, 2);
        int y1 = luaL_checknumber(L, 3);
        float mx = luaL_checknumber(L, 4);
        float my = luaL_checknumber(L, 5);
        float mdx = luaL_optnumber(L, 6, 0.0f);
        float mdy = luaL_optnumber(L, 7, 0.125f);
        tvline(x, y0, y1, mx, my, mdx, mdy);
        return 0;
    }*/

    static int cpp_draw_surface(lua_State *L) {
        int sx = luaL_checknumber(L, 1);
        int sy = luaL_checknumber(L, 2);
        int sw = luaL_checknumber(L, 3);
        int sh = luaL_checknumber(L, 4);
        int dx = luaL_checknumber(L, 5);
        int dy = luaL_checknumber(L, 6);
        int dw = luaL_optnumber(L, 7, 0);
        int dh = luaL_optnumber(L, 8, 0);
        bool flip_x = lua_toboolean(L, 9);
        bool flip_y = lua_toboolean(L, 10);
        bool invert = lua_toboolean(L, 11);
        blit(sx, sy, sw, sh, dx, dy, dw, dh, flip_x, flip_y, invert);
        return 0;
    }

    static int cpp_draw_surfaceRotated(lua_State *L) {
        int sx = luaL_checknumber(L, 1);
        int sy = luaL_checknumber(L, 2);
        int sw = luaL_checknumber(L, 3);
        int sh = luaL_checknumber(L, 4);
        int dx = luaL_checknumber(L, 5);
        int dy = luaL_checknumber(L, 6);
        float a = luaL_checknumber(L, 7);
        blit_r(sx, sy, sw, sh, dx, dy, a);
        return 0;
    }

    static int cpp_draw_text(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        int x = luaL_checknumber(L, 2);
        int y = luaL_checknumber(L, 3);
        if (lua_gettop(L) > 3) {
            uint8_t color = luaL_checkinteger(L, 4);
            print(str, x, y, color);
        } else {
            print(str, x, y);
        }
        return 0;
    }


    // shaders
    // ===============================================

    static int cpp_shader_init(lua_State *L) {
        const char* vstr = luaL_optstring(L, 1, NULL);
        const char* fstr = luaL_optstring(L, 2, NULL);
        shader_init(vstr, fstr);
        return 0;
    }

    static int cpp_shader_enable(lua_State *L) {
        shader_enable();
        return 0;
    }

    static int cpp_shader_disable(lua_State *L) {
        shader_disable();
        return 0;
    }


    // music
    // ===============================================

    static int cpp_music_play(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        const int loop = luaL_optinteger(L, 2, -1);
        playmusic(str, loop);
        return 0;
    }

    static int cpp_music_pause(lua_State *L) {
        pausemusic();
        return 0;
    }

    static int cpp_music_resume(lua_State *L) {
        resumemusic();
        return 0;
    }

    static int cpp_music_stop(lua_State *L) {
        const int time = luaL_optinteger(L, 1, 1000);
        stopmusic(time);
        return 0;
    }

    static int cpp_music_pos(lua_State *L) {
        if (lua_gettop(L) == 0) {
            lua_pushnumber(L, musicpos());
            return 1;
        } else {
            musicpos(luaL_checknumber(L, 1));
            return 0;
        }
    }

    static int cpp_music_enable(lua_State *L) {
        if (lua_gettop(L) == 0) {
            lua_pushboolean(L, ismusicenabled());
            return 1;
        } else {
            enablemusic(lua_toboolean(L, 1));
            return 0;
        }
    }


    // sound
    // ===============================================

    static int cpp_sound_load(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        lua_pushinteger(L,loadsound(str));
        return 1;
    }

    static int cpp_sound_free(lua_State *L) {
        const int sound = luaL_checknumber(L, 1);
        freesound(sound);
        return 0;
    }

    static int cpp_sound_play(lua_State *L) {
        const int sound = luaL_checknumber(L, 1);
        const int volume = luaL_optinteger(L, 2, -1);
        lua_pushinteger(L,playsound(sound, volume));
        return 1;
    }

    static int cpp_sound_stop(lua_State *L) {
        const int sound = luaL_checknumber(L, 1);
        stopsound(sound);
        return 0;
    }

    static int cpp_sound_enable(lua_State *L) {
        if (lua_gettop(L) == 0) {
            lua_pushboolean(L, issoundenabled());
            return 1;
        } else {
            enablesound(lua_toboolean(L, 1));
            return 0;
        }
    }


    // sys
    // ===============================================

    static int cpp_sys_time(lua_State *L) {
        lua_pushnumber(L, time());
        return 1;
    }

    static int cpp_sys_beat(lua_State *L) {
        if (lua_gettop(L) == 0) {
            lua_pushboolean(L, beat(-1));
            return 1;
        } else {
            int16_t beats = luaL_optnumber(L, 1, -1);
            beat(beats);
            return 0;
        }
    }

    static int cpp_sys_update(lua_State *L) {
        if (lua_gettop(L) == 0) {
            lua_pushinteger(L, getupdatemode());
            return 1;
        } else {
            int mode = luaL_checknumber(L, 1);
            int interval = luaL_optinteger(L, 2, 0);
            setupdatemode(mode, interval);
            return 0;
        }
    }

    static int cpp_sys_dir(lua_State *L) {
        lua_newtable(L);
        int i=1;
        for (const auto& entry : fs::directory_iterator("./data")) {
            lua_pushstring(L, entry.path().u8string().c_str());
            lua_rawseti(L, -2, i++);
        }

        return 1;
    }

    static int cpp_sys_exit(lua_State *L) {
        exit();
        return 0;
    }

    static int cpp_sys_fps(lua_State *L) {
        lua_pushnumber(L, getfps());
        return 1;
    }

    static int cpp_sys_clipboard(lua_State *L) {
        if (lua_gettop(L) == 0) {
            lua_pushstring(L, SDL_GetClipboardText());
            return 1;
        } else {
            const char* value = luaL_checkstring(L, 1);
            SDL_SetClipboardText(value);
            return 0;
        }
    }


    // win
    // ===============================================

    static int cpp_win_zoom(lua_State *L) {
        if (lua_gettop(L) == 0) {
            lua_pushinteger(L, getzoom());
            return 1;
        } else {
            const int value = luaL_optinteger(L, 1, 0);
            setzoom(value);
            return 0;
        }
    }

    static int cpp_win_fullscreen(lua_State *L) {
        if (lua_gettop(L) == 0) {
            lua_pushboolean(L, getfullscreen());
            return 1;
        } else {
            setfullscreen(lua_toboolean(L, 1));
            return 0;
        }
    }

    static int cpp_win_cursor(lua_State *L) {
        if (lua_gettop(L) == 0) {
            lua_pushboolean(L, getcursor());
            return 1;
        } else {
            setcursor(lua_toboolean(L, 1));
            return 0;
        }
    }

    static int cpp_win_res(lua_State *L) {
        if (lua_gettop(L) == 0) {
            lua_pushinteger(L, scrw());
            lua_pushinteger(L, scrh());
            return 2;
        } else {
            const int w = luaL_optinteger(L, 1, 160);
            const int h = luaL_optinteger(L, 2, 120);
            setres(w, h);
            return 0;
        }
    }

    // conf
    // ===============================================

    static int cpp_conf_key(lua_State *L) {
        const char* key = luaL_checkstring(L, 1);
        if (lua_gettop(L) > 1) {
            const char* value = luaL_checkstring(L, 2);
            setconfig(key, value);
            return 0;
        } else {
            const char* value = getconfig(key);
            if (value==NULL) {
                lua_pushnil(L);
            } else {
                lua_pushstring(L, value);
            }
            return 1;
        }
    }

    static int cpp_conf_folder(lua_State *L) {
        lua_pushstring(L, configfolder());
        return 1;
    }


    // mouse
    // ===============================================

    static int cpp_mouse_pos(lua_State *L) {
        lua_pushinteger(L, mousex());
        lua_pushinteger(L, mousey());
        return 2;
    }

    static int cpp_mouse_wheel(lua_State *L) {
        lua_pushinteger(L, mwheel());
        return 1;
    }

    static int cpp_mouse_down(lua_State *L) {
        uint8_t i = luaL_checkinteger(L, 1);
        lua_pushboolean(L, mbtn(i));
        return 1;
    }

    static int cpp_mouse_press(lua_State *L) {
        uint8_t i = luaL_checkinteger(L, 1);
        lua_pushboolean(L, mbtnp(i));
        return 1;
    }

    static int cpp_mouse_discard(lua_State *L) {
        mdiscard();
        return 0;
    }

    
    // key
    // ===============================================

    static int cpp_key_down(lua_State *L) {
        uint8_t i = luaL_checkinteger(L, 1);
        lua_pushboolean(L, btn(i));
        return 1;
    }

    static int cpp_key_press(lua_State *L) {
        if (lua_gettop(L) >=1 ) {
            uint8_t i = luaL_checkinteger(L, 1);
            lua_pushboolean(L, btnp(i));
        } else {
            lua_pushinteger(L, wbtnp());
        }
        return 1;
    }

    static int cpp_key_any(lua_State *L) {
        lua_pushboolean(L, anykey());
        return 1;
    }

    
    // pad
    // ===============================================

    static int cpp_pad_down(lua_State *L) {
        int8_t i = luaL_checkinteger(L, 1);
        lua_pushboolean(L, pad(i));
        return 1;
    }

    static int cpp_pad_press(lua_State *L) {
        if (lua_gettop(L) >=1 ) {
            int8_t i = luaL_checkinteger(L, 1);
            lua_pushboolean(L, padp(i));
        } else {
            lua_pushinteger(L, wpad());
        }
        return 1;
    }

    static int cpp_pad_any(lua_State *L) {
        lua_pushinteger(L, wpad());
        return 1;
    }

}

lua_State *L;
bool is_playing = false;
bool init_exists = false;
bool update_exists = false;

bool lua_is_playing() {
    return is_playing;
}

void push_lua_funcs() {
    lua_newtable(L);
    lua_setglobal(L, "mini");

    lua_newtable(L);
    lua_pushcfunction(L,cpp_surf_new);              lua_setfield(L, -2, "new");
    lua_pushcfunction(L,cpp_surf_load);             lua_setfield(L, -2, "load");
    lua_pushcfunction(L,cpp_surf_save);             lua_setfield(L, -2, "save");
    lua_pushcfunction(L,cpp_surf_free);             lua_setfield(L, -2, "free");
    lua_pushcfunction(L,cpp_surf_size);             lua_setfield(L, -2, "size");
    lua_pushcfunction(L,cpp_surf_target);           lua_setfield(L, -2, "target");
    lua_pushcfunction(L,cpp_surf_source);           lua_setfield(L, -2, "source");
    lua_pushcfunction(L,cpp_surf_cls);              lua_setfield(L, -2, "cls");
    lua_pushcfunction(L,cpp_surf_pixel);            lua_setfield(L, -2, "pixel");
    lua_setglobal(L, "surf");

    lua_newtable(L);
    //lua_pushcfunction(L,cpp_map_new);               lua_setfield(L, -2, "new");
    //lua_pushcfunction(L,cpp_map_load);              lua_setfield(L, -2, "load");
    //lua_pushcfunction(L,cpp_map_save);              lua_setfield(L, -2, "save");
    lua_pushcfunction(L,cpp_map_surf);              lua_setfield(L, -2, "surf");
    lua_pushcfunction(L,cpp_map_draw);              lua_setfield(L, -2, "draw");
    lua_pushcfunction(L,cpp_map_tile);              lua_setfield(L, -2, "tile");
    lua_setglobal(L, "map");
    
    lua_newtable(L);
    lua_pushcfunction(L,cpp_pal_load);              lua_setfield(L, -2, "load");
    lua_pushcfunction(L,cpp_pal_set);               lua_setfield(L, -2, "set");
    lua_pushcfunction(L,cpp_pal_color);             lua_setfield(L, -2, "color");
    lua_pushcfunction(L,cpp_pal_trans);             lua_setfield(L, -2, "trans");
    lua_pushcfunction(L,cpp_pal_subpal);            lua_setfield(L, -2, "subpal");
    lua_setglobal(L, "pal");

    lua_newtable(L);
    lua_pushcfunction(L,cpp_viewport_clip);         lua_setfield(L, -2, "clip");
    lua_pushcfunction(L,cpp_viewport_origin);       lua_setfield(L, -2, "origin");
    lua_pushcfunction(L,cpp_viewport_tolocal);        lua_setfield(L, -2, "tolocal");
    lua_setglobal(L, "view");

    lua_newtable(L);
    lua_pushcfunction(L,cpp_draw_line);             lua_setfield(L, -2, "line");
    lua_pushcfunction(L,cpp_draw_hline);            lua_setfield(L, -2, "hline");
    lua_pushcfunction(L,cpp_draw_vline);            lua_setfield(L, -2, "vline");
    lua_pushcfunction(L,cpp_draw_rect);             lua_setfield(L, -2, "rect");
    lua_pushcfunction(L,cpp_draw_rectfill);         lua_setfield(L, -2, "rectf");
    lua_pushcfunction(L,cpp_draw_circ);             lua_setfield(L, -2, "circ");
    lua_pushcfunction(L,cpp_draw_circfill);         lua_setfield(L, -2, "circf");
    lua_pushcfunction(L,cpp_draw_oval);             lua_setfield(L, -2, "oval");
    lua_pushcfunction(L,cpp_draw_ovalfill);         lua_setfield(L, -2, "ovalf");
    lua_pushcfunction(L,cpp_draw_pattern);          lua_setfield(L, -2, "pattern");
    //lua_pushcfunction(L,cpp_draw_tline);          lua_setfield(L, -2, "tline");
    //lua_pushcfunction(L,cpp_draw_thline);         lua_setfield(L, -2, "thline");
    //lua_pushcfunction(L,cpp_draw_tvline);         lua_setfield(L, -2, "tvline");
    lua_pushcfunction(L,cpp_draw_surface);          lua_setfield(L, -2, "surf");
    lua_pushcfunction(L,cpp_draw_surfaceRotated);   lua_setfield(L, -2, "surfrot");
    lua_pushcfunction(L,cpp_draw_text);             lua_setfield(L, -2, "text");
    lua_setglobal(L, "draw");

    lua_newtable(L);
    lua_pushcfunction(L,cpp_shader_init);           lua_setfield(L, -2, "init");
    lua_pushcfunction(L,cpp_shader_enable);         lua_setfield(L, -2, "enable");
    lua_pushcfunction(L,cpp_shader_disable);        lua_setfield(L, -2, "disable");
    lua_setglobal(L, "shader");

    lua_newtable(L);
    lua_pushcfunction(L,cpp_music_play);            lua_setfield(L, -2, "play");
    lua_pushcfunction(L,cpp_music_pause);           lua_setfield(L, -2, "pause");
    lua_pushcfunction(L,cpp_music_resume);          lua_setfield(L, -2, "resume");
    lua_pushcfunction(L,cpp_music_stop);            lua_setfield(L, -2, "stop");
    lua_pushcfunction(L,cpp_music_pos);             lua_setfield(L, -2, "pos");
    lua_pushcfunction(L,cpp_music_enable);          lua_setfield(L, -2, "enabled");
    lua_setglobal(L, "music");

    lua_newtable(L);
    lua_pushcfunction(L,cpp_sound_load);            lua_setfield(L, -2, "load");
    lua_pushcfunction(L,cpp_sound_free);            lua_setfield(L, -2, "free");
    lua_pushcfunction(L,cpp_sound_play);            lua_setfield(L, -2, "play");
    lua_pushcfunction(L,cpp_sound_stop);            lua_setfield(L, -2, "stop");
    lua_pushcfunction(L,cpp_sound_enable);          lua_setfield(L, -2, "enabled");
    lua_setglobal(L, "sound");

    lua_newtable(L);
    lua_pushcfunction(L,cpp_sys_time);              lua_setfield(L, -2, "time");
    lua_pushcfunction(L,cpp_sys_beat);              lua_setfield(L, -2, "beat");
    lua_pushcfunction(L,cpp_sys_update);            lua_setfield(L, -2, "update");
    lua_pushcfunction(L,cpp_sys_dir);               lua_setfield(L, -2, "dir");
    lua_pushcfunction(L,cpp_sys_exit);              lua_setfield(L, -2, "quit");
    lua_pushcfunction(L,cpp_sys_fps);               lua_setfield(L, -2, "fps");
    lua_pushcfunction(L,cpp_sys_clipboard);         lua_setfield(L, -2, "clipboard");

    lua_pushinteger(L, 0);                          lua_setfield(L, -2, "UPDATE_ALWAYS");
    lua_pushinteger(L, 1);                          lua_setfield(L, -2, "UPDATE_WAIT");
    lua_pushinteger(L, 2);                          lua_setfield(L, -2, "UPDATE_TIMEOUT");

    lua_setglobal(L, "sys");

    lua_newtable(L);
    lua_pushcfunction(L,cpp_win_zoom);              lua_setfield(L, -2, "zoom");
    lua_pushcfunction(L,cpp_win_fullscreen);        lua_setfield(L, -2, "fullscreen");
    lua_pushcfunction(L,cpp_win_cursor);            lua_setfield(L, -2, "cursor");
    lua_pushcfunction(L,cpp_win_res);               lua_setfield(L, -2, "res");
    lua_setglobal(L, "win");

    lua_newtable(L);
    lua_pushcfunction(L,cpp_conf_key);              lua_setfield(L, -2, "key");
    lua_pushcfunction(L,cpp_conf_folder);           lua_setfield(L, -2, "folder");
    lua_setglobal(L, "config");

    lua_newtable(L);
    lua_pushcfunction(L,cpp_mouse_pos);             lua_setfield(L, -2, "pos");
    lua_pushcfunction(L,cpp_mouse_wheel);           lua_setfield(L, -2, "wheel");
    lua_pushcfunction(L,cpp_mouse_down);            lua_setfield(L, -2, "down");
    lua_pushcfunction(L,cpp_mouse_press);           lua_setfield(L, -2, "press");
    lua_pushcfunction(L,cpp_mouse_discard);         lua_setfield(L, -2, "discard");

    lua_pushinteger(L, 1);                          lua_setfield(L, -2, "LEFT");
    lua_pushinteger(L, 2);                          lua_setfield(L, -2, "MIDDLE");
    lua_pushinteger(L, 3);                          lua_setfield(L, -2, "RIGHT");
    lua_setglobal(L, "mouse");

    lua_newtable(L);
    lua_pushcfunction(L,cpp_key_down);              lua_setfield(L, -2, "down");
    lua_pushcfunction(L,cpp_key_press);             lua_setfield(L, -2, "press");
    lua_pushcfunction(L,cpp_key_any);               lua_setfield(L, -2, "any");
    //lua_setglobal(L, "key");

    //lua_newtable(L);
    lua_pushinteger(L, 0);                          lua_setfield(L, -2, "UNKNOWN");
    lua_pushinteger(L, 4);                          lua_setfield(L, -2, "A");
    lua_pushinteger(L, 5);                          lua_setfield(L, -2, "B");
    lua_pushinteger(L, 6);                          lua_setfield(L, -2, "C");
    lua_pushinteger(L, 7);                          lua_setfield(L, -2, "D");
    lua_pushinteger(L, 8);                          lua_setfield(L, -2, "E");
    lua_pushinteger(L, 9);                          lua_setfield(L, -2, "F");
    lua_pushinteger(L, 10);                         lua_setfield(L, -2, "G");
    lua_pushinteger(L, 11);                         lua_setfield(L, -2, "H");
    lua_pushinteger(L, 12);                         lua_setfield(L, -2, "I");
    lua_pushinteger(L, 13);                         lua_setfield(L, -2, "J");
    lua_pushinteger(L, 14);                         lua_setfield(L, -2, "K");
    lua_pushinteger(L, 15);                         lua_setfield(L, -2, "L");
    lua_pushinteger(L, 16);                         lua_setfield(L, -2, "M");
    lua_pushinteger(L, 17);                         lua_setfield(L, -2, "N");
    lua_pushinteger(L, 18);                         lua_setfield(L, -2, "O");
    lua_pushinteger(L, 19);                         lua_setfield(L, -2, "P");
    lua_pushinteger(L, 20);                         lua_setfield(L, -2, "Q");
    lua_pushinteger(L, 21);                         lua_setfield(L, -2, "R");
    lua_pushinteger(L, 22);                         lua_setfield(L, -2, "S");
    lua_pushinteger(L, 23);                         lua_setfield(L, -2, "T");
    lua_pushinteger(L, 24);                         lua_setfield(L, -2, "U");
    lua_pushinteger(L, 25);                         lua_setfield(L, -2, "V");
    lua_pushinteger(L, 26);                         lua_setfield(L, -2, "W");
    lua_pushinteger(L, 27);                         lua_setfield(L, -2, "X");
    lua_pushinteger(L, 28);                         lua_setfield(L, -2, "Y");
    lua_pushinteger(L, 29);                         lua_setfield(L, -2, "Z");
    lua_pushinteger(L, 30);                         lua_setfield(L, -2, "N1");
    lua_pushinteger(L, 31);                         lua_setfield(L, -2, "N2");
    lua_pushinteger(L, 32);                         lua_setfield(L, -2, "N3");
    lua_pushinteger(L, 33);                         lua_setfield(L, -2, "N4");
    lua_pushinteger(L, 34);                         lua_setfield(L, -2, "N5");
    lua_pushinteger(L, 35);                         lua_setfield(L, -2, "N6");
    lua_pushinteger(L, 36);                         lua_setfield(L, -2, "N7");
    lua_pushinteger(L, 37);                         lua_setfield(L, -2, "N8");
    lua_pushinteger(L, 38);                         lua_setfield(L, -2, "N9");
    lua_pushinteger(L, 39);                         lua_setfield(L, -2, "N0");
    lua_pushinteger(L, 40);                         lua_setfield(L, -2, "RETURN");
    lua_pushinteger(L, 41);                         lua_setfield(L, -2, "ESCAPE");
    lua_pushinteger(L, 42);                         lua_setfield(L, -2, "BACKSPACE");
    lua_pushinteger(L, 43);                         lua_setfield(L, -2, "TAB");
    lua_pushinteger(L, 44);                         lua_setfield(L, -2, "SPACE");
    lua_pushinteger(L, 45);                         lua_setfield(L, -2, "MINUS");
    lua_pushinteger(L, 46);                         lua_setfield(L, -2, "EQUALS");
    lua_pushinteger(L, 47);                         lua_setfield(L, -2, "LEFTBRACKET");
    lua_pushinteger(L, 48);                         lua_setfield(L, -2, "RIGHTBRACKET");
    lua_pushinteger(L, 49);                         lua_setfield(L, -2, "BACKSLASH");
    lua_pushinteger(L, 50);                         lua_setfield(L, -2, "NONUSHASH");
    lua_pushinteger(L, 51);                         lua_setfield(L, -2, "SEMICOLON");
    lua_pushinteger(L, 52);                         lua_setfield(L, -2, "APOSTROPHE");
    lua_pushinteger(L, 53);                         lua_setfield(L, -2, "GRAVE");
    lua_pushinteger(L, 54);                         lua_setfield(L, -2, "COMMA");
    lua_pushinteger(L, 55);                         lua_setfield(L, -2, "PERIOD");
    lua_pushinteger(L, 56);                         lua_setfield(L, -2, "SLASH");
    lua_pushinteger(L, 57);                         lua_setfield(L, -2, "CAPSLOCK");
    lua_pushinteger(L, 58);                         lua_setfield(L, -2, "F1");
    lua_pushinteger(L, 59);                         lua_setfield(L, -2, "F2");
    lua_pushinteger(L, 60);                         lua_setfield(L, -2, "F3");
    lua_pushinteger(L, 61);                         lua_setfield(L, -2, "F4");
    lua_pushinteger(L, 62);                         lua_setfield(L, -2, "F5");
    lua_pushinteger(L, 63);                         lua_setfield(L, -2, "F6");
    lua_pushinteger(L, 64);                         lua_setfield(L, -2, "F7");
    lua_pushinteger(L, 65);                         lua_setfield(L, -2, "F8");
    lua_pushinteger(L, 66);                         lua_setfield(L, -2, "F9");
    lua_pushinteger(L, 67);                         lua_setfield(L, -2, "F10");
    lua_pushinteger(L, 68);                         lua_setfield(L, -2, "F11");
    lua_pushinteger(L, 69);                         lua_setfield(L, -2, "F12");
    lua_pushinteger(L, 70);                         lua_setfield(L, -2, "PRINTSCREEN");
    lua_pushinteger(L, 71);                         lua_setfield(L, -2, "SCROLLLOCK");
    lua_pushinteger(L, 72);                         lua_setfield(L, -2, "PAUSE");
    lua_pushinteger(L, 73);                         lua_setfield(L, -2, "INSERT");
    lua_pushinteger(L, 74);                         lua_setfield(L, -2, "HOME");
    lua_pushinteger(L, 75);                         lua_setfield(L, -2, "PAGEUP");
    lua_pushinteger(L, 76);                         lua_setfield(L, -2, "DELETE");
    lua_pushinteger(L, 77);                         lua_setfield(L, -2, "END");
    lua_pushinteger(L, 78);                         lua_setfield(L, -2, "PAGEDOWN");
    lua_pushinteger(L, 79);                         lua_setfield(L, -2, "RIGHT");
    lua_pushinteger(L, 80);                         lua_setfield(L, -2, "LEFT");
    lua_pushinteger(L, 81);                         lua_setfield(L, -2, "DOWN");
    lua_pushinteger(L, 82);                         lua_setfield(L, -2, "UP");
    lua_pushinteger(L, 83);                         lua_setfield(L, -2, "NUMLOCKCLEAR");
    lua_pushinteger(L, 84);                         lua_setfield(L, -2, "KP_DIVIDE");
    lua_pushinteger(L, 85);                         lua_setfield(L, -2, "KP_MULTIPLY");
    lua_pushinteger(L, 86);                         lua_setfield(L, -2, "KP_MINUS");
    lua_pushinteger(L, 87);                         lua_setfield(L, -2, "KP_PLUS");
    lua_pushinteger(L, 88);                         lua_setfield(L, -2, "KP_ENTER");
    lua_pushinteger(L, 89);                         lua_setfield(L, -2, "KP_1");
    lua_pushinteger(L, 90);                         lua_setfield(L, -2, "KP_2");
    lua_pushinteger(L, 91);                         lua_setfield(L, -2, "KP_3");
    lua_pushinteger(L, 92);                         lua_setfield(L, -2, "KP_4");
    lua_pushinteger(L, 93);                         lua_setfield(L, -2, "KP_5");
    lua_pushinteger(L, 94);                         lua_setfield(L, -2, "KP_6");
    lua_pushinteger(L, 95);                         lua_setfield(L, -2, "KP_7");
    lua_pushinteger(L, 96);                         lua_setfield(L, -2, "KP_8");
    lua_pushinteger(L, 97);                         lua_setfield(L, -2, "KP_9");
    lua_pushinteger(L, 98);                         lua_setfield(L, -2, "KP_0");
    lua_pushinteger(L, 99);                         lua_setfield(L, -2, "KP_PERIOD");
    lua_pushinteger(L, 100);                        lua_setfield(L, -2, "NONUSBACKSLASH");
    lua_pushinteger(L, 101);                        lua_setfield(L, -2, "APPLICATION");
    lua_pushinteger(L, 224);                        lua_setfield(L, -2, "LCTRL");
    lua_pushinteger(L, 225);                        lua_setfield(L, -2, "LSHIFT");
    lua_pushinteger(L, 226);                        lua_setfield(L, -2, "LALT");
    lua_pushinteger(L, 227);                        lua_setfield(L, -2, "LGUI");
    lua_pushinteger(L, 228);                        lua_setfield(L, -2, "RCTRL");
    lua_pushinteger(L, 229);                        lua_setfield(L, -2, "RSHIFT");
    lua_pushinteger(L, 230);                        lua_setfield(L, -2, "RALT");
    lua_pushinteger(L, 231);                        lua_setfield(L, -2, "RGUI");

    lua_setglobal(L, "key");

    lua_newtable(L);
    lua_pushcfunction(L,cpp_pad_down);              lua_setfield(L, -2, "down");
    lua_pushcfunction(L,cpp_pad_press);             lua_setfield(L, -2, "press");
    lua_pushcfunction(L,cpp_pad_any);               lua_setfield(L, -2, "any");
    //lua_setglobal(L, "gamepad");

    //lua_newtable(L);
    lua_pushinteger(L, -1);                         lua_setfield(L, -2, "INVALID");
    lua_pushinteger(L, 0);                          lua_setfield(L, -2, "A");
    lua_pushinteger(L, 1);                          lua_setfield(L, -2, "B");
    lua_pushinteger(L, 2);                          lua_setfield(L, -2, "X");
    lua_pushinteger(L, 3);                          lua_setfield(L, -2, "Y");
    lua_pushinteger(L, 4);                          lua_setfield(L, -2, "BACK");
    lua_pushinteger(L, 5);                          lua_setfield(L, -2, "GUIDE");
    lua_pushinteger(L, 6);                          lua_setfield(L, -2, "START");
    lua_pushinteger(L, 7);                          lua_setfield(L, -2, "LEFTSTICK");
    lua_pushinteger(L, 8);                          lua_setfield(L, -2, "RIGHTSTICK");
    lua_pushinteger(L, 9);                          lua_setfield(L, -2, "LEFTSHOULDER");
    lua_pushinteger(L, 10);                         lua_setfield(L, -2, "RIGHTSHOULDER");
    lua_pushinteger(L, 11);                         lua_setfield(L, -2, "UP");
    lua_pushinteger(L, 12);                         lua_setfield(L, -2, "DOWN");
    lua_pushinteger(L, 13);                         lua_setfield(L, -2, "LEFT");
    lua_pushinteger(L, 14);                         lua_setfield(L, -2, "RIGHT");
    lua_pushinteger(L, 15);                         lua_setfield(L, -2, "MISC1");
    lua_pushinteger(L, 16);                         lua_setfield(L, -2, "PADDLE1");
    lua_pushinteger(L, 17);                         lua_setfield(L, -2, "PADDLE2");
    lua_pushinteger(L, 18);                         lua_setfield(L, -2, "PADDLE3");
    lua_pushinteger(L, 19);                         lua_setfield(L, -2, "PADDLE4");
    lua_pushinteger(L, 20);                         lua_setfield(L, -2, "TOUCHPAD");

    lua_setglobal(L, "pad");

}

int MiniLoader(lua_State *L) {
    const char *name = luaL_checkstring(L, 1);
    char filename[strlen(name)+5];
    strcpy(filename, name);
    strcat(filename, ".lua");
    int size;
    char* buffer = file_getfilebuffer(filename, size);
    if (luaL_loadbuffer(L, buffer, size, filename)) {
        debug("REQUIRE LOADING ERROR: ");
        debug("%s\n",lua_tostring(L, -1));
        lua_pop(L,1);
        //return ;
    }
    free(buffer);
    return 1;
}

void lua_init(const char *main_lua_file) {
    L = luaL_newstate();
    luaL_openlibs(L);
    push_lua_funcs();
    lua_register(L, "mini_loader", MiniLoader);
    luaL_dostring(L, "table.insert(package.searchers,2,mini_loader)\n");

    int size;
    char* buffer = file_getfilebuffer(main_lua_file, size);
    if (luaL_loadbuffer(L, buffer, size, "main")) {
        debug("LOADING ERROR: ");
        debug("%s\n",lua_tostring(L, -1));
        lua_pop(L,1);
        return;
    }
    free(buffer);
    if (lua_pcall(L,0, LUA_MULTRET, 0)) {
        debug("RUNTIME ERROR [BOOT]: ");
        //debug("%s\n",lua_tostring(L, -1));
        //lua_pop(L,1);

        luaL_traceback(L, L, NULL, 1);
        debug("%s\n", lua_tostring(L, -1));
        lua_pop(L,1);
        return;
    }

    // Check if _init and _update exist
    lua_getglobal(L, "mini");
    lua_getfield(L, -1, "init");
    if (lua_isfunction(L,-1)) init_exists = true;
    lua_pop(L,1);
    lua_pop(L,1);

    lua_getglobal(L, "mini");
    lua_getfield(L, -1, "update");
    if (lua_isfunction(L,-1)) update_exists = true;
    lua_pop(L,1);
    lua_pop(L,1);

    is_playing = true;
}

void lua_call_init() {
    if (!init_exists) return;
    lua_getglobal(L, "mini");
    lua_getfield(L, -1, "init");
    if (lua_pcall(L, 0, 0, 0)) {
        debug("RUNTIME ERROR [INIT]: ");
        debug("%s\n",lua_tostring(L, -1));
        lua_pop(L,1);
        luaL_traceback(L, L, NULL, 1);
        debug("%s\n", lua_tostring(L, -1));
        lua_pop(L,1);
        is_playing = false;
    }
}

void lua_call_update() {
    if (!update_exists) return;
    lua_getglobal(L, "mini");
    lua_getfield(L, -1, "update");
    if (lua_pcall(L, 0, 0, 0)) {
        debug("RUNTIME ERROR [UPDATE]: ");
        debug("%s\n",lua_tostring(L, -1));
        lua_pop(L,1);
        luaL_traceback(L, L, NULL, 1);
        debug("%s\n", lua_tostring(L, -1));
        lua_pop(L,1);
        is_playing = false;
    }
}

void lua_quit() {
    if (!is_playing) return;
    is_playing = false;
    lua_close(L);
}