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

extern "C" {
    static int cpp_newsurf(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_loadsurf(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        lua_pushinteger(L, loadsurf(str));
        return 1;
    }

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

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

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

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

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

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

    static int cpp_loadpal(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        uint32_t *pal = loadpal(str);
        lua_createtable(L, 2, 0);
        for (int i=0;i<=256;++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_setpal(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=1;i<=len;++i) {
                lua_rawgeti(L, -1, i);
                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-1] = (r<<16)+(g<<8)+b;
            }
            setpal(pal);
        }
        return 0;
    }

    static int cpp_setcolor(lua_State *L) {
        uint8_t index = luaL_checkinteger(L, 1);
        uint8_t r = luaL_checkinteger(L, 2);
        uint8_t g = luaL_checkinteger(L, 3);
        uint8_t b = luaL_checkinteger(L, 4);
        uint32_t color = (r<<16) + (g<<8) + b;
        setcolor(index, color);
        return 0;
    }
    static int cpp_getcolor(lua_State *L) {
        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;
    }
    static int cpp_settrans(lua_State *L) {
        uint8_t index = luaL_checkinteger(L, 1);
        settrans(index);
        return 0;
    }
    static int cpp_gettrans(lua_State *L) {
        lua_pushinteger(L, gettrans());
        return 1;
    }
/*    static int cpp_pal(lua_State *L) {
        int numargs = lua_gettop(L);
        switch (numargs) {
            case 0: pal(); return 0;
            case 1: luaL_error(L, "not enough arguments"); return 0;
        }
        uint8_t c0 = luaL_checkinteger(L, 1);
        uint8_t c1 = luaL_checkinteger(L, 2);
        uint8_t p = luaL_optinteger(L, 3, 0);
        pal(c0, c1, p);
        return 0;
    }

    static int cpp_palt(lua_State *L) {
        int numargs = lua_gettop(L);
        switch (numargs) {
            case 0: palt(); return 0;
            case 1: uint16_t bits = luaL_checkinteger(L, 1); palt(bits); return 0;
        }
        uint8_t col = luaL_checkinteger(L, 1);
        bool t = lua_toboolean(L, 2);
        palt(col, t);
        return 0;
    }*/

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

    static int cpp_pget(lua_State *L) {
        int x = luaL_checknumber(L, 1);
        int y = luaL_checknumber(L, 2);
        lua_pushinteger(L, pget(x, y));
        return 1;
    }

    static int cpp_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);
        if (lua_gettop(L) > 4) {
            uint8_t color = luaL_checkinteger(L, 5);
            line(x0, y0, x1, y1, color);
        } else {
            line(x0, y0, x1, y1);
        }
        return 0;
    }

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

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

    static int cpp_rect(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);
        if (lua_gettop(L) > 4) {
            uint8_t color = luaL_checkinteger(L, 5);
            rect(x0, y0, x1, y1, color);
        } else {
            rect(x0, y0, x1, y1);
        }
        return 0;
    }

    static int cpp_rectfill(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);
        if (lua_gettop(L) > 4) {
            uint8_t color = luaL_checkinteger(L, 5);
            rectfill(x0, y0, x1, y1, color);
        } else {
            rectfill(x0, y0, x1, y1);
        }
        return 0;
    }

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

    static int cpp_print(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;
    }

    static int cpp_clip(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);
        clip(x, y, w, h);
        return 0;
    }

    static int cpp_camera(lua_State *L) {
        int x = luaL_checknumber(L, 1);
        int y = luaL_checknumber(L, 2);
        camera(x, y);
        return 0;
    }

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

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

    static int cpp_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);
        if (lua_gettop(L) > 4) {
            uint8_t color = luaL_checkinteger(L, 5);
            oval(x0, y0, x1, y1, color);
        } else {
            oval(x0, y0, x1, y1);
        }
        return 0;
    }

    static int cpp_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);
        if (lua_gettop(L) > 4) {
            uint8_t color = luaL_checkinteger(L, 5);
            ovalfill(x0, y0, x1, y1, color);
        } else {
            ovalfill(x0, y0, x1, y1);
        }
        return 0;
    }

    static int cpp_sset(lua_State *L) {
        int x = luaL_checknumber(L, 1);
        int y = luaL_checknumber(L, 2);
        if (lua_gettop(L) > 2) {
            uint8_t color = luaL_checkinteger(L, 3);
            sset(x, y, color);
        } else {
            sset(x, y);
        }
        return 0;
    }

    static int cpp_sget(lua_State *L) {
        int x = luaL_checknumber(L, 1);
        int y = luaL_checknumber(L, 2);
        lua_pushinteger(L, sget(x, y));
        return 1;
    }

    static int cpp_spr(lua_State *L) {
        uint8_t n = luaL_checkinteger(L, 1);
        int x = luaL_checknumber(L, 2);
        int y = luaL_checknumber(L, 3);
        float w = luaL_optnumber(L, 4, 1.0f);
        float h = luaL_optnumber(L, 5, 1.0f);
        bool flip_x = lua_toboolean(L, 6);
        bool flip_y = lua_toboolean(L, 7);
        spr(n, x, y, w, h, flip_x, flip_y);
        return 0;
    }

    static int cpp_sspr(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);
        sspr(sx, sy, sw, sh, dx, dy, dw, dh, flip_x, flip_y);
        return 0;
    }

    static int cpp_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_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_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_mset(lua_State *L) {
        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;
    }

    static int cpp_mget(lua_State *L) {
        int celx = luaL_checknumber(L, 1);
        int cely = luaL_checknumber(L, 2);
        lua_pushinteger(L, mget(celx, cely));
        return 1;
    }

    static int cpp_map(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);
        map(celx, cely, sx, sy, celw, celh, layer);
        return 0;
    }

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

    static int cpp_btnp(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_anykey(lua_State *L) {
        lua_pushboolean(L, anykey());
        return 1;
    }

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

    static int cpp_padp(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_mousex(lua_State *L) {
        lua_pushinteger(L, mousex());
        return 1;
    }

    static int cpp_mousey(lua_State *L) {
        lua_pushinteger(L, mousey());
        return 1;
    }

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

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

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

    static int cpp_abs(lua_State *L) {
        float x = luaL_checknumber(L, 1);
        lua_pushnumber(L, abs(x));
        return 1;
    }
    static int cpp_ceil(lua_State *L) {
        float x = luaL_checknumber(L, 1);
        lua_pushnumber(L, ceil(x));
        return 1;
    }
    static int cpp_flr(lua_State *L) {
        float x = luaL_checknumber(L, 1);
        lua_pushnumber(L, flr(x));
        return 1;
    }
    static int cpp_sgn(lua_State *L) {
        float x = luaL_checknumber(L, 1);
        lua_pushnumber(L, sgn(x));
        return 1;
    }
    static int cpp_sin(lua_State *L) {
        float x = luaL_checknumber(L, 1);
        lua_pushnumber(L, sin(x));
        return 1;
    }
    static int cpp_cos(lua_State *L) {
        float x = luaL_checknumber(L, 1);
        lua_pushnumber(L, cos(x));
        return 1;
    }
    static int cpp_atan2(lua_State *L) {
        float dx = luaL_checknumber(L, 1);
        float dy = luaL_checknumber(L, 2);
        lua_pushnumber(L, atan2(dx, dy));
        return 1;
    }
    static int cpp_sqrt(lua_State *L) {
        float x = luaL_checknumber(L, 1);
        lua_pushnumber(L, sqrt(x));
        return 1;
    }
    static int cpp_max(lua_State *L) {
        float x = luaL_checknumber(L, 1);
        float y = luaL_checknumber(L, 2);
        lua_pushnumber(L, max(x, y));
        return 1;
    }
    static int cpp_mid(lua_State *L) {
        float x = luaL_checknumber(L, 1);
        float y = luaL_checknumber(L, 2);
        float z = luaL_checknumber(L, 3);
        lua_pushnumber(L, mid(x, y, z));
        return 1;
    }
    static int cpp_min(lua_State *L) {
        float x = luaL_checknumber(L, 1);
        float y = luaL_checknumber(L, 2);
        lua_pushnumber(L, min(x, y));
        return 1;
    }
    static int cpp_rnd(lua_State *L) {
        int x = luaL_checkinteger(L, 1);
        lua_pushinteger(L, rnd(x));
        return 1;
    }
    static int cpp_srand(lua_State *L) {
        int x = luaL_checkinteger(L, 1);
        srand(x);
        return 0;
    }
    static int cpp_tostr(lua_State *L) {
        int val = luaL_checknumber(L, 1);
        lua_pushstring(L, tostr(val));
        return 1;
    }
    static int cpp_ascii(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        int index = luaL_checkinteger(L, 2);
        lua_pushinteger(L, ascii(str, index));
        return 1;
    }
    static int cpp_strlen(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        lua_pushinteger(L, utfstrlen(str));
        return 1;
    }

    static int cpp_fopen(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        uint8_t mode = luaL_optinteger(L, 2, 0);
        fopen(str, mode);
        return 0;
    }
    static int cpp_fopenres(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        fopenres(str);
        return 0;
    }
    static int cpp_fclose(lua_State *L) {
        fclose();
        return 0; 
    }

    static int cpp_feof(lua_State *L) {
        lua_pushboolean(L,feof());
        return 1;
    }

    static int cpp_fwritei(lua_State *L) {
        int value = luaL_checkinteger(L, 1);
        fwritei(value);
        return 0;
    }

    static int cpp_fwrited(lua_State *L) {
        float value = luaL_checknumber(L, 1);
        fwrited(value);
        return 0;
    }

    static int cpp_fwrites(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        fwrites(str);
        return 0;
    }

    static int cpp_fwritew(lua_State *L) {
        const char* str = luaL_checkstring(L, 1);
        fwritew(str);
        return 0;
    }

    static int cpp_fwriteb(lua_State *L) {
        bool value = lua_toboolean(L, 1);
        fwriteb(value);
        return 0;
    }

    static int cpp_fwriteln(lua_State *L) {
        fwriteln();
        return 0;
    }

    static int cpp_freadi(lua_State *L) {
        lua_pushinteger(L,freadi());
        return 1;
    }

    static int cpp_freadd(lua_State *L) {
        lua_pushnumber(L,freadd());
        return 1;
    }

    static int cpp_freads(lua_State *L) {
        lua_pushstring(L,freads());
        return 1;
    }

    static int cpp_freadw(lua_State *L) {
        lua_pushstring(L,freadw());
        return 1;
    }

    static int cpp_freadb(lua_State *L) {
        lua_pushboolean(L,freadb());
        return 1;
    }

    static int cpp_playmusic(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_pausemusic(lua_State *L) {
        pausemusic();
        return 0;
    }

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

    static int cpp_stopmusic(lua_State *L) {
        stopmusic();
        return 0;
    }

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

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

    static int cpp_playsound(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_stopsound(lua_State *L) {
        const int sound = luaL_checknumber(L, 1);
        stopsound(sound);
        return 0;
    }

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

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

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

    static int cpp_getconf(lua_State *L) {
        const char* key = luaL_checkstring(L, 1);
        const char* value = getconfig(key);
        if (value==NULL) {
            lua_pushnil(L);
        } else {
            lua_pushstring(L, value);
        }
        return 1;
    }

    static int cpp_setconf(lua_State *L) {
        const char* key = luaL_checkstring(L, 1);
        const char* value = luaL_checkstring(L, 2);
        setconfig(key, value);
        return 0;
    }

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

}

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_pushcfunction(L,cpp_newsurf);   lua_setglobal(L, "newsurf");
    lua_pushcfunction(L,cpp_loadsurf);  lua_setglobal(L, "loadsurf");
    lua_pushcfunction(L,cpp_freesurf);  lua_setglobal(L, "freesurf");
    lua_pushcfunction(L,cpp_setdest);   lua_setglobal(L, "setdest");
    lua_pushcfunction(L,cpp_setsource); lua_setglobal(L, "setsource");
    lua_pushcfunction(L,cpp_setmap);    lua_setglobal(L, "setmap");

    lua_pushcfunction(L,cpp_cls);       lua_setglobal(L, "cls");
    lua_pushcfunction(L,cpp_color);     lua_setglobal(L, "color");

    lua_pushcfunction(L,cpp_loadpal);   lua_setglobal(L, "loadpal");
    lua_pushcfunction(L,cpp_setpal);    lua_setglobal(L, "setpal");
    lua_pushcfunction(L,cpp_setcolor);  lua_setglobal(L, "setcolor");
    lua_pushcfunction(L,cpp_getcolor);  lua_setglobal(L, "getcolor");
    lua_pushcfunction(L,cpp_settrans);  lua_setglobal(L, "settrans");
    lua_pushcfunction(L,cpp_gettrans);  lua_setglobal(L, "gettrans");

    lua_pushcfunction(L,cpp_pset);      lua_setglobal(L, "pset");
    lua_pushcfunction(L,cpp_pget);      lua_setglobal(L, "pget");
    lua_pushcfunction(L,cpp_line);      lua_setglobal(L, "line");
    lua_pushcfunction(L,cpp_hline);     lua_setglobal(L, "hline");
    lua_pushcfunction(L,cpp_vline);     lua_setglobal(L, "vline");
    lua_pushcfunction(L,cpp_rect);      lua_setglobal(L, "rect");
    lua_pushcfunction(L,cpp_rectfill);  lua_setglobal(L, "rectfill");
    lua_pushcfunction(L,cpp_fillp);     lua_setglobal(L, "fillp");
    lua_pushcfunction(L,cpp_print);     lua_setglobal(L, "prnt");
    lua_pushcfunction(L,cpp_clip);      lua_setglobal(L, "clip");
    lua_pushcfunction(L,cpp_camera);    lua_setglobal(L, "camera");
    lua_pushcfunction(L,cpp_circ);      lua_setglobal(L, "circ");
    lua_pushcfunction(L,cpp_circfill);  lua_setglobal(L, "circfill");
    lua_pushcfunction(L,cpp_oval);      lua_setglobal(L, "oval");
    lua_pushcfunction(L,cpp_ovalfill);  lua_setglobal(L, "ovalfill");
    lua_pushcfunction(L,cpp_sset);      lua_setglobal(L, "sset");
    lua_pushcfunction(L,cpp_sget);      lua_setglobal(L, "sget");
    lua_pushcfunction(L,cpp_spr);       lua_setglobal(L, "spr");
    lua_pushcfunction(L,cpp_sspr);      lua_setglobal(L, "sspr");
    lua_pushcfunction(L,cpp_tline);     lua_setglobal(L, "tline");
    lua_pushcfunction(L,cpp_thline);    lua_setglobal(L, "thline");
    lua_pushcfunction(L,cpp_tvline);    lua_setglobal(L, "tvline");
    lua_pushcfunction(L,cpp_mget);      lua_setglobal(L, "mget");
    lua_pushcfunction(L,cpp_mset);      lua_setglobal(L, "mset");
    lua_pushcfunction(L,cpp_map);       lua_setglobal(L, "map");
    lua_pushcfunction(L,cpp_btn);       lua_setglobal(L, "btn");
    lua_pushcfunction(L,cpp_btnp);      lua_setglobal(L, "btnp");
    lua_pushcfunction(L,cpp_anykey);    lua_setglobal(L, "anykey");
    lua_pushcfunction(L,cpp_pad);       lua_setglobal(L, "pad");
    lua_pushcfunction(L,cpp_padp);      lua_setglobal(L, "padp");
    lua_pushcfunction(L,cpp_mousex);    lua_setglobal(L, "mousex");
    lua_pushcfunction(L,cpp_mousey);    lua_setglobal(L, "mousey");
    lua_pushcfunction(L,cpp_mwheel);    lua_setglobal(L, "mwheel");
    lua_pushcfunction(L,cpp_mbtn);      lua_setglobal(L, "mbtn");

    lua_pushcfunction(L,cpp_time);      lua_setglobal(L, "time");
    lua_pushcfunction(L,cpp_abs);       lua_setglobal(L, "abs");
    lua_pushcfunction(L,cpp_ceil);      lua_setglobal(L, "ceil");
    lua_pushcfunction(L,cpp_flr);       lua_setglobal(L, "flr");
    lua_pushcfunction(L,cpp_sgn);       lua_setglobal(L, "sgn");
    lua_pushcfunction(L,cpp_sin);       lua_setglobal(L, "sin");
    lua_pushcfunction(L,cpp_cos);       lua_setglobal(L, "cos");
    lua_pushcfunction(L,cpp_atan2);     lua_setglobal(L, "atan2");
    lua_pushcfunction(L,cpp_sqrt);      lua_setglobal(L, "sqrt");
    lua_pushcfunction(L,cpp_max);       lua_setglobal(L, "max");
    lua_pushcfunction(L,cpp_mid);       lua_setglobal(L, "mid");
    lua_pushcfunction(L,cpp_min);       lua_setglobal(L, "min");
    lua_pushcfunction(L,cpp_rnd);       lua_setglobal(L, "rnd");
    lua_pushcfunction(L,cpp_srand);     lua_setglobal(L, "srand");
    lua_pushcfunction(L,cpp_tostr);     lua_setglobal(L, "tostr");
    lua_pushcfunction(L,cpp_ascii);     lua_setglobal(L, "ascii");
    lua_pushcfunction(L,cpp_strlen);    lua_setglobal(L, "strlen");

    lua_pushcfunction(L,cpp_fopen);     lua_setglobal(L, "fopen");
    lua_pushcfunction(L,cpp_fopenres);  lua_setglobal(L, "fopenres");
    lua_pushcfunction(L,cpp_fclose);    lua_setglobal(L, "fclose");
    lua_pushcfunction(L,cpp_feof);      lua_setglobal(L, "feof");
    lua_pushcfunction(L,cpp_fwritei);   lua_setglobal(L, "fwritei");
    lua_pushcfunction(L,cpp_fwrited);   lua_setglobal(L, "fwrited");
    lua_pushcfunction(L,cpp_fwrites);   lua_setglobal(L, "fwrites");
    lua_pushcfunction(L,cpp_fwritew);   lua_setglobal(L, "fwritew");
    lua_pushcfunction(L,cpp_fwriteb);   lua_setglobal(L, "fwriteb");
    lua_pushcfunction(L,cpp_fwriteln);  lua_setglobal(L, "fwriteln");
    lua_pushcfunction(L,cpp_freadi);    lua_setglobal(L, "freadi");
    lua_pushcfunction(L,cpp_freadd);    lua_setglobal(L, "freadd");
    lua_pushcfunction(L,cpp_freads);    lua_setglobal(L, "freads");
    lua_pushcfunction(L,cpp_freadw);    lua_setglobal(L, "freadw");
    lua_pushcfunction(L,cpp_freadb);    lua_setglobal(L, "freadb");

    lua_pushcfunction(L,cpp_playmusic);     lua_setglobal(L, "playmusic");
    lua_pushcfunction(L,cpp_pausemusic);    lua_setglobal(L, "pausemusic");
    lua_pushcfunction(L,cpp_resumemusic);   lua_setglobal(L, "resumemusic");
    lua_pushcfunction(L,cpp_stopmusic);     lua_setglobal(L, "stopmusic");
    lua_pushcfunction(L,cpp_loadsound);     lua_setglobal(L, "loadsound");
    lua_pushcfunction(L,cpp_freesound);     lua_setglobal(L, "freesound");
    lua_pushcfunction(L,cpp_playsound);     lua_setglobal(L, "playsound");
    lua_pushcfunction(L,cpp_stopsound);     lua_setglobal(L, "stopsound");

    lua_pushcfunction(L,cpp_zoom);          lua_setglobal(L, "zoom");
    lua_pushcfunction(L,cpp_fullscreen);    lua_setglobal(L, "fullscreen");
    lua_pushcfunction(L,cpp_cursor);        lua_setglobal(L, "cursor");

    lua_pushcfunction(L,cpp_getconf);       lua_setglobal(L, "getconf");
    lua_pushcfunction(L,cpp_setconf);       lua_setglobal(L, "setconf");

    lua_pushcfunction(L,cpp_exit);          lua_setglobal(L, "quit");

    lua_pushinteger(L, 0);              lua_setglobal(L, "KEY_UNKNOWN");
    lua_pushinteger(L, 4);              lua_setglobal(L, "KEY_A");
    lua_pushinteger(L, 5);              lua_setglobal(L, "KEY_B");
    lua_pushinteger(L, 6);              lua_setglobal(L, "KEY_C");
    lua_pushinteger(L, 7);              lua_setglobal(L, "KEY_D");
    lua_pushinteger(L, 8);              lua_setglobal(L, "KEY_E");
    lua_pushinteger(L, 9);              lua_setglobal(L, "KEY_F");
    lua_pushinteger(L, 10);             lua_setglobal(L, "KEY_G");
    lua_pushinteger(L, 11);             lua_setglobal(L, "KEY_H");
    lua_pushinteger(L, 12);             lua_setglobal(L, "KEY_I");
    lua_pushinteger(L, 13);             lua_setglobal(L, "KEY_J");
    lua_pushinteger(L, 14);             lua_setglobal(L, "KEY_K");
    lua_pushinteger(L, 15);             lua_setglobal(L, "KEY_L");
    lua_pushinteger(L, 16);             lua_setglobal(L, "KEY_M");
    lua_pushinteger(L, 17);             lua_setglobal(L, "KEY_N");
    lua_pushinteger(L, 18);             lua_setglobal(L, "KEY_O");
    lua_pushinteger(L, 19);             lua_setglobal(L, "KEY_P");
    lua_pushinteger(L, 20);             lua_setglobal(L, "KEY_Q");
    lua_pushinteger(L, 21);             lua_setglobal(L, "KEY_R");
    lua_pushinteger(L, 22);             lua_setglobal(L, "KEY_S");
    lua_pushinteger(L, 23);             lua_setglobal(L, "KEY_T");
    lua_pushinteger(L, 24);             lua_setglobal(L, "KEY_U");
    lua_pushinteger(L, 25);             lua_setglobal(L, "KEY_V");
    lua_pushinteger(L, 26);             lua_setglobal(L, "KEY_W");
    lua_pushinteger(L, 27);             lua_setglobal(L, "KEY_X");
    lua_pushinteger(L, 28);             lua_setglobal(L, "KEY_Y");
    lua_pushinteger(L, 29);             lua_setglobal(L, "KEY_Z");
    lua_pushinteger(L, 30);             lua_setglobal(L, "KEY_1");
    lua_pushinteger(L, 31);             lua_setglobal(L, "KEY_2");
    lua_pushinteger(L, 32);             lua_setglobal(L, "KEY_3");
    lua_pushinteger(L, 33);             lua_setglobal(L, "KEY_4");
    lua_pushinteger(L, 34);             lua_setglobal(L, "KEY_5");
    lua_pushinteger(L, 35);             lua_setglobal(L, "KEY_6");
    lua_pushinteger(L, 36);             lua_setglobal(L, "KEY_7");
    lua_pushinteger(L, 37);             lua_setglobal(L, "KEY_8");
    lua_pushinteger(L, 38);             lua_setglobal(L, "KEY_9");
    lua_pushinteger(L, 39);             lua_setglobal(L, "KEY_0");
    lua_pushinteger(L, 40);             lua_setglobal(L, "KEY_RETURN");
    lua_pushinteger(L, 41);             lua_setglobal(L, "KEY_ESCAPE");
    lua_pushinteger(L, 42);             lua_setglobal(L, "KEY_BACKSPACE");
    lua_pushinteger(L, 43);             lua_setglobal(L, "KEY_TAB");
    lua_pushinteger(L, 44);             lua_setglobal(L, "KEY_SPACE");
    lua_pushinteger(L, 45);             lua_setglobal(L, "KEY_MINUS");
    lua_pushinteger(L, 46);             lua_setglobal(L, "KEY_EQUALS");
    lua_pushinteger(L, 47);             lua_setglobal(L, "KEY_LEFTBRACKET");
    lua_pushinteger(L, 48);             lua_setglobal(L, "KEY_RIGHTBRACKET");
    lua_pushinteger(L, 49);             lua_setglobal(L, "KEY_BACKSLASH");
    lua_pushinteger(L, 50);             lua_setglobal(L, "KEY_NONUSHASH");
    lua_pushinteger(L, 51);             lua_setglobal(L, "KEY_SEMICOLON");
    lua_pushinteger(L, 52);             lua_setglobal(L, "KEY_APOSTROPHE");
    lua_pushinteger(L, 53);             lua_setglobal(L, "KEY_GRAVE");
    lua_pushinteger(L, 54);             lua_setglobal(L, "KEY_COMMA");
    lua_pushinteger(L, 55);             lua_setglobal(L, "KEY_PERIOD");
    lua_pushinteger(L, 56);             lua_setglobal(L, "KEY_SLASH");
    lua_pushinteger(L, 57);             lua_setglobal(L, "KEY_CAPSLOCK");
    lua_pushinteger(L, 58);             lua_setglobal(L, "KEY_F1");
    lua_pushinteger(L, 59);             lua_setglobal(L, "KEY_F2");
    lua_pushinteger(L, 60);             lua_setglobal(L, "KEY_F3");
    lua_pushinteger(L, 61);             lua_setglobal(L, "KEY_F4");
    lua_pushinteger(L, 62);             lua_setglobal(L, "KEY_F5");
    lua_pushinteger(L, 63);             lua_setglobal(L, "KEY_F6");
    lua_pushinteger(L, 64);             lua_setglobal(L, "KEY_F7");
    lua_pushinteger(L, 65);             lua_setglobal(L, "KEY_F8");
    lua_pushinteger(L, 66);             lua_setglobal(L, "KEY_F9");
    lua_pushinteger(L, 67);             lua_setglobal(L, "KEY_F10");
    lua_pushinteger(L, 68);             lua_setglobal(L, "KEY_F11");
    lua_pushinteger(L, 69);             lua_setglobal(L, "KEY_F12");
    lua_pushinteger(L, 70);             lua_setglobal(L, "KEY_PRINTSCREEN");
    lua_pushinteger(L, 71);             lua_setglobal(L, "KEY_SCROLLLOCK");
    lua_pushinteger(L, 72);             lua_setglobal(L, "KEY_PAUSE");
    lua_pushinteger(L, 73);             lua_setglobal(L, "KEY_INSERT");
    lua_pushinteger(L, 74);             lua_setglobal(L, "KEY_HOME");
    lua_pushinteger(L, 75);             lua_setglobal(L, "KEY_PAGEUP");
    lua_pushinteger(L, 76);             lua_setglobal(L, "KEY_DELETE");
    lua_pushinteger(L, 77);             lua_setglobal(L, "KEY_END");
    lua_pushinteger(L, 78);             lua_setglobal(L, "KEY_PAGEDOWN");
    lua_pushinteger(L, 79);             lua_setglobal(L, "KEY_RIGHT");
    lua_pushinteger(L, 80);             lua_setglobal(L, "KEY_LEFT");
    lua_pushinteger(L, 81);             lua_setglobal(L, "KEY_DOWN");
    lua_pushinteger(L, 82);             lua_setglobal(L, "KEY_UP");
    lua_pushinteger(L, 83);             lua_setglobal(L, "KEY_NUMLOCKCLEAR");
    lua_pushinteger(L, 84);             lua_setglobal(L, "KEY_KP_DIVIDE");
    lua_pushinteger(L, 85);             lua_setglobal(L, "KEY_KP_MULTIPLY");
    lua_pushinteger(L, 86);             lua_setglobal(L, "KEY_KP_MINUS");
    lua_pushinteger(L, 87);             lua_setglobal(L, "KEY_KP_PLUS");
    lua_pushinteger(L, 88);             lua_setglobal(L, "KEY_KP_ENTER");
    lua_pushinteger(L, 89);             lua_setglobal(L, "KEY_KP_1");
    lua_pushinteger(L, 90);             lua_setglobal(L, "KEY_KP_2");
    lua_pushinteger(L, 91);             lua_setglobal(L, "KEY_KP_3");
    lua_pushinteger(L, 92);             lua_setglobal(L, "KEY_KP_4");
    lua_pushinteger(L, 93);             lua_setglobal(L, "KEY_KP_5");
    lua_pushinteger(L, 94);             lua_setglobal(L, "KEY_KP_6");
    lua_pushinteger(L, 95);             lua_setglobal(L, "KEY_KP_7");
    lua_pushinteger(L, 96);             lua_setglobal(L, "KEY_KP_8");
    lua_pushinteger(L, 97);             lua_setglobal(L, "KEY_KP_9");
    lua_pushinteger(L, 98);             lua_setglobal(L, "KEY_KP_0");
    lua_pushinteger(L, 99);             lua_setglobal(L, "KEY_KP_PERIOD");
    lua_pushinteger(L, 100);            lua_setglobal(L, "KEY_NONUSBACKSLASH");
    lua_pushinteger(L, 101);            lua_setglobal(L, "KEY_APPLICATION");
    lua_pushinteger(L, 224);            lua_setglobal(L, "KEY_LCTRL");
    lua_pushinteger(L, 225);            lua_setglobal(L, "KEY_LSHIFT");
    lua_pushinteger(L, 226);            lua_setglobal(L, "KEY_LALT");
    lua_pushinteger(L, 227);            lua_setglobal(L, "KEY_LGUI");
    lua_pushinteger(L, 228);            lua_setglobal(L, "KEY_RCTRL");
    lua_pushinteger(L, 229);            lua_setglobal(L, "KEY_RSHIFT");
    lua_pushinteger(L, 230);            lua_setglobal(L, "KEY_RALT");
    lua_pushinteger(L, 231);            lua_setglobal(L, "KEY_RGUI");

    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_INVALID);          lua_setglobal(L, "BTN_INVALID");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_A);                lua_setglobal(L, "BTN_A");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_B);                lua_setglobal(L, "BTN_B");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_X);                lua_setglobal(L, "BTN_X");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_Y);                lua_setglobal(L, "BTN_Y");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_BACK);             lua_setglobal(L, "BTN_BACK");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_GUIDE);            lua_setglobal(L, "BTN_GUIDE");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_START);            lua_setglobal(L, "BTN_START");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_LEFTSTICK);        lua_setglobal(L, "BTN_LEFTSTICK");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_RIGHTSTICK);       lua_setglobal(L, "BTN_RIGHTSTICK");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_LEFTSHOULDER);     lua_setglobal(L, "BTN_LEFTSHOULDER");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);    lua_setglobal(L, "BTN_RIGHTSHOULDER");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_DPAD_UP);          lua_setglobal(L, "BTN_UP");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_DPAD_DOWN);        lua_setglobal(L, "BTN_DOWN");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_DPAD_LEFT);        lua_setglobal(L, "BTN_LEFT");
    lua_pushinteger(L, SDL_CONTROLLER_BUTTON_DPAD_RIGHT);       lua_setglobal(L, "BTN_RIGHT");
    lua_pushinteger(L, 15);            lua_setglobal(L, "BTN_MISC1");
    lua_pushinteger(L, 16);          lua_setglobal(L, "BTN_PADDLE1");
    lua_pushinteger(L, 17);          lua_setglobal(L, "BTN_PADDLE2");
    lua_pushinteger(L, 18);          lua_setglobal(L, "BTN_PADDLE3");
    lua_pushinteger(L, 19);          lua_setglobal(L, "BTN_PADDLE4");
    lua_pushinteger(L, 20);         lua_setglobal(L, "BTN_TOUCHPAD");

    lua_pushinteger(L, 0);              lua_setglobal(L, "FILE_READ");
    lua_pushinteger(L, 1);              lua_setglobal(L, "FILE_WRITE");
}

