#include "../la_5.h"

extern LA MAIN;
extern struct _tnsMain *T;

laBaseNodeType TNS_IDN_TRANSFORM;
laBaseNodeType TNS_IDN_MAKE_TRANSFORM;

laPropContainer* TNS_PC_IDN_TRANSFORM;
laPropContainer* TNS_PC_IDN_MAKE_TRANSFORM;

void IDN_TransformInit(tnsTransformNode* n){
    n->Mat=laCreateInSocket("mat",0); strSafeSet(&n->Base.Name,"Transform");
}
void IDN_TransformDestroy(tnsTransformNode* n){
    laDestroyInSocket(n->Mat); strSafeDestroy(&n->Base.Name);
}
int IDN_TransformVisit(tnsTransformNode* n, laListHandle* l){
    if(LA_SRC_AND_PARENT(n->Mat)){ laBaseNode*bn=n->Mat->Source->Parent; LA_VISIT_NODE(bn); }
    n->Base.Eval=LA_DAG_FLAG_PERM;
    lstAppendPointer(l, n);
    return LA_DAG_FLAG_PERM;
}
int IDN_TransformEval(tnsTransformNode* n){
    if(!n->Target) return 0;
    if((!n->Mat->Source) || (n->Mat->Source->DataType!=(LA_PROP_FLOAT|LA_PROP_ARRAY)) || (n->Mat->Source->ArrLen!=16)){
        tnsLoadIdentity44d(&n->Target->DeltaTransform); tnsSelfMatrixChanged(n->Target, 1);
    }else{
        memcpy(n->Target->DeltaTransform, n->Mat->Source->Data, sizeof(tnsMatrix44d)); tnsSelfMatrixChanged(n->Target, 1);
    }
    laNotifyInstanceUsers(n->Target);
    return 1;
}
void tnsui_TransformNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn *UNUSED, int context){
    laColumn* c=laFirstColumn(uil); tnsTransformNode*n=This->EndInstance;
    laColumn* cl,*cr; laSplitColumn(uil,c,0.3); cl=laLeftColumn(c,0); cr=laRightColumn(c,0);

    LA_BASE_NODE_HEADER(uil,c,This);

    laUiItem* b=laBeginRow(uil,cl,0,0);
    laShowNodeSocket(uil,cl,This,"mat",0);
    laEndRow(uil,b);

    laShowItem(uil,cr,This,"target");
}

