#include <iostream>
#include <math.h>
#include "SceneGraphRoot.h"
#include "SceneGraph.h"
#include "TaskManager.h"
#include "Func.h"
#include "Chain.h"
#include "Application.h"
#define FALSE 0
#define TRUE !FALSE
#define CHAIN_LEN 50

static double chain_width = 10;
static void post2propertyLoop(void *chain);

/* SceneGraph の property */
//ChainPropertyPtr c_properties[2];
//ChainPropertyPtr c_property;


//void createSceneGraphFromProperty(ChainPropertyPtr p) ;
void createSceneGraphFromProperty(void* p) ;

void
Chain::init_chain_vars(ChainPropertyPtr cv) {
    cv->x = 0, cv->y = 0, cv->next_x = 0, cv->next_y = 0;
    cv->vx = 0, cv->vy = 0, cv->next_vx = 0, cv->next_vy = 0;
    cv->can_move = TRUE;
}

void
set_vector(ChainPropertyPtr p, SceneGraphPtr sg) {
    sg->xyz[0] = p->next_x;
    sg->xyz[1] = p->next_y;
    sg->xyz[2] = 0.0f;
    sg->angle[0] = p->angle[0];
    sg->angle[1] = p->angle[1];
    sg->angle[2] = p->angle[2];
}

#if 0
static void
chain_move_ope(SceneGraphPtr node, int screen_w, int screen_h)
{
    Pad *pad = sgroot->getController();

    if (pad->circle.isHold()) {
        property[CHAIN_LEN-1].can_move = FALSE;
        if (pad->left.isHold()) {
            property[CHAIN_LEN-1].x += -5.0;
        } else if (pad->right.isHold()) {
            property[CHAIN_LEN-1].x += 5.0;
        }

        if (pad->up.isHold()) {
            property[CHAIN_LEN-1].y += -5.0;
        } else if (pad->down.isHold()) {
            property[CHAIN_LEN-1].y += 5.0;
        }
    } else {
        property[CHAIN_LEN-1].can_move = TRUE;
    }
}
#endif

void
Chain::chain_switch()
{
    HTaskPtr chain_cal;
    ChainPropertyPtr output;

    // SceneGraph の切り替えもここでやる
    if (property == properties[0]) {
	property = (ChainPropertyPtr)properties[1];
	output   = (ChainPropertyPtr)properties[0];

    }else{
	property = (ChainPropertyPtr)properties[0];
	output   = (ChainPropertyPtr)properties[1];
    }

    chain_cal = manager->create_task(CHAINCAL_TASK);
    chain_cal->add_inData(property, sizeof(ChainProperty)*CHAIN_LEN);
    chain_cal->add_outData(output, sizeof(ChainProperty)*CHAIN_LEN);
    chain_cal->set_post(post2propertyLoop, (void *)sg_available_list);
    chain_cal->spawn();
}

void
Chain::chain_collision(SceneGraphPtr sg, int w, int h, SceneGraphPtr osg)
{

}

void 
createSceneGraphFromProperty(void* p)
{
    ChainPropertyPtr chain_p = (ChainPropertyPtr)p;
    SceneGraphPtr chain_copy = sgroot->createSceneGraph("CHAIN");
    chain_copy->propertyptr = (void*)chain_p;
    chain_copy->property_size = sizeof(ChainProperty);
    set_vector(chain_p, chain_copy);
    chain_p->parent->addChild(chain_copy);
}

void
Chain::apply_property(void *p, SceneGraphPtr sgptr)
{
    ChainPropertyPtr cp = (ChainPropertyPtr)p;
    
    sgptr->xyz[0] = cp->xyz[0];
    sgptr->xyz[1] = cp->xyz[1];
    sgptr->xyz[2] = cp->xyz[2];

    sgptr->angle[0] = cp->angle[0];
    sgptr->angle[1] = cp->angle[1];
    sgptr->angle[2] = cp->angle[2];
    
    cp->frame++;
    sgptr->frame = cp->frame;
}

SceneGraphPtr
Chain::scenegraph_factory(void *p)
{
    ChainPropertyPtr cp = (ChainPropertyPtr)p;
    SceneGraphPtr sgptr =  (SceneGraphPtr)cp->scenegraph;
    apply_property(p, sgptr);
    
    return sgptr;
}

void
Chain::scenegraph_connector(void *p, SceneGraphPtr sg)
{
    ChainPropertyPtr cp = (ChainPropertyPtr)p;
    SceneGraphPtr last = sg_available_list;

    if (!last) {
	sg_available_list = sg;
    } else {
	while (last->next) {
	    last = last->next;
	}
	last->next = sg;
	sg->prev = last;
    }

    ChainPropertyPtr p_curent = (ChainPropertyPtr)sg->propertyptr;

    // parent_id が 0 , NULL だったらどうすんだ？
    // そこで試合終了じゃね？
    // if ( p_curent_id->parent_id == 0) return -1;
    ChainProperty p_parent = cp[p_curent->parent_id];
    SceneGraphPtr s_parent = (SceneGraphPtr)p_parent.scenegraph;

    /* childrenのリストの最後に加える (brother として)*/
    if (s_parent->lastChild != NULL) {
        SceneGraphPtr last_child = s_parent->lastChild;
        last_child->brother = sg;
    }

    s_parent->lastChild = sg;

    if (s_parent->children == NULL) {
        s_parent->children = sg;
    }

    sg->parent = s_parent;
}

int
is_end(ChainPropertyPtr t)
{
    // どうやって終了させよう？
    // property の個数を保持する必要がある？
    // or for文ではなくて、条件にする 

    return 0;
}

void
Chain::property_loop()
{
    for (ChainPropertyPtr t = &property[0]; is_end(t); t++){
	SceneGraphPtr sg = scenegraph_factory(t); // SceneGraphNode を作る
	t->scenegraph = (void *)sg; // property list には SceneGraphへのポインタが入っている
	scenegraph_connector((void *)properties[0], sg); // add する
    }
}

void
post2propertyLoop(void *chain_)
{
    Application *chain = (Application *)chain_;
    //chain->property_loop(chain->sg_available_list);
    chain->property_loop();
}

void
Chain::property_ope(SceneGraphPtr sg_available_list_)
{
    sg_available_list = sg_available_list_;
    chain_switch();
}

void
Chain::init(TaskManager *manager_, int w, int h)
{
    SceneGraphPtr root_chain, chain;
    //ChainProperty r;
    manager = manager_;
    // 未実装
    char *data = {"1"};
    int len = 0;
    sgroot->createFromXMLfile(manager, "xml_file/chain.xml");

    /* SPE に送る property の配列の領域確保 */
    properties[0] = (ChainPropertyPtr)manager->allocate(sizeof(ChainProperty)*CHAIN_LEN);
    properties[1] = (ChainPropertyPtr)manager->allocate(sizeof(ChainProperty)*CHAIN_LEN);
    property = properties[0];

    root_chain = sgroot->createSceneGraph("CHAIN");
    init_chain_vars(&property[0]);
    property[0].next_x = w / 2;
    property[0].next_y = 0.0;
    property[0].angle[0] = 0;
    property[0].angle[1] = 0;
    property[0].angle[2] = 0;

    set_vector(&property[0], root_chain);

    for(int i = 1; i < CHAIN_LEN; i++) {
        chain = sgroot->createSceneGraph("CHAIN");
	property[i].id = i;
        init_chain_vars(&property[i]);
        property[i].x = 0;
        property[i].y = chain_width * i;
        set_vector(&property[i], chain);
        property[i].angle[1] = -90 * (i % 2);        
	chain->propertyptr = &property[i];
	chain->property_size = sizeof(ChainProperty);
        root_chain->addChild(chain);
	property[i].parent = root_chain;
	property[i].parent_id = 0;
    }
    property[0].can_move = FALSE;

    sgroot->setSceneData(root_chain);
}