#include <SDL.h>
#include "viewer.h"
#include "viewer_types.h"
#include "SceneGraph.h"
#include "SceneGraphRoot.h"
#include "scene_graph_pack.h"
#include "sys.h"
#include "Func.h"
#include "error.h"
#include "TaskManager.h"
#include <wchar.h>
#include "Pad.h"
#include "Application.h"
#include "lindaapi.h"

static void post2runLoop(SchedTask *s,void *viewer,void *s1);
static void post2runDraw(SchedTask *s,void *viewer,void *s1);
static void post2speRendering(SchedTask *s,void *viewer,void *s1);
static void post2speDraw(SchedTask *s,void *viewer,void *s1);
static void post2runMoveDrawLoop(SchedTask *s,void *viewer,void *s1);

/* measure for FPS (Frame Per Second) */
int start_time;
int this_time;
int frames;
// static void post2speRunLoop(void *viewer);
//static void post2runMove(void *viewer);
//static void post2exchange_sgroot(void *viewer);
//static void post2speRunLoop(void *viewer);

//SceneGraphRootPtr sgroot_2;

/* Data Pack sent to Other CPUs (ex. SPE) */
SceneGraphPack *sgpack;
PolygonPack *ppack;
SpanPackPtr spackList;
SpanPackPtr *spackList_ptr;

int spackList_length;
int spackList_length_align;

/**
 *
 */

Viewer::Viewer(TaskManager *m, ViewerDevice *vd, int b, int w, int h, int _num)
{
    spe_num = _num;
    manager = m;

    dev = vd;
    pixels = dev->video_init(manager, b, w, h);

    width = dev->width;
    height = dev->height;
    bpp = dev->bpp;

}

int
Viewer::get_ticks(void)
{
    int time;
    time = SDL_GetTicks();
    return time;
}

bool
Viewer::quit_check(void)
{
    SDL_Event event;

    while(SDL_PollEvent(&event)) {
        if (event.type==SDL_QUIT) {
            return true;
        }
    }

    Uint8 *keys=SDL_GetKeyState(NULL);

    if (keys[SDLK_q] == SDL_PRESSED) {
        return true;
    }

    return false;
}

void
Viewer::quit(void)
{
    SDL_Quit();
}


void
Viewer::run_init(TaskManager *manager, Application *app)
{
    this->manager = manager;

    start_time = get_ticks();
    this_time  = 0;
    frames     = 0;

    if (spe_num == 0) spe_num = 1;

    sgroot = new SceneGraphRoot(this->width, this->height);
    sgroot->tmanager = manager;


    int light_num = 4;
    int size = sizeof(float)*4*light_num; //xyz+alfa(4) * light_num(4)
    int light_size = size / sizeof(float);

    light_xyz_stock = (float *)manager->allocate(size);
    light_xyz = (float *)manager->allocate(size);

    for (int i = 0; i < light_size ; i++) {
      light_xyz[i] = 0.0f;
    }

    for(int i = 0; i < spe_num; i++) {

	HTaskPtr data_load = manager->create_task(DataLoad);
	data_load->set_param(0,(memaddr)size);
	data_load->set_param(1,(memaddr)Light);
	data_load->set_cpu((CPU_TYPE)((int)SPE_0 + i));
	data_load->spawn();
    }

    size = light_num * sizeof(int);
    light_switch = (int*)manager->allocate(size);

    for (int i = 0; i < light_num; i++) {
        light_switch[i] = 0;
    }

    for(int i = 0; i < spe_num; i++) {
	HTaskPtr data_load = manager->create_task(DataLoad);
	data_load->set_param(0,(memaddr)size);
	data_load->set_param(1,(memaddr)LightSwitch);
	data_load->set_cpu((CPU_TYPE)((int)SPE_0 + i));
	data_load->spawn();
    }

    size = 16; // LightSysSwitch は 4byte. 残り 12byte は DMA転送の為のパディング

    light_sysswitch = (int*)manager->allocate(size);

    for (unsigned int i = 0; i < size / sizeof(int); i++) {
      light_sysswitch[i] = 0;
    }

    for(int i = 0; i < spe_num; i++) {
	HTaskPtr data_load = manager->create_task(DataLoad);
	data_load->set_param(0,(memaddr)size);
	data_load->set_param(1,(memaddr)LightSysSwitch);
	data_load->set_cpu((CPU_TYPE)((int)SPE_0 + i));
	data_load->spawn();
    }
    
    MainLoop *mainloop = app->init(this, this->width, this->height);
    mainloop->mainLoop();
}