void IDN_MakeTransformInit(tnsMakeTransformNode* n){
    n->Out=laCreateOutSocket(n,"mat",0); strSafeSet(&n->Base.Name,"Make Transform");
    n->Loc=laCreateInSocket("loc",0); 
    n->Rot=laCreateInSocket("rot",0);  n->Angle=laCreateInSocket("angle",0); n->UseRot[2]=1;
    n->Sca=laCreateInSocket("scale",0);  n->UseSca=1;
}
void IDN_MakeTransformDestroy(tnsMakeTransformNode* n){
    laDestroyOutSocket(n->Out); strSafeDestroy(&n->Base.Name);
    laDestroyInSocket(n->Loc);
    laDestroyInSocket(n->Rot); laDestroyInSocket(n->Angle);
    laDestroyInSocket(n->Sca);
}
int IDN_MakeTransformVisit(tnsMakeTransformNode* n, laListHandle* l){
    LA_GUARD_THIS_NODE(n);
    if(LA_SRC_AND_PARENT(n->Loc)){ laBaseNode*bn=n->Loc->Source->Parent; LA_VISIT_NODE(bn); }
    if(LA_SRC_AND_PARENT(n->Rot)){ laBaseNode*bn=n->Rot->Source->Parent; LA_VISIT_NODE(bn); }
    if(LA_SRC_AND_PARENT(n->Sca)){ laBaseNode*bn=n->Sca->Source->Parent; LA_VISIT_NODE(bn); }
    if(LA_SRC_AND_PARENT(n->Angle)){ laBaseNode*bn=n->Angle->Source->Parent;  LA_VISIT_NODE(bn); }
    n->Base.Eval=LA_DAG_FLAG_PERM; lstAppendPointer(l, n);
    return LA_DAG_FLAG_PERM;
}
int IDN_MakeTransformEval(tnsMakeTransformNode* n){
    tnsMatrix44d mm,mt,mr,ms; real* UseT,*UseR,*UseA,*UseS; tnsVector3d nr;
    if(LA_SRC_AND_PARENT(n->Loc) && n->Loc->Source->ArrLen>=3 && n->Loc->Source->DataType==LA_PROP_FLOAT|LA_PROP_ARRAY){ UseT=n->Loc->Source->Data; }else{ UseT=n->UseLoc; }
    if(LA_SRC_AND_PARENT(n->Rot) && n->Rot->Source->ArrLen>=3 && n->Rot->Source->DataType==LA_PROP_FLOAT|LA_PROP_ARRAY){ UseR=n->Rot->Source->Data; }else{ UseR=n->UseRot; }
    if(LA_SRC_AND_PARENT(n->Angle) && n->Angle->Source->DataType&LA_PROP_FLOAT){ UseA=n->Angle->Source->Data; }else{ UseA=&n->UseAngle; }
    if(LA_SRC_AND_PARENT(n->Sca) && n->Sca->Source->DataType&LA_PROP_FLOAT){ UseS=n->Sca->Source->Data; }else{ UseS=&n->UseSca; }
    tnsMakeTranslationMatrix44d(mt,LA_COLOR3(UseT));
    tnsNormalize3d(nr, UseR); tnsMakeRotationMatrix44d(mr,*UseA, LA_COLOR3(nr));
    tnsMakeScaleMatrix44d(ms,*UseS,*UseS,*UseS);
    tnsMultiply44d(mm,mt,mr); tnsMultiply44d(n->Mat,mm,ms);
    n->Out->ArrLen=16; n->Out->Data=n->Mat; n->Out->DataType=LA_PROP_FLOAT|LA_PROP_ARRAY;
    return 1;
}
void tnsui_MakeTransformNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn *UNUSED, int context){
    laColumn* c=laFirstColumn(uil); tnsMakeTransformNode*n=This->EndInstance;
    laColumn* cl,*cr; laSplitColumn(uil,c,0.3); cl=laLeftColumn(c,0); cr=laRightColumn(c,0);
    laUiItem* b2, *rui;

    LA_BASE_NODE_HEADER(uil,c,This);

    laUiItem* b=laBeginRow(uil,c,0,0);
    laShowNodeSocket(uil,c,This,"loc",0); laShowLabel(uil,c,"Loc",0,0); b2=laOnConditionThat(uil,c,laNot(laPropExpression(This,"loc.source")));{
        laShowItem(uil,c,This,"use_loc")->Expand=1;
    }laEndCondition(uil,b2);
    laEndRow(uil,b);

    b=laBeginRow(uil,c,0,0);
    laShowNodeSocket(uil,c,This,"rot",0); laShowLabel(uil,c,"Rot",0,0); b2=laOnConditionThat(uil,c,laNot(laPropExpression(This,"rot.source")));{
        laShowItem(uil,c,This,"use_rot")->Expand=1;
    }laEndCondition(uil,b2);
    laEndRow(uil,b);

    b=laBeginRow(uil,c,0,0);
    laShowNodeSocket(uil,c,This,"angle",0); laShowLabel(uil,c,"Angle",0,0); b2=laOnConditionThat(uil,c,laNot(laPropExpression(This,"angle.source")));{
        laShowItem(uil,c,This,"use_angle")->Expand=1;
    }laEndCondition(uil,b2);
    laEndRow(uil,b);

    b=laBeginRow(uil,c,0,0);
    laShowNodeSocket(uil,c,This,"sca",0); laShowLabel(uil,c,"Scale",0,0); b2=laOnConditionThat(uil,c,laNot(laPropExpression(This,"sca.source")));{
        laShowItem(uil,c,This,"use_sca")->Expand=1;
    }laEndCondition(uil,b2);
    laEndRow(uil,b);

    b=laBeginRow(uil,c,0,0);
    laShowSeparator(uil,c)->Expand=1;;
    laShowNodeSocket(uil,c,This,"out",0);
    laEndRow(uil,b);
}


