#include <sys/types.h>
#define _USE_MATH_DEFINES
#include <math.h>
#include <SDL.h>
#include <vector>
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
#ifdef HAVE_CONFIG_H
#include "config.h"
#else
#endif
//#include "gettext.h"
#include <Exceptions.h>
#include <generic.h>
#include <Main.h>
#include <Input.h>
#include <Output.h>
#include <Buffer.h>
#include <BLua.h>
#include <LuaHandle.h>
#include "glbase.h"
#include "texture.h"
#include "glfont.h"
#include "glwidgets.h"
#include "engine.h"
#include "glsprite.h"
#include "glshape.h"
#include "glwidgets.h"

class keyhandler_t : public mogltk::engine::keyevent {
    virtual void down(SDL_keysym keysym) {
        if (keysym.sym == SDLK_ESCAPE)
            mogltk::engine::quit();
        if ((keysym.sym == SDLK_RETURN) && (keysym.mod & KMOD_ALT))
            mogltk::engine::base_o->ToggleFullscreen();
    }
    virtual void up(SDL_keysym keysym) {
    }
} keyhandler;

#if 1

#define SPIN .50
#define TILT .20

#define NBSTARS 300
#define STARSRATE 300.0

#define SPHERE

int zoom = 1;

#define centerx 320
#define centery 240

struct tdvect {
    double x, y, z;
};

std::vector<tdvect> points;
std::vector<tdvect> ppoints;

static int myprint(lua_State * L) {
    const char * t = lua_tostring(L, -1);

    Base::printm(M_INFO, "From LUA: %s\n", t);

    return 0;
}

static int myluaputstar(lua_State * L) {
    tdvect t;

    t.x = lua_tonumber(L, -3);
    t.y = lua_tonumber(L, -2);
    t.z = lua_tonumber(L, -1);

    points.push_back(t);

    return 0;
}

int myluaerror(lua_State * L) {
    int n = lua_gettop(L);
    int i;
    String t;

    Base::printm(M_ERROR, "Got an LUA error\n");
    Base::printm(M_ERROR, "Inspecting LUA stack\n");

    if (n == 0) {
	Base::printm(M_ERROR, "Stack empty\n");
	return 0;
    }

    for (i = 1; i <= n; i++) {
	switch(lua_type(L, i)) {
	case LUA_TNONE:
	    t = "Invalid";
	    break;
	case LUA_TNIL:
	    t = "(Nil)";
	    break;
	case LUA_TNUMBER:
	    t.set("(Number) %f", lua_tonumber(L, i));
	    break;
	case LUA_TBOOLEAN:
	    t.set("(Bool)   %s", lua_toboolean(L, i) ? "true" : "false");
	    break;
	case LUA_TSTRING:
	    t.set("(String) %s", lua_tostring(L, i));
	    break;
	case LUA_TTABLE:
	    t.set("(Table)");
	    break;
	case LUA_TFUNCTION:
	    t = "(Function)";
	    break;
	default:
	    t = "Unknown";
	}

	Base::printm(M_ERROR, String(i) + ": " + t + "\n");
    }

    return 0;

    getchar();
}

unsigned int swap32(unsigned int w) {
    return (w >> 24) | ((w >> 8) & 0x0000ff00) | ((w << 8) & 0x00ff0000) | (w << 24);
}

unsigned int readB32(FILE * f) {
    unsigned int r;
    fread(&r, 1, 4, f);
    return swap32(r);
}

unsigned short readB16(FILE * f) {
    unsigned char t[2];
    fread(t, 1, 2, f);
    return t[1] | (t[0] << 8);
}

float tofloat(unsigned int w) {
    return *((float *) &w);
}

char * sread(FILE * f) {
    char temp[256], * p = temp;
    
    do {
	*p = fgetc(f);
    } while (*(p++));
    
    return strdup(temp);
}

char * pname[16] = {
    "Unknown (not a float)",
    "ScalX",
    "ScalY",
    "ScalZ",
    "Unknown (not a float)",
    "Unknown (not a float)",
    "TransX",
    "TransY",
    "TransZ",
    "Unknown",
    "Unknown",
    "Unknown",
    "Unknown",
    "Unknown",
    "Unknown",
    "Unknown"
};

#define OUTPUT stdout

unsigned short entries;
struct tdvect * mesh;