void lua_init(char* filenames) {
    L = luaL_newstate();
    luaL_openlibs(L);
    push_lua_funcs();

    char *pointer = filenames;
    do {
        // Get next filename...
        char *file_start=pointer;
        while (*pointer!=',' && *pointer!=0) pointer++;
        if (*pointer!=0) *(pointer++)=0;

        // Load and execute file
        //if (luaL_loadfile(L, file_start)) { // "game.lua"
        int size;
        char* buffer = file_getfilebuffer(file_start, size);
        if (luaL_loadbuffer(L, buffer, size, file_start)) {
            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: ");
            debug("%s\n",lua_tostring(L, -1));
            lua_pop(L,1);
            return;
        }
        if (*pointer!=0) *(pointer-1)=',';
    } while (*pointer!=0);

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

    lua_getglobal(L, "_update");
    if (lua_isfunction(L,-1)) update_exists = true;
    lua_pop(L,1);

    is_playing = true;
}

void lua_call_init() {
    if (!init_exists) return;
    lua_getglobal(L, "_init");
    if (lua_pcall(L, 0, 0, 0)) {
        debug("RUNTIME ERROR: ");
        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, "_update");
    if (lua_pcall(L, 0, 0, 0)) {
        debug("RUNTIME ERROR: ");
        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);
}