HTaskPtr
Viewer::initLoop()
{
    HTaskPtr task_next;
    HTaskPtr task_tex;

    sgpack = (SceneGraphPack*)manager->allocate(sizeof(SceneGraphPack));
    sgpack->init();
    ppack  = (PolygonPack*)manager->allocate(sizeof(PolygonPack));

    spackList_length = (this->height + split_screen_h - 1) / split_screen_h;
    spackList = (SpanPack*)manager->allocate(sizeof(SpanPack)*spackList_length);

    /**
     * SPU に送る address list は 16 バイト倍数でないといけない。
     * spackList_length*sizeof(SpanPack*) が 16 バイト倍数になるような
     * length_align を求めている。はみ出した部分は使われない
     * (ex) spackList_length が 13 の場合
     *   spackList_length_align = 16;
     *     実際に送るデータは64バイトになるのでOK
     *     14,15,16 の部分は何も入らない。
     */
    spackList_length_align = (spackList_length + 3)&(~3);

    /* 各 SPU が持つ、SpanPack の address list */
    spackList_ptr =
        (SpanPack**)manager->allocate(sizeof(SpanPack*)*spackList_length_align);

    for (int i = 0; i < spackList_length; i++) {
        spackList_ptr[i] = &spackList[i];
    }

    for (int i = 1; i <= spackList_length; i++) {
        spackList[i-1].init(i*split_screen_h);
    }

    task_next = manager->create_task(Dummy,0,0,0,0);
    
    // ここは、Iterator を用意するべきだよね
    for (int i = 0; i < spe_num; i++) {
        task_tex = manager->create_task(LoadTexture,0,0,0,0);
        task_tex->set_cpu((CPU_TYPE)((int)SPE_0 + i));
        task_next->wait_for(task_tex);
	task_tex->spawn();	
    }


    return task_next;
}


void
Viewer::getKey()
{
    Pad *pad = sgroot->getController();
    if (pad->right.isHold()) {
		keyPtr->right = HOLD;
    } else if (pad->right.isPush()) {
		keyPtr->right = PUSH;
    } else {
		keyPtr->right = NONE;
    }
    
    if (pad->left.isHold()) {
		keyPtr->left = HOLD;
    } else if (pad->left.isPush()) {
		keyPtr->left = PUSH;
    } else {
		keyPtr->left = NONE;
    }

    if (pad->up.isHold()) {
		keyPtr->up = HOLD;
    } else if (pad->up.isPush()) {
		keyPtr->up = PUSH;
    } else {
		keyPtr->up = NONE;
    }

    if (pad->down.isHold()) {
		keyPtr->down = HOLD;
    } else if (pad->down.isPush()) {
		keyPtr->down = PUSH;
    } else {
		keyPtr->down = NONE;
    }

    if (pad->circle.isHold()) {
		keyPtr->circle = HOLD;
    } else if (pad->circle.isPush()) {
		keyPtr->circle = PUSH;
    } else {
		keyPtr->circle = NONE;
    }
}

static void
post2runMoveDrawLoop(SchedTask *m, void *viewer_, void *arg)
{
    Viewer *viewer = (Viewer*)viewer_;
    
    // 同じ PPE 上なので sgroot(ポインタ) を set_param で送る。 
    //HTaskPtr send_key_task = viewer->manager->create_task(SendKey);
    //send_key_task->set_param((int)sgroot);
    // set input data -> viewer keyPtr
    viewer->getKey();
    //HTaskPtr update_key = viewer->manager->create_task(UpdateKey,viewer->keyPtr, sizeof(key_stat),0,0);
    HTaskPtr update_key = viewer->manager->create_task(UpdateKey,0,0,0,0);
    update_key->add_inData(viewer->keyPtr, sizeof(key_stat));
    //update_key->set_cpu(SPE_0);
    update_key->spawn();
    
    /* TASK_MOVE は外から引数で取ってくるべき */
    //HTaskPtr move_task = viewer->manager->create_task(viewer->app->move_taskid);    
    HTaskPtr move_task = viewer->manager->create_task(Move,0,0,0,0);
    //move_task->set_param(sgroot);

    //HTaskPtr draw_task = viewer->manager->create_task(Draw);

    /* rendering task test */
    HTaskPtr draw_task = viewer->manager->create_task(Dummy,0,0,0,0);
    HTaskPtr draw_dummy = viewer->manager->create_task(Dummy,0,0,0,0);

    HTaskPtr switch_task = viewer->manager->create_task(Switch,0,0,0,0);
    viewer->draw_dummy = draw_dummy;
    switch_task->wait_for(draw_dummy);
    draw_task->set_post(post2speRendering, (void*)viewer, 0);

    switch_task->wait_for(move_task);
    switch_task->wait_for(draw_task);
    move_task->spawn();
    draw_task->spawn();

    switch_task->set_post(post2runMoveDrawLoop, (void*)viewer, 0);
    switch_task->spawn();
    
}