int OPINV_AddDriverPage(laOperator* a, laEvent *e){
    laDriverPage* dp=memAcquire(sizeof(laDriverPage));
    strSafeSet(&dp->Name,"New Page");
    lstAppendItem(&MAIN.DriverPages, dp); MAIN.CurrentDriverPage=dp;
    laNotifyUsers("la.driver_pages");
    return LA_FINISHED;
}
int OPINV_AddDriverRack(laOperator* a, laEvent *e){
    laDriverPage* dp=a->This?a->This->EndInstance:0; if(!dp) return LA_FINISHED;
    laNodeRack* ir=memAcquire(sizeof(laNodeRack)); ir->RackType=LA_RACK_TYPE_DRIVER;
    strSafeSet(&ir->Name,"New Rack");
    lstAppendItem(&dp->Racks, ir);
    laNotifyUsers("la.driver_pages");
    return LA_FINISHED;
}

laBaseNode* la_CreateDriverNode(laNodeRack* ir, laBaseNodeType* NodeType){
    laBaseNode* bn=memAcquire(NodeType->NodeSize);
    bn->Type=NodeType; NodeType->Init(bn); lstAppendItem(&ir->Nodes, bn); bn->InRack=ir;
    laNotifyUsers("la.driver_pages");
    return bn;
}
void la_DestroyDriverNode(laBaseNode* bn){
    lstRemoveItem(bn->InRack, bn); bn->Type->Destroy(bn);
    laNotifyUsers("la.driver_pages");
    memFree(bn);
}
int OPINV_AddDriverNode(laOperator* a, laEvent *e){
    laNodeRack* ir=a->This?a->This->EndInstance:0; if(!ir) return LA_CANCELED;
    laBaseNodeType* bnt=0;

    char* type=strGetArgumentString(a->ExtraInstructionsP,"type");
    if(!type){ laEnableOperatorPanel(a,a->This,e->x,e->y,200,200,0,0,0,0,0,0,0,0,e); return LA_RUNNING; }
    elif(strSame(type, "TRANSFORM")){ la_CreateDriverNode(ir, &TNS_IDN_TRANSFORM); }
    elif(strSame(type, "MAKE_TRANSFORM")){ la_CreateDriverNode(ir, &TNS_IDN_MAKE_TRANSFORM); }
    elif(strSame(type, "VISUALIZER")){ la_CreateDriverNode(ir, &LA_IDN_VISUALIZER); }
    elif(strSame(type, "SPLIT")){ la_CreateDriverNode(ir, &LA_IDN_SPLIT); }
    elif(strSame(type, "SWITCH")){ la_CreateDriverNode(ir, &LA_IDN_SWITCH); }
    elif(strSame(type, "COMBINE")){ la_CreateDriverNode(ir, &LA_IDN_COMBINE); }
    elif(strSame(type, "VALUES")){ la_CreateDriverNode(ir, &LA_IDN_VALUES); }
    elif(strSame(type, "MATRIX")){ la_CreateDriverNode(ir, &LA_IDN_MATRIX); }
    elif(MAIN.ExtraGetDriverNodeType && (bnt=MAIN.ExtraGetDriverNodeType(type))){ la_CreateDriverNode(ir, bnt); }

    return LA_FINISHED;
}
void laui_AddDriverNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn *UNUSED, int context){
    laColumn* c=laFirstColumn(uil);
    if(MAIN.ExtraAddDriverNodes){
        MAIN.ExtraAddDriverNodes(uil,This,Extra,0,0);
    }
    laShowLabel(uil,c,"Operations:",0,0);
    laShowItemFull(uil,c,This,"add_node_driver",0,"type=SPLIT;text=Split",0,0);
    laShowItemFull(uil,c,This,"add_node_driver",0,"type=SWITCH;text=Switch",0,0);
    laShowItemFull(uil,c,This,"add_node_driver",0,"type=COMBINE;text=Combine",0,0);
    laShowItemFull(uil,c,This,"add_node_driver",0,"type=VALUES;text=Values",0,0);
    laShowLabel(uil,c,"Visualizations:",0,0);
    laShowItemFull(uil,c,This,"add_node_driver",0,"type=VISUALIZER;text=Visualizer",0,0);
    laShowLabel(uil,c,"Math:",0,0);
    laShowItemFull(uil,c,This,"add_node_driver",0,"type=MAKE_TRANSFORM;text=Make Transform",0,0);
    laShowItemFull(uil,c,This,"add_node_driver",0,"type=MATRIX;text=Matrix",0,0);
    laShowLabel(uil,c,"Drivers:",0,0);
    laShowItemFull(uil,c,This,"add_node_driver",0,"type=TRANSFORM;text=Transform Objects",0,0);
}