int bdlload(char * name) {
    FILE * bdl;
    int i, j;
    char sig[9], sec[5], ** bnames;
    unsigned int length, fpos, namespos, tpos, npos, r;
    unsigned short * unks;
    float f;
    
    if (!(bdl = fopen(name, "rb")))
	exit(-1);

    fread(sig, 1, 8, bdl);
    sig[8] = 0;
    
    if (strcmp(sig, "J3D2bdl4")) {
	fprintf(OUTPUT, "File not bdl.\n");
	exit(-1);
    }
    
    fprintf(OUTPUT, "Looking for section JNT1...\n");
    
    fseek(bdl, 32, SEEK_SET);
    
    do {
	fread(sec, 1, 4, bdl);
	sec[4] = 0;
	length = readB32(bdl);
	fprintf(OUTPUT, "Found section `%s' @ %08x, size %08x\n", sec, ftell(bdl) - 8, length);
	fseek(bdl, length - 8, SEEK_CUR);
    } while (strcmp(sec, "JNT1"));
    
    fseek(bdl, -length, SEEK_CUR);
    fpos = ftell(bdl);
    
    fprintf(OUTPUT, "Found it at 0x%08x\n", fpos);
    
    fseek(bdl, 8, SEEK_CUR);
    
    entries = readB16(bdl);
    if (readB16(bdl) != 0xffff) {
	fprintf(OUTPUT, "Something's wrong, not found FFFF\n");
    }
    if (readB32(bdl) != 0x18) {
	fprintf(OUTPUT, "Something's wrong, bones not at 0x18, can't go on.\n");
	exit(-1);
    }
    if (readB32(bdl) != (0x18 + entries * 0x40)) {
	fprintf(OUTPUT, "Something's wrong, bone index not at expected place, can't go on.\n");
	exit(-1);
    }
    
    namespos = readB32(bdl);
    
    fprintf(OUTPUT, "Reading names.\n");
    
    bnames = (char **) malloc(entries * sizeof(char *));
    unks = (unsigned short *) malloc(entries * sizeof(unsigned short));
    mesh = (struct tdvect *) malloc(entries * sizeof(struct tdvect));
    
    fseek(bdl, namespos + fpos + 4, SEEK_SET);
    
    for (i = 0; i < entries; i++) {
	unks[i] = readB16(bdl);
	npos = readB16(bdl) + fpos + namespos;
	tpos = ftell(bdl);
	fseek(bdl, npos, SEEK_SET);
	bnames[i] = sread(bdl);
	fseek(bdl, tpos, SEEK_SET);
    }
    for (i = 0; i < entries; i++) {
	fprintf(OUTPUT, "%02x: (%04x) `%s'\n", i, unks[i], bnames[i]);
    }
    
    fprintf(OUTPUT, "Dumping bones\n");
    
    fseek(bdl, fpos + 0x18, SEEK_SET);
    
    for (i = 0; i < entries; i++) {
	fprintf(OUTPUT, "Bone #%02x (%s):\n", i, bnames[i]); 
	for (j = 0; j < 16; j++) {
	    r = readB32(bdl);
	    f = tofloat(r);
	    fprintf(OUTPUT, "%x: %08x - %9.5f - %s\n", j, r, f, pname[j]);
	    switch(j) {
	    case 6:
		mesh[i].x = f;
		break;
	    case 7:
		mesh[i].y = f;
		break;
	    case 8:
		mesh[i].z = f;
		break;
	    }
	}
    }
    
    return 0;
}


CODE_BEGINS

void checkluastack(lua_State * L) {
    int n = lua_gettop(L);
    int i, j;
    String t;

    printm(M_INFO, "Inspecting LUA stack\n");

    if (n == 0) {
	printm(M_INFO, "Stack empty\n");
	return;
    }

    for (i = 1; i <= n; i++) {
	switch(lua_type(L, i)) {
	case LUA_TNONE:
	    t = "Invalid";
	    break;
	case LUA_TNIL:
	    t = "(Nil)";
	    break;
	case LUA_TNUMBER:
	    t.set("(Number) %f", lua_tonumber(L, i));
	    break;
	case LUA_TBOOLEAN:
	    t.set("(Bool)   %s", lua_toboolean(L, i) ? "true" : "false");
	    break;
	case LUA_TSTRING:
	    t.set("(String) %s", lua_tostring(L, i));
	    break;
	case LUA_TTABLE:
	    printm(M_INFO, String(i) + ": (Table) Exploring:\n");
	    lua_pushnil(L);  /* first key */
	    j = 0;
	    while (lua_next(L, -2) != 0) {
	    /* `key' is at index -2 and `value' at index -1 */
		printm(M_INFO, "    %s - %s\n", lua_typename(L, lua_type(L, -2)),
		                                lua_typename(L, lua_type(L, -1)));
		lua_pop(L, 1);  /* removes `value'; keeps `key' for next iteration */
	    }
	    t = "";
	    break;
	case LUA_TFUNCTION:
	    t = "(Function)";
	    break;
	default:
	    t = "Unknown";
	}

	if (t != "")
	    printm(M_INFO, String(i) + ": " + t + "\n");
    }
}