void
Viewer::mainLoop()
{
    HTaskPtr task_next = initLoop();

    task_next->set_post(&post2runLoop, (void *)this, 0); // set_post(function(this->run_loop()), NULL)
    task_next->spawn();
}

void
Viewer::run_loop(HTaskPtr task_next)
{
    dev->clear_screen();

    bool quit_flg;
    quit_flg = quit_check();
    if (quit_flg == true) {
        this_time = get_ticks();
        run_finish();
        return;
    }

    dev->clean_pixels();

    for (int i = 1; i <= spackList_length; i++) {
        spackList[i-1].reinit(i*split_screen_h);
    }

    sgroot->updateControllerState();
    sgroot->allExecute(width, height);
    light_xyz_stock = sgroot->getLightVector();
    light_switch_stock = sgroot->getLightSwitch();
    light_sysswitch_stock = sgroot->getLightSysSwitch();
    //sgroot->checkRemove();

    // ここから下は Rendering という関数にする
    rendering(task_next);
}



void
Viewer::run_collision()
{
}

void
post2rendering(SchedTask *s, void *viewer_, void *arg)
{
    Viewer *viewer = (Viewer *)viewer_;
    HTaskPtr task_next = viewer->manager->create_task(Dummy,0,0,0,0);
    viewer->rendering(task_next);
}

void 
Viewer::rendering(HTaskPtr task_next)
{
    common_rendering(task_next, sgroot);
    
    // Barrier 同期
    // run_draw() を呼ぶ post2runDraw
    task_next->set_post(post2runDraw, (void*)this, 0); // set_post(function(this->run_draw()), NULL)
    task_next->spawn();

    // TASK_CREATE_SPAN が全て終わったら DUMMY_TASK が Viewer::run_draw() を呼ぶ
}

static void
post2runLoop(SchedTask *s, void *viewer_, void *arg)
{
    Viewer *viewer = (Viewer*)viewer_;
    HTaskPtr task_next = viewer->manager->create_task(Dummy,0,0,0,0);
    viewer->run_loop(task_next);
    psx_sync_n();
}

static void 
post2runDraw(SchedTask *s, void *viewer_, void *arg)
{
    Viewer *viewer = (Viewer*)viewer_;
    HTaskPtr task_next = viewer->manager->create_task(Dummy,0,0,0,0);
    viewer->run_draw(task_next);

}

void
Viewer::run_draw(HTaskPtr task_next) // 引数に post2runLoop を入れるようにする
{
    common_draw(task_next);

    task_next->set_post(post2runLoop, (void*)this, 0); // set_post(function(this->run_loop()), NULL)
    task_next->spawn();
    // TASK_DRAW_SPAN が全て終わったら DUMMY_TASK が Viewer::run_loop() を呼ぶ    

    frames++;
}


static void
post2speRendering(SchedTask *s, void *viewer_, void *arg)
{
    Viewer *viewer = (Viewer*)viewer_;
    HTaskPtr task_next = viewer->manager->create_task(Dummy,0,0,0,0);
    viewer->spe_rendering(task_next);
}

void 
Viewer::spe_rendering(HTaskPtr task_next)
{
    common_rendering(task_next, sgroot);

    this->draw_dummy->wait_for(task_next);
    task_next->set_post(post2speDraw, (void*)this, 0);
    task_next->spawn();

}

static void 
post2speDraw(SchedTask *s, void *viewer_, void *arg)
{
    Viewer *viewer = (Viewer*)viewer_;
    HTaskPtr task_next = viewer->manager->create_task(Dummy,0,0,0,0);
    viewer->spe_draw(task_next);
}

void
Viewer::spe_draw(HTaskPtr task_next)
{
    common_draw(task_next);
    
    this->draw_dummy->wait_for(task_next);
    task_next->spawn();
    this->draw_dummy->spawn();

    frames++;
}

#if SPE_CREATE_POLYGON

void
Viewer::create_pp_task(SceneGraphPtr sg, PolygonPackPtr pp_cur, HTaskPtr create_pp_wait,
		       int &pp_index, int &sg_index, int tri_num) 
{

    HTaskPtr create_pp = manager->create_task(CreatePolygon);
    create_pp->set_inData(0, &sg->tri_pack[sg_index], sizeof(TrianglePack)*tri_num);
    create_pp->set_inData(1, sg->texture_info, sizeof(texture_list));
    create_pp->set_inData(2, sg->sg_matrix, sizeof(float)*32); //わーい、マジックナンバー
    create_pp->set_outData(0, &pp_cur->tri[pp_index], sizeof(TrianglePack)*tri_num);
    create_pp->set_param(0, (memaddr)tri_num);
    //create_pp->set_cpu(SPE_ANY);
    create_pp_wait->wait_for(create_pp);
    create_pp->spawn();

    pp_index += tri_num;
    sg_index += tri_num;
}

#endif

void
Viewer::common_rendering(HTaskPtr task_next, SceneGraphRoot *sgroot)
{

#if SPE_CREATE_POLYGON

  SceneGraphPtr sg = sgroot->getDrawSceneGraph();
  PolygonPackPtr pp_cur = ppack;
  HTaskPtr create_pp_wait = manager->create_task(Dummy);
  int pp_index = 0;

  pp_cur->init();

  task_next->wait_for(create_pp_wait);

  while (sg) {
    
    if (sg->flag_drawable) {

      int sum_size = sg->size;
      int tri_cur_num = MAX_SIZE_TRIANGLE;
      int sg_index = 0;

      while (sum_size) {
	
	  tri_cur_num -= sg->size/3;
	
	  if (tri_cur_num < 0) {
	    
	      tri_cur_num = MAX_SIZE_TRIANGLE;
	      create_pp_task(sg, pp_cur, create_pp_wait,
			     pp_index, sg_index, tri_cur_num);
	     
	      PolygonPackPtr next = (PolygonPackPtr)manager->allocate(sizeof(PolygonPack));
	      next->init();

	      pp_cur->next = next;
	      pp_cur       = next;
	      pp_index = 0;
	      
	  } else {
	  
	      create_pp_task(sg, pp_cur, create_pp_wait,
			     pp_index, sg_index, tri_cur_num);

	  }

	  sum_size -= tri_cur_num*3;

      }
      
      
    }
    
    
    
    if (sg->children != NULL) {
      sg = sg->children;
    } else if (sg->brother != NULL) {
      sg = sg->brother;
    } else {
      while (sg) {
	if (sg->brother != NULL) {
	  sg = sg->brother;
	  break;
	} else {
	  if (sg->parent == NULL) {
	    sg = NULL;
	    break;
	  } else {
	    sg = sg->parent;
	  }
	}
      }
    } 
  }
  

  int  range_base = spe_num;
  
    // 切り上げのつもり
  int range = (spackList_length + range_base - 1) / range_base;
  
  for (int i = 0; i < range_base; i++) {
    int index_start = range*i;
    int index_end = (index_start + range >= spackList_length)
      ? spackList_length : index_start + range;
    
    HTaskPtr task_create_sp = manager->create_task(CreateSpan);
    
    task_create_sp->set_param(0,index_start);
    
    /**
     * ex. screen_height が 480, spenum が 6 の場合、各SPEのy担当範囲
     *   [  1.. 80] [ 81..160] [161..240]
     *   [241..320] [321..400] [401..480]
     *
     * ex. screen_height が 1080, spenum が 5 の場合、
     *   [  1..216] [217..432] [433..648]
     *   [649..864] [865..1080]
     */
    
    task_create_sp->set_param(1,index_start*split_screen_h + 1);
    task_create_sp->set_param(2,index_end*split_screen_h);
    
    task_create_sp->add_inData(ppack, sizeof(PolygonPack));
    task_create_sp->add_inData(spackList_ptr,
			       sizeof(SpanPack*)*spackList_length_align);
    task_create_sp->add_inData(&spackList[index_start], sizeof(SpanPack));
    
    task_next->wait_for(task_create_sp);
    task_create_sp->wait_for(create_pp_wait);
    
    task_create_sp->set_cpu(SPE_ANY);
    task_create_sp->spawn();
  }
  
#else

    HTaskPtr task_create_pp = manager->create_task(CreatePolygonFromSceneGraph);
    
    // SceneGraph(木構造) -> PolygonPack

    task_create_pp->set_param(0,(memaddr)sgroot->getDrawSceneGraph());
    task_create_pp->set_param(1,(memaddr)ppack);

    task_next->wait_for(task_create_pp);

    int  range_base = spe_num;

    // 切り上げのつもり
    int range = (spackList_length + range_base - 1) / range_base;

    for (int i = 0; i < range_base; i++) {
        int index_start = range*i;
        int index_end = (index_start + range >= spackList_length)
            ? spackList_length : index_start + range;

	HTaskPtr task_create_sp = manager->create_task(CreateSpan);

        task_create_sp->set_param(0,index_start);
	
        /**
         * ex. screen_height が 480, spenum が 6 の場合、各SPEのy担当範囲
         *   [  1.. 80] [ 81..160] [161..240]
         *   [241..320] [321..400] [401..480]
         *
         * ex. screen_height が 1080, spenum が 5 の場合、
         *   [  1..216] [217..432] [433..648]
         *   [649..864] [865..1080]
         */

        task_create_sp->set_param(1,index_start*split_screen_h + 1);
        task_create_sp->set_param(2,index_end*split_screen_h);

        task_create_sp->add_inData(ppack, sizeof(PolygonPack));
        task_create_sp->add_inData(spackList_ptr,
                                   sizeof(SpanPack*)*spackList_length_align);
        task_create_sp->add_inData(&spackList[index_start], sizeof(SpanPack));

        task_next->wait_for(task_create_sp);
        task_create_sp->wait_for(task_create_pp);

	task_create_sp->set_cpu(SPE_ANY);
        task_create_sp->spawn();
    }

    task_create_pp->spawn();

#endif

}

HTaskPtr
Viewer::update_task_create(void *data, int size, 
			   int load_id, int spe_id, HTaskPtr wait)
{

	HTaskPtr data_update = manager->create_task(DataUpdate);
	data_update->add_inData(data,size);
	data_update->set_param(0,size);
	data_update->set_param(1,load_id);
	data_update->set_cpu((CPU_TYPE)(spe_id));
	if (wait != NULL) {
	  wait->wait_for(data_update);
	}
	data_update->spawn();

	return data_update;

}

void
Viewer::common_draw(HTaskPtr task_next)
{

    //task_next = manager->create_task(Dummy);
    //task_next->set_post(post2runLoop, (void*)this);

    //Light info update
                                                                   
    //HTaskPtr data_update;
    HTaskPtr data_update_wait;
    int light_num = 4;
    int size = sizeof(float)*4*light_num; //xyz+alpha(4) * light_num(4) 
    int light_size = size / sizeof(float);

    for (int i = 0; i < light_size; i++) {
        light_xyz[i] = light_xyz_stock[i]; 
    }

    for (int i = 0; i < light_num; i++) {
        light_switch[i] = light_switch_stock[i];
    }

    light_sysswitch[0] = light_sysswitch_stock;
 
    data_update_wait = manager->create_task(DataUpdate);
    data_update_wait->add_inData(light_xyz,size);
    data_update_wait->set_param(0,size);
    data_update_wait->set_param(1,Light);
    data_update_wait->set_cpu((CPU_TYPE)((int)SPE_0));
      
    for (int i = 1; i < spe_num; i++) {
      update_task_create(light_xyz,size,Light,(int)SPE_0+i,data_update_wait);
    }

    size = light_num * sizeof(int);

    for (int i = 0; i < spe_num; i++) {
      update_task_create(light_switch,size,LightSwitch,(int)SPE_0+i,data_update_wait);
    }

    size = 16; // LightSysSwitch は 4byte. 残り 12byte は DMA転送の為のパディング

    for (int i = 0; i < spe_num; i++) {
      update_task_create(light_sysswitch,size,LightSysSwitch,(int)SPE_0+i,data_update_wait);
    }
    
    ppack->clear();
    for (int i = 0; i < spackList_length; i++) {
        SpanPack *spack = &spackList[i];
        int startx = 1;
        int endx = split_screen_w;

        int starty = spack->info.y_top - split_screen_h + 1;
        //int endy = spack->info.y_top;
        int rangey = (starty + split_screen_h - 1 > this->height)
            ? this->height - starty + 1 : split_screen_h;

#if 1

	if(spack->info.size > 0) {

	  int array_task_num = (this->width + split_screen_w - 1) / split_screen_w;
	  HTaskPtr task_draw_array = manager->create_task_array(DrawSpan, array_task_num, 6, 1, rangey);
	  Task *task_draw = 0;
	  
	  while (startx < this->width) {
	    
	    // Draw SpanPack
	    
	    task_draw = task_draw_array->next_task_array(DrawSpan,task_draw);
	    task_draw->set_param(0,(memaddr)&pixels[(startx-1) + this->width*(starty-1)]);
	    task_draw->set_param(1,this->width);
	    task_draw->set_param(2,startx);
	    task_draw->set_param(3,endx);
	    task_draw->set_param(4,rangey);
	    task_draw->set_param(5,spack->info.size);
	    
	    task_draw->set_inData(0,spack, sizeof(SpanPack));
	    
	    for (int i = 0; i < rangey; i++) {
	      task_draw->set_outData(i,
				     &pixels[(startx-1) + this->width*(starty-1 + i) ],
				     (endx-startx+1)*sizeof(int));
	    }
	    
	    startx += split_screen_w;
	    endx += split_screen_w;
	    
	    if (endx > this->width) {
	      endx = this->width;
	    }
	    
	  }	
	  
	  task_draw_array->spawn_task_array(task_draw->next());
	  task_draw_array->set_cpu(SPE_ANY);
	  task_next->wait_for(task_draw_array);
	  task_draw_array->wait_for(data_update_wait);
	  task_draw_array->spawn();

	} else {
	  
	  memset(&pixels[(startx-1)+this->width*(starty-1)],
		 0, (this->width)*sizeof(int)*rangey);

	}

#else

       HTaskPtr task_draw;

        while (startx < this->width) {
	  if (spack->info.size > 0) {
                // Draw SpanPack
                task_draw = manager->create_task(DrawSpan);

                task_draw->set_param(0,
                    (memaddr)&pixels[(startx-1) + this->width*(starty-1)]);
                task_draw->set_param(1,this->width);
		task_draw->set_param(2,startx);
		task_draw->set_param(3,endx);
		task_draw->set_param(4,rangey);
		task_draw->set_param(5,spack->info.size);

                task_draw->add_inData(spack, sizeof(SpanPack));

		for (int i = 0; i < rangey; i++) {
		    task_draw->add_outData(
			&pixels[(startx-1) + this->width*(starty-1 + i) ],
			(endx-startx+1)*sizeof(int));
		}

	} else {
		// 7.7.3 SL1 Data Cache Range Set to Zero コマンド
		//  を使って、DMAでclearするべき... ということは、
		// それもSPEでやる方が良い?
		  memset(&pixels[(startx-1)+this->width*(starty-1)],
		                0, (this->width)*sizeof(int)*rangey);
		  break;
	}

	    task_draw->set_cpu(SPE_ANY);
            task_next->wait_for(task_draw);
	    task_draw->wait_for(data_update_wait);
            task_draw->spawn();

            startx += split_screen_w;
            endx += split_screen_w;

            if (endx > this->width) {
                endx = this->width;
            }
        }
#endif

    } 

    data_update_wait->spawn();  

}

void
Viewer::run_finish()
{
    dev->free_device();
    if (this_time != start_time) {
        printf("%f FPS\n", (((float)frames)/(this_time-start_time))*1000.0);
    }

    delete sgroot;
//    delete sgroot_2;
    quit();
}

/* end */