int OPINV_RebuildDrivers(laOperator* a, laEvent *e){
    laDriverRequestRebuild();
    return LA_FINISHED;
}


tnsObject* tnsget_FirstObject(void* unused, void* unused2){
    return T->World.AllObjects.pFirst;
}

void tns_RegisterNodes(){
    laPropContainer *pc; laProp *p;
    laOperatorType *at;
    laEnumProp *ep;

    laCreateOperatorType("LA_add_driver_page", "New Page", "Add a driver page", 0,0,0,OPINV_AddDriverPage,0,'+',0);
    laCreateOperatorType("LA_add_driver_rack", "Add Rack", "Add a rack for driver nodes", 0,0,0,OPINV_AddDriverRack,0,'+',0);
    at=laCreateOperatorType("LA_add_driver_node", "Add Node", "Add a input mapper node",0,0,0,OPINV_AddDriverNode,OPMOD_FinishOnData,'+',0);
    at->UiDefine=laui_AddDriverNode;
    laCreateOperatorType("LA_driver_rebuild", "Rebuild Drivers", "Rebuild drivers for evaluation",0,0,0,OPINV_RebuildDrivers,0,L'⭮',0);

    pc=laAddPropertyContainer("tns_transform_node", "Transform", "Transform objects",0,tnsui_TransformNode,sizeof(tnsTransformNode),0,0,1);
    TNS_PC_IDN_TRANSFORM=pc;
    laAddSubGroup(pc,"base","Base","Base node","la_base_node",0,0,0,0,0,0,0,0,0,0,0,LA_UDF_LOCAL);
    laAddSubGroup(pc,"mat", "Mat","Input matrix","la_in_socket",0,0,0,offsetof(tnsTransformNode,Mat),0,0,0,0,0,0,0,LA_UDF_SINGLE);
    laAddSubGroup(pc,"target", "Target","Target object","tns_object",0,LA_WIDGET_COLLECTION_SELECTOR,laui_IdentifierOnly,offsetof(tnsTransformNode,Target),tnsget_FirstObject,0,laget_ListNext,0,0,0,0,LA_UDF_REFER);
    
    pc=laAddPropertyContainer("tns_make_transform_node", "Make Transform", "Make Transform matrix",0,tnsui_MakeTransformNode,sizeof(tnsMakeTransformNode),0,0,1);
    TNS_PC_IDN_MAKE_TRANSFORM=pc;
    laAddSubGroup(pc,"base","Base","Base node","la_base_node",0,0,0,0,0,0,0,0,0,0,0,LA_UDF_LOCAL);
    laAddSubGroup(pc,"out", "Out","Output matrix","la_out_socket",0,0,0,offsetof(tnsMakeTransformNode,Out),0,0,0,0,0,0,0,LA_UDF_SINGLE);
    laAddSubGroup(pc,"loc", "Location","Location","la_in_socket",0,0,0,offsetof(tnsMakeTransformNode,Loc),0,0,0,0,0,0,0,LA_UDF_SINGLE);
    laAddSubGroup(pc,"rot", "Rotation","Rotation","la_in_socket",0,0,0,offsetof(tnsMakeTransformNode,Rot),0,0,0,0,0,0,0,LA_UDF_SINGLE);
    laAddSubGroup(pc,"sca", "Scale","Scale","la_in_socket",0,0,0,offsetof(tnsMakeTransformNode,Sca),0,0,0,0,0,0,0,LA_UDF_SINGLE);
    laAddSubGroup(pc,"angle", "Angle","Rotation Angle","la_in_socket",0,0,0,offsetof(tnsMakeTransformNode,Angle),0,0,0,0,0,0,0,LA_UDF_SINGLE);
    laAddFloatProperty(pc,"use_loc", "Location", "Use Location",0,"X,Y,Z",0,0,0,0.05,0,0,offsetof(tnsMakeTransformNode, UseLoc),0,0,3,0,0,0,0,0,0,0,0);
    laAddFloatProperty(pc,"use_rot", "Rotation", "Use Rotation",0,"X,Y,Z",0,0,0,0.05,0,0,offsetof(tnsMakeTransformNode, UseRot),0,0,3,0,0,0,0,0,0,0,0);
    laAddFloatProperty(pc,"use_sca", "Scale", "Use Scale",0,0,0,0,0,0.05,0,0,offsetof(tnsMakeTransformNode, UseSca),0,0,0,0,0,0,0,0,0,0,0);
    laAddFloatProperty(pc,"use_angle", "Angle", "Use Angle",0,0,0,0,0,0.05,0,0,offsetof(tnsMakeTransformNode, UseAngle),0,0,0,0,0,0,0,0,0,0,0);
    
    LA_IDN_REGISTER(TNS_IDN_TRANSFORM,TNS_PC_IDN_TRANSFORM, IDN_TransformInit, IDN_TransformDestroy, IDN_TransformVisit, IDN_TransformEval, tnsTransformNode);
    LA_IDN_REGISTER(TNS_IDN_MAKE_TRANSFORM,TNS_PC_IDN_MAKE_TRANSFORM, IDN_MakeTransformInit, IDN_MakeTransformDestroy, IDN_MakeTransformVisit, IDN_MakeTransformEval, tnsMakeTransformNode);
}

void laDriverRequestRebuild(){ MAIN.DriverNeedRebuild=1; }
void laDriverRequestEval(){ MAIN.DriverNeedEval=1; }

int la_RunDrivers(){
    MAIN.MappingNeedEval = 0;
    for(laListItemPointer*lip=MAIN.DriverEval.pFirst;lip;lip=lip->pNext){
        laBaseNode* n=lip->p; n->Type->Eval(n);
    }
    return 1;
}
int la_RebuildDriverEval(){
    MAIN.MappingNeedRebuild = 0;
    while(lstPopPointer(&MAIN.DriverEval));
    laListHandle pending={0};
    for(laDriverPage* dp=MAIN.DriverPages.pFirst;dp;dp=dp->Item.pNext){
        for(laNodeRack* ir=dp->Racks.pFirst;ir;ir=ir->Item.pNext){
            for(laBaseNode*bn=ir->Nodes.pFirst;bn;bn=bn->Item.pNext){ lstAppendPointer(&pending,bn); bn->Eval=0; }
        }
    }
    laBaseNode*n;int result=LA_DAG_FLAG_PERM; laListItemPointer*NextLip;
    for(laListItemPointer*lip=pending.pFirst;lip;lip=NextLip){ n=lip->p; NextLip=lip->pNext;
        if(n->Eval&LA_DAG_FLAG_PERM) continue;
        result=n->Type->Visit(n,&MAIN.DriverEval); if(result==LA_DAG_FLAG_ERR){ while(lstPopPointer(&pending)); break; }
    }
    if(result==LA_DAG_FLAG_ERR){ while(lstPopPointer(&MAIN.DriverEval)); return LA_DAG_FLAG_ERR; }
    return LA_DAG_FLAG_PERM;
}