void putstar(double x, double y, double z, mogltk::Sprite * s) {
    double tx, ty, tz;
    double spin, tilt;

    spin = (mogltk::engine::mouseX() - centerx) / 80.0;
    tilt = (mogltk::engine::mouseY() - centery) / 80.0;

    // Spin --> around y
    
    tx =  x * cos(spin) + z * sin(spin);
    tz = -x * sin(spin) + z * cos(spin);

    x = tx;
    z = tz;


    // tilt --> around x

    ty =  y * cos(tilt) + z * sin(tilt);
    tz = -y * sin(tilt) + z * cos(tilt);

    y = ty;
    z = tz;

    tdvect t;
    t.x = x;
    t.y = y;
    t.z = z;

//	s->draw(centerx + t.x * zoom * mogltk::engine::mouseZ() - s->GetSX() / 2, centery + t.y * zoom * mogltk::engine::mouseZ() - s->GetSY() / 2);
    ppoints.push_back(t);
}

double t;

#ifdef STARSCAPE
int starsx[NBSTARS];
int starsy[NBSTARS];
#endif

#ifdef SPHERE
double starst[NBSTARS];
double starso[NBSTARS];
#endif

lua_State * L;

void initstars() {
    int i;
#ifdef STARSCAPE
    for (i = 0; i < NBSTARS; i++) {
	starsx[i] = rand() % 640;
	starsy[i] = rand() % 480;
    }

    t = 0;
#endif
#ifdef RING
    t = 0;
#endif
#ifdef SPHERE
    t = 0;
    for (i = 0; i < NBSTARS; i++) {
	starst[i] = -(rand() % 3000) / 1000.0;
	starso[i] = 2 * ((rand() % 1000) / 1000.0) * M_PI;
    }
#endif
#ifdef LUA
    L = lua_open();
    luaopen_math(L);
    lua_pop(L, 1);
    lua_atpanic(L, myluaerror);
    luaL_loadfile(L, "particules.lua");
    lua_call(L, 0, 0);
    lua_pushstring(L, "putstar");
    lua_pushcfunction(L, myluaputstar);
    lua_settable(L, LUA_GLOBALSINDEX);
    lua_pushstring(L, "print");
    lua_pushcfunction(L, myprint);
    lua_settable(L, LUA_GLOBALSINDEX);
    lua_pushstring(L, "initstars");
    lua_gettable(L, LUA_GLOBALSINDEX);
    lua_call(L, 0, 0);
#endif
}

void displaystars(mogltk::Sprite * s) {
    int i;
    double x, y, z, st;
    tdvect tv;

#ifdef STARSCAPE    
    for (i = 0; i < NBSTARS; i++) {
	s->draw(starsx[i], starsy[i]);
    }
#endif
#ifdef RING
    for (i = 0; i < NBSTARS; i++) {
	putstar(cos(t + i * 2 * M_PI / NBSTARS), 0, sin(t + i * 2 * M_PI / NBSTARS), s);
    }
#endif
#ifdef SPHERE
    for (i = 0; i < NBSTARS; i++) {
	st = t - starst[i];

	y = st / 3.0;

	x = cos(st * 2 * M_PI + starso[i]) * sin(y * M_PI);
	z = sin(st * 2 * M_PI + starso[i]) * sin(y * M_PI);

	y = cos(y * M_PI);

	putstar(x, y, z, s);
    }
#endif
#ifdef LUA
    lua_pushstring(L, "displaystars");
    lua_gettable(L, LUA_GLOBALSINDEX);
    lua_call(L, 0, 0);

    for (std::vector<tdvect>::iterator i = points.begin(); i != points.end(); i++) {
	tv = *i;
	putstar(tv.x, tv.y, tv.z, s);
    }
    points.clear();
#endif
#ifdef BDL
    for (i = 0; i < entries; i++) {
	putstar(mesh[i].x / 20, mesh[i].y / 20, mesh[i].z / 20, s);
    }
#endif
    while (!ppoints.empty()) {
	std::vector<tdvect>::iterator m = ppoints.begin();
	for (std::vector<tdvect>::iterator i = ppoints.begin(); i != ppoints.end(); i++) {
	    if (i->z > m->z)
		m = i;
	}
	tv = *m;
	ppoints.erase(m);
	// Only bare projecting... for now...
	s->draw(centerx + tv.x * zoom * mogltk::engine::mouseZ() - s->GetSX() / 2, centery + tv.y * zoom * mogltk::engine::mouseZ() - s->GetSY() / 2);
    }
}

void incrementstars(double nt) {
    int i;

#ifdef STARSCAPE
    while ((t + (1 / STARSRATE)) <= nt) {
	t += 1 / STARSRATE;

	for (i = 0; i < NBSTARS; i++) {
	    if ((++starsx[i]) >= 640) {
		starsx[i] = 0;
		starsy[i] = rand() % 480;
	    }
	}
    }
#endif
#ifdef RING
    t = nt;
#endif
#ifdef SPHERE
    t = nt;

    for (i = 0; i < NBSTARS; i++) {
	if ((starst[i] + 3) < t) {
	    starst[i] += 3.0;
    	    starso[i] = 2 * ((rand() % 1000) / 1000.0) * M_PI;
	}
    }
#endif
#ifdef LUA
    t = nt;

    lua_pushstring(L, "incstars");
    lua_gettable(L, LUA_GLOBALSINDEX);
    lua_pushnumber(L, t);
    lua_call(L, 1, 0);
#endif
}

virtual int startup() throw (GeneralException) {
    int sx1, sx2, sy1, sy2;
    double t = 0;
    verbosity = M_INFO;
    String str;

    mogltk::engine::setmouseZ(50);

#if 0
    Lua * l = new Lua();
    LuaInput::pushconstruct(l);
    LuaOutput::pushconstruct(l);
    LuaBuffer::pushconstruct(l);
    l->open_math();
    l->declarefunc("print", myprint);
#if 0
    l->load(&Input("particules.lua"), false);
    l->dump(&Output("particules.out"));
    l->call();
#else
    l->load(&Input("particules.out"));
#endif
//    l->call("testing");
    delete l;
#endif

    new Archive("datas.paq");
//    bdlload("cl.bdl");

#if 1
    mogltk::base * gl = new mogltk::glbase();
    mogltk::shape * sh = new mogltk::glshape();
    mogltk::font * font = new mogltk::glfont(&Input("font-2.bin"));
    mogltk::glSprite * s = new mogltk::glSprite(&Input("cursor.rgba"), 25, 25);
    mogltk::Sprite * p = new mogltk::glSprite(&Input("particule.rgba"), 16, 16);
//    mogltk::glSprite * spr = new mogltk::glSprite(&Input("015_Over-Mind.raw"), 347, 328);
    mogltk::glSprite * spr = new mogltk::glSprite(&Input("test.raw"), 200, 200);
    mogltk::widget * w = new mogltk::Root(sh);
#else
    mogltk::base * gl = new mogltk::base();
    mogltk::shape * sh = new mogltk::shape();
    mogltk::font * font = new mogltk::font(&Input("font-2.bin"));
    mogltk::Sprite * s = new mogltk::Sprite(&Input("cursor.rgba"), 25, 25);
    mogltk::Sprite * p = new mogltk::Sprite(&Input("particule.rgba"), 16, 16);
    mogltk::Sprite * spr = new mogltk::Sprite(&Input("015_Over-Mind.raw"), 347, 328);
    mogltk::widget * w = new mogltk::Root(sh);
#endif

#if 1
    font->setcolor(WHITE);
    font->setshadow(1);
    mogltk::rect textrect;
    mogltk::texture * text = font->printtex(&textrect, 
        "PixelPawa!\n"
        "It works!!\n"
        "I can't believe it!\n"
    );
    SDL_SaveBMP(text->GetSurface(), "test-font.bmp");
    textrect.x = 10;
    textrect.y = 30;
#endif

    mogltk::engine::setcursorvisible(true);
    mogltk::engine::setappactive(true);

    mogltk::engine::setkeyevent(&keyhandler);
    
    mogltk::texture * mytex = new mogltk::texture(&Input("pattern6.tex"), true);

    Color AlphaBlue(AQUA);
    AlphaBlue.A = 50;

    mogltk::fill * f = sh->fcircle(320, 240, 50);

    initstars();
    
    while (!mogltk::engine::quitrequested()) {
	sx1 = 320 + 320 * sin(0.983 * t + 3.15);
	sx2 = 320 + 320 * sin(0.537 * t + 5.32);
	sy1 = 240 + 240 * sin(0.692 * t + 8.21);
	sy2 = 240 + 240 * sin(1.029 * t + 2.42);

	gl->Enter2DMode();

	w->fulldraw();

	sh->tbox(mytex, 50, 50, 561, 561, BLACK, RED, LIME, BLUE);
	//sh->box(400, 100, 450, 150, BLACK, RED, LIME, BLUE);    

	sh->box(5, 5, 150, 80, CORNFLOWERBLUE, DEEPSKYBLUE, MIDNIGHTBLUE, NAVY);
	mogltk::ColorP::Max.A = 100;
	//sh->box(5, 5, 400, 300, CORNFLOWERBLUE, DEEPSKYBLUE, MIDNIGHTBLUE, NAVY);
	mogltk::ColorP::Max.A = 255;
#if 1
	font->setshadow(1);
	font->putcursor(10, 30);
	mogltk::ColorP::Max.A = sy1 / 2;
	font->setcolor(Color(sy1 / 2, sy1 / 2, sy1 / 2, sy1 / 2));
	font->printf(
	    "PixelPawa!\n"
	    "It works!!\n"
	    "I can't believe it!\n"
	);
	mogltk::ColorP::Max.A = 255;
	font->setcolor(WHITE);
#else
        sh->tbox(text, textrect.x, textrect.y, textrect.x + textrect.w, textrect.y + textrect.h);
#endif
	
	sh->box3d(50, 150, 150, 200);
	sh->obox3d(50, 250, 150, 300);
	sh->window(50, 350, 150, 400, "Titre plus beau ;)");
	sh->box3d(180, 130, 320, 220);
	sh->button(200, 150, 300, 200, "Bouton");

	sh->fdraw(f, BLUE);
	sh->sdraw(f);

        spr->drawrotate(500, 400, sx1);
	
	sh->box(MIN(sx1, sx2), MIN(sy1, sy2), MAX(sx1, sx2), MAX(sy1, sy2), AlphaBlue);
	mogltk::ColorP::Min.A = 200;
	sh->obox(MIN(sx1, sx2), MIN(sy1, sy2), MAX(sx1, sx2), MAX(sy1, sy2), AlphaBlue);
	mogltk::ColorP::Min.A = 0;

	p->draw(mogltk::engine::mouseX() - 8, mogltk::engine::mouseY() - 8);
	sh->line(320, 240, mogltk::engine::mouseX(), mogltk::engine::mouseY());

	mogltk::ColorP::Min.A = 200;
	p->draw(sx1 - 8, sy1 - 8, AlphaBlue);
	p->draw(sx2 - 8, sy2 - 8, AlphaBlue);

	displaystars(p);
	incrementstars(t);

	font->putcursor(550, 400);
	font->printf("FPS: %.2f\n", mogltk::engine::FPS());
	font->printf("mx: %i\n", mogltk::engine::mouseX());
	font->printf("my: %i\n", mogltk::engine::mouseY());
	font->printf("t: %.2fs\n", SDL_GetTicks() / 1000.0);
        mogltk::ColorP::Max.A = 50;
	s->draw(mogltk::engine::mouseX() - 6, mogltk::engine::mouseY() - 3, BLACK);
        mogltk::ColorP::Max.A = 255;
	s->draw(mogltk::engine::mouseX() - 8, mogltk::engine::mouseY() - 6);

	gl->Leave2DMode();

	gl->Flip();
	t = (double) SDL_GetTicks() / 1000.0;
    }
    
    delete mytex;
    
    return 0;
}
CODE_ENDS

#else

CODE_BEGINS
virtual int startup() throw (GeneralException) {
    unsigned char palette[256][3], * pixels, c;
    char outname[256];
    int width, height, x, y;

    if (argc != 2)
        exit(-1);
    Input i(argv[1]);
    SDL_Init(SDL_INIT_VIDEO);
    atexit(SDL_Quit);
    width = i.readU16();
    height = i.readU16();
    i.seek(12, SEEK_CUR);
    SDL_Surface * s = SDL_SetVideoMode(width, height, 24, 0);
    pixels = (unsigned char *) s->pixels;
    for (x = 0; x < 256; x++) {
        for (y = 0; y < 3; y++) {
            palette[x][y] = i.readU8();
        }
        i.seek(1, SEEK_CUR);
    }
    for (y = 0; y < height; y++) {
        for (x = 0; x < width; x++) {
            c = i.readU8();
            pixels[(y * width + x) * 3 + 0] = palette[c][2];
            pixels[(y * width + x) * 3 + 1] = palette[c][1];
            pixels[(y * width + x) * 3 + 2] = palette[c][0];
        }
    }

    *strchr(argv[1], '.') = 0;

    sprintf(outname, "%s.bmp", argv[1]);

    SDL_SaveBMP(s, outname);

    SDL_Flip(s);

    SDL_Event event;
    
    while(true) {
        SDL_PollEvent(&event);
        switch (event.type) {
        case SDL_QUIT:
            exit(0);
        }
    }

    return 0;
}
CODE_ENDS


#endif