#include <iostream>
#include "viewer.h"
#include "polygon.h"
#include "demonstration.h"
#include "pad.h"
#include "TaskManager.h"
using namespace std;

int init(void*, void*);
int sdl_init(void*, void*);
int zrow_init(void*, void*);
int run(void*, void*);
int finish(void*, void*);

extern int run_init();

TaskManager *manager;
Viewer *screen;

extern void task_initialize(void);

struct init_arg {
    int bpp;
    int w;
    int h;
};

int init(void *w, void *_arg)
{
    struct init_arg *arg;
    int fd_sdl_init, fd_zrow_init, fd_run, fd_finish;
    HTaskPtr task_sdl_init, task_zrow_init, task_run, task_finish;

    arg = (struct init_arg *)_arg;

    screen = new Viewer(arg->bpp, arg->w, arg->h);

    fd_sdl_init  = manager->open("sdl_init");
    fd_zrow_init = manager->open("zRow_init");
    fd_run       = manager->open("run");
    fd_finish    = manager->open("finish");

    // こっから下は一つの関数だと確かに簡単
    // 複数の依存がある場合はどうしようかな。
    // 可変引数にするわけにもいかないし。
    // その時は set_task_depend を自分で呼ぶ？
    // でもそれだと、結局自分で書いた方が早い気も。
    task_sdl_init  = manager->create_task(fd_sdl_init, 0, 0, 0, NULL);
    task_zrow_init = manager->create_task(fd_zrow_init, 0, 0, 0, NULL);
    task_run       = manager->create_task(fd_run, 0, 0, 0, NULL);
    task_finish    = manager->create_task(fd_finish, 0, 0, 0, NULL);

    manager->set_task_depend(task_sdl_init, task_run);
    manager->set_task_depend(task_zrow_init, task_run);
    manager->set_task_depend(task_run, task_finish);

    //task_sdl_init->set_depend(..);
    //task_sdl_init->spawn();

    manager->spawn_task(task_sdl_init);
    manager->spawn_task(task_zrow_init);
    manager->spawn_task(task_run);
    manager->spawn_task(task_finish);

    free(arg);
    return 0;
}


// クラス関数は単純にポインタで扱えないので
// 現状は間接的に呼ぶことに
int sdl_init(void *w, void *r)
{
    screen->sdl_init();
    return 0;
}

int zRow_init(void *w, void *r)
{
    screen->zRow_init();
    return 0;
}

int run(void *w, void *r)
{
    screen->run();
    return 0;
}

int finish(void *w, void *r)
{
    delete screen;
    return 0;
}

// 上の init() が代わりに動いてます
int run_test(int bpp, int width, int height)
{
    Viewer *screen;
    screen = new Viewer(bpp, width, height);
    //screen->init();
    screen->sdl_init();

    //Scene *scene;
    //scene = new Scene;
  
    screen->zRow_init();
    //screen->scene = scene;
    screen->run();

    //delete scene;
    delete screen;

    return(0);
}


int main(int argc, char *argv[])
{
    manager = new TaskManager(1);
    manager->init();

    task_initialize();

    // 本当は、dlsym みたいなものを使いたいんだけど
    // 静的なやつはできないん？
    manager->set_symbol("init", (void*)init);
    manager->set_symbol("sdl_init", (void*)sdl_init);
    manager->set_symbol("zRow_init", (void*)zRow_init);
    manager->set_symbol("run", (void*)run);
    manager->set_symbol("finish", (void*)finish);

    int bpp = 0;
    int width = 640;
    int height = 480;

    for(int i = 1; argv[i]; ++i)
    {
	if (strcmp(argv[i], "-bpp") == 0)
	{
	    bpp = atoi(argv[++i]);
	}
	if (strcmp(argv[i], "-width") == 0)
	{
	    width = atoi(argv[++i]);
	} 
	if (strcmp(argv[i], "-height") == 0) 
	{
	    height = atoi(argv[++i]);
	}
    }

#if 1
    run_test(bpp, width, height);
#else
    // 一番最初に行われる init 専用の task_run があってもいいけど。。
    // その場合は引数とか固定か。まあ引数は argc, argv を持つ
    // 構造体で固定しても問題はない・・・か？
    HTaskPtr task_init;
    int fd_init;
    struct init_arg *arg = new struct init_arg;

    arg->bpp = bpp;
    arg->w = width;
    arg->h = height;    

    fd_init = manager->open("init");
    task_init  = manager->create_task(fd_init, sizeof(struct init_arg),
				      (unsigned int)arg, 0, NULL);
    manager->spawn_task(task_init);
    manager->run();
#endif
    return 0;
}