#include "../la_5.h"

extern LA MAIN;
extern struct _tnsMain *T;


laInputMapperNodeType LA_IDN_KEYBOARD;
laInputMapperNodeType LA_IDN_MOUSE;
laInputMapperNodeType LA_IDN_CONTROLLER;
laInputMapperNodeType LA_IDN_VISUALIZER;

laPropContainer* LA_PC_IDN_GENERIC;
laPropContainer* LA_PC_IDN_KEYBOARD;
laPropContainer* LA_PC_IDN_MOUSE;
laPropContainer* LA_PC_IDN_CONTROLLER;
laPropContainer* LA_PC_IDN_VISUALIZER;

#define LA_IDN_CONTROLLER_RESET_SOCKET(ns)\
    {ns->IntVal[0]=0; ns->Out->DataType=LA_PROP_INT; ns->Offset=0; ns->Out->Data=&ns->IntVal;}

void IDN_ControllerInit(laInputControllerNode* n){
    for(int i=0;i<8;i++){ n->Sockets[i].Out=laCreateOutSocket(n, "out", 0); n->Sockets[i].Parent=n; }
    strSafeSet(&n->Base.Name,"Controller Output");
}
void IDN_ControllerDestroy(laInputControllerNode* n){
    for(int i=0;i<8;i++){ laDestroyOutSocket(n->Sockets[i].Out); }
    strSafeDestroy(&n->Base.Name);
}
int IDN_ControllerVisit(laInputControllerNode* n, laListHandle* l){
    laController* c=la_FindControllerWithID(n->UserID);
    if(!c){ for(int i=0;i<8;i++){ laInputControllerNodeSocket* ns=&n->Sockets[i]; LA_IDN_CONTROLLER_RESET_SOCKET(ns); } return LA_DAG_FLAG_PERM; }
    else{
        for(int i=0;i<8;i++){ laInputControllerNodeSocket* ns=&n->Sockets[i];
            if(!ns->Which || !ns->Which->Ptr){ LA_IDN_CONTROLLER_RESET_SOCKET(ns); continue; }
            laPropContainer*pc=la_EnsureSubTarget(LA_PROP_CONTROLLER, c);
            laProp* p=la_PropLookup(&pc->Props, n->Sockets[i].Which->Ptr);
            if((!p)||(!p->Offset)||
                ((p->PropertyType!=LA_PROP_INT)&&(p->PropertyType!=LA_PROP_ENUM)&&
                 (p->PropertyType!=(LA_PROP_INT|LA_PROP_ARRAY))&&(p->PropertyType!=(LA_PROP_ENUM|LA_PROP_ARRAY)))){ LA_IDN_CONTROLLER_RESET_SOCKET(ns); continue; }
            if(p->PropertyType==LA_PROP_INT){ ns->Out->DataType=LA_PROP_FLOAT; ns->Out->Data=&ns->RealVal; ns->Out->ArrLen=1; }
            elif(p->PropertyType==(LA_PROP_INT|LA_PROP_ARRAY)){ ns->Out->DataType=(LA_PROP_FLOAT|LA_PROP_ARRAY); ns->Out->Data=&ns->RealVal; ns->Out->ArrLen=p->Len; }
            elif(p->PropertyType==LA_PROP_ENUM){ ns->Out->DataType=LA_PROP_ENUM; ns->Out->Data=&ns->IntVal; ns->Out->ArrLen=1; }
            elif(p->PropertyType==(LA_PROP_ENUM|LA_PROP_ARRAY)){ ns->Out->DataType=(LA_PROP_ENUM|LA_PROP_ARRAY); ns->Out->Data=&ns->IntVal; ns->Out->ArrLen=p->Len; }
            ns->Offset=p->Offset;
        }
    }
    n->Base.Eval=LA_DAG_FLAG_PERM;
    lstAppendPointer(l, n);
    return LA_DAG_FLAG_PERM;
}
int IDN_ControllerEval(laInputControllerNode* n){
    laNotifyInstanceUsers(n);
    laController* c=la_FindControllerWithID(n->UserID); if(!c){ 
        for(int i=0;i<8;i++){ laInputControllerNodeSocket* ns=&n->Sockets[i]; LA_IDN_CONTROLLER_RESET_SOCKET(ns); } return 1;
    }
    for(int i=0;i<8;i++){ laInputControllerNodeSocket* ns=&n->Sockets[i]; 
        int *addr=((char*)c)+ns->Offset; char* addc=addr;
        if(ns->Out->DataType==LA_PROP_FLOAT){ ns->RealVal[0]=(real)(*addr)/32767.0; }
        if(ns->Out->DataType==(LA_PROP_FLOAT|LA_PROP_ARRAY)){ for(int a=0;a<ns->Out->ArrLen;a++) ns->RealVal[a]=((real)addr[a])/32767.0; }
        elif(ns->Out->DataType==LA_PROP_ENUM){ ns->IntVal[0]=(*addc); }
        elif(ns->Out->DataType==(LA_PROP_ENUM|LA_PROP_ARRAY)){ for(int a=0;a<ns->Out->ArrLen;a++) ns->IntVal[a]=addc[a]; }
    }
    return 1;
}
void laui_ControllerNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn *UNUSED, int context){
    laColumn* c=laFirstColumn(uil); laInputControllerNode*n=This->EndInstance;
    laColumn* cl,*cr; laSplitColumn(uil,c,0.4); cl=laLeftColumn(c,0); cr=laRightColumn(c,0);

    laUiItem* b=laBeginRow(uil,c,0,0);
    laShowHeightAdjuster(uil,c,This,"base.__gap",0);
    laShowItem(uil,c,This,"base.name")->Expand=1;
    laShowItem(uil,c,This,"user_id");
    laEndRow(uil,b);

    char* buf[128],buf2[128];
    for(int i=0;i<8;i++){
        sprintf(buf,"out%d.which",i); laShowItem(uil,cl,This,buf);
        laUiItem* b=laBeginRow(uil,cr,0,0);
        sprintf(buf2,"out%d.out.data_type",i);
        laUiItem* b2=laOnConditionThat(uil,cr,laEqual(laPropExpression(This,buf2),laIntExpression(LA_PROP_FLOAT)));{
            sprintf(buf,"out%d.axis",i); laShowItem(uil,cr,This,buf)->Expand=1;
        }laElse(uil,b2);{
            laUiItem* b3=laOnConditionThat(uil,cr,laEqual(laPropExpression(This,buf2),laIntExpression(LA_PROP_FLOAT|LA_PROP_ARRAY)));{
                sprintf(buf,"out%d.axis2d",i); laUiItem* aui=laShowItem(uil,cr,This,buf);aui->Expand=1;aui->Flags|=LA_UI_FLAGS_TRANSPOSE;aui->Extra->HeightCoeff=1;
            }laElse(uil,b3);{
                sprintf(buf,"out%d.switch",i); laUiItem* sui=laShowItem(uil,cr,This,buf);sui->Expand=1;sui->Flags|=LA_UI_FLAGS_TRANSPOSE;
            }laEndCondition(uil,b3);
        }laEndCondition(uil,b2);
        sprintf(buf,"out%d.out",i); laShowNodeSocket(uil,cr,This,buf,0);
        laEndRow(uil,b);
    }
}

void IDN_InputVisualizeInit(laInputVisualizerNode* n){
    n->In=laCreateInSocket("in", 0);
    strSafeSet(&n->Base.Name,"Input Visualizer");
}
void IDN_InputVisualizeDestroy(laInputVisualizerNode* n){
    laDestroyInSocket(n->In);
    strSafeDestroy(&n->Base.Name);
}
int IDN_InputVisualizeVisit(laInputVisualizerNode* n, laListHandle* l){
    n->Base.Eval=LA_DAG_FLAG_TEMP;
    if(n->In->Source){ int result;
        laInputMapperNode* sn=n->In->Source->Parent; result=sn->Type->Visit(sn,l); if(result==LA_DAG_FLAG_TEMP) return LA_DAG_FLAG_ERR;
    }
    n->Base.Eval=LA_DAG_FLAG_PERM;
    lstAppendPointer(l, n);
    return LA_DAG_FLAG_PERM;
}
int IDN_InputVisualizerEval(laInputVisualizerNode* n){
    if(!n->In->Source) return 0;
    laNodeOutSocket* os=n->In->Source; int arrlen=1;
    switch(os->DataType){
    case LA_PROP_FLOAT|LA_PROP_ARRAY:
    case LA_PROP_FLOAT: if(os->ArrLen)arrlen=os->ArrLen; memcpy(n->RealVal,os->Data,sizeof(real)*arrlen); n->In->ArrLen=arrlen; break;
    case LA_PROP_ENUM|LA_PROP_ARRAY:
    case LA_PROP_ENUM: if(os->ArrLen)arrlen=os->ArrLen; memcpy(n->IntVal,os->Data,sizeof(int)*arrlen); n->In->ArrLen=arrlen; break;
    default: n->IntVal[0]=0; n->In->ArrLen=1; break;
    }
    n->In->DataType=os->DataType;
    laNotifyInstanceUsers(n);
    return 1;
}
void laui_InputVisualizeNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn *UNUSED, int context){
    laColumn* c=laFirstColumn(uil); laInputControllerNode*n=This->EndInstance;
    laColumn* cl,*cr; laSplitColumn(uil,c,0.4); cl=laLeftColumn(c,1); cr=laRightColumn(c,0);

    laUiItem* b=laBeginRow(uil,c,0,0);
    laShowHeightAdjuster(uil,c,This,"base.__gap",0);
    laShowItem(uil,c,This,"base.name");
    laEndRow(uil,b);

    laShowNodeSocket(uil,cl,This,"in",0);
    laUiItem* b2=laOnConditionThat(uil,cr,laEqual(laPropExpression(This,"in.data_type"),laIntExpression(LA_PROP_FLOAT)));{
        laShowItem(uil,cr,This,"axis");
    }laElse(uil,b2);{
        laUiItem* b3=laOnConditionThat(uil,cr,laEqual(laPropExpression(This,"in.data_type"),laIntExpression(LA_PROP_FLOAT|LA_PROP_ARRAY)));{
            laUiItem* aui=laShowItem(uil,cr,This,"axis2d");
        }laElse(uil,b3);{
            laUiItem* sui=laShowItem(uil,cr,This,"switch");
        }laEndCondition(uil,b3);
    }laEndCondition(uil,b2);
}

int OPINV_AddInputMapperRack(laOperator* a, laEvent *e){
    laInputRack* pivot=a->This?a->This->EndInstance:0;
    laInputRack* ir=memAcquire(sizeof(laInputRack));

    if(strSame(strGetArgumentString(a->ExtraInstructionsP,"before"),"true")){
        if(pivot){ lstInsertItemBefore(&MAIN.InputMappingRacks,ir,pivot); }else{ lstPushItem(&MAIN.InputMappingRacks,ir); }
    }else { if(pivot){ lstInsertItemAfter(&MAIN.InputMappingRacks,ir,pivot); }else{ lstAppendItem(&MAIN.InputMappingRacks,ir); } }
    laNotifyUsers("la.input_racks");
    
    return LA_FINISHED;
}

laInputMapperNode* la_CreateInputMapperNode(laInputRack* ir, laInputMapperNodeType* NodeType){
    laInputMapperNode* imn=memAcquire(NodeType->NodeSize);
    imn->Type=NodeType; NodeType->Init(imn); lstAppendItem(&ir->Nodes, imn); imn->InRack=ir;
    laNotifyUsers("la.input_racks");
    return imn;
}
void la_DestroyInputMapperNode(laInputMapperNode* imn){
    lstRemoveItem(imn->InRack, imn); imn->Type->Destroy(imn);
    laNotifyUsers("la.input_racks");
    memFree(imn);
}

int OPINV_AddInputMapperNode(laOperator* a, laEvent *e){
    laInputRack* ir=a->This?a->This->EndInstance:0; if(!ir) return LA_CANCELED;

    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, "KEYBOARD")){}
    elif(strSame(type, "MOUSE")){}
    elif(strSame(type, "CONTROLLER")){ la_CreateInputMapperNode(ir, &LA_IDN_CONTROLLER); }
    elif(strSame(type, "VISUALIZER")){ la_CreateInputMapperNode(ir, &LA_IDN_VISUALIZER); }

    return LA_FINISHED;
}
void laui_AddInputMapperNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn *UNUSED, int context){
    laColumn* c=laFirstColumn(uil);
    laShowItemFull(uil,c,This,"add_node",0,"type=KEYBOARD;text=Keyboard",0,0);
    laShowItemFull(uil,c,This,"add_node",0,"type=MOUSE;text=Mouse",0,0);
    laShowItemFull(uil,c,This,"add_node",0,"type=CONTROLLER;text=Controller",0,0);
    laShowSeparator(uil,c);
    laShowItemFull(uil,c,This,"add_node",0,"type=VISUALIZER;text=Visualizer",0,0);
}

laPropContainer* laget_InputNodeType(laInputMapperNode* imn){
    if(imn->Type==&LA_IDN_CONTROLLER) return LA_PC_IDN_CONTROLLER;
    if(imn->Type==&LA_IDN_VISUALIZER) return LA_PC_IDN_VISUALIZER;
    return LA_PC_IDN_GENERIC;
}
int laget_InputNodeGap(laInputRack* rack_unused, laInputMapperNode* n){
    return n->Gap;
}
void laset_InputNodeGap(laInputMapperNode* n, int gap){
    if(gap<0){
        int done=0;
        laInputMapperNode* nn=n; while(nn){ if(nn->Gap>0){ nn->Gap--; done=1; break; } nn=nn->Item.pPrev; }
        if(done){ nn=n->Item.pNext; while(nn){ if(nn->Gap>0){ nn->Gap++; break; } nn=nn->Item.pNext; } }
    }
    if(gap>0){
        n->Gap+=gap;
        laInputMapperNode* nn=n->Item.pNext; while(nn){ if(nn->Gap>0){ nn->Gap--; break; } nn=nn->Item.pNext; }
    }
}
void laset_InputNodeUserID(laInputControllerNode* n, int i){
    laNotifyUsers("la.input_racks");
}
void laset_InputControllerNodeSocketWhich(laInputControllerNodeSocket* s, char* str){
    strSafeSet(&s->Which, str);
    laNotifyUsers("la.input_racks"); laMappingRequestRebuild();
}
int laget_SocketEnumArrayLength(laInputControllerNodeSocket* s){
    return s->Out->ArrLen?s->Out->ArrLen:1;
}
int laget_VisualizerArrayLength(laInputVisualizerNode* s){
    return s->In->ArrLen?s->In->ArrLen:1;
}

#define LA_IDN_REGISTER(a,init,destroy,visit,eval,type)\
    {a.Init = init; a.Destroy = destroy; a.Visit=visit; a.Eval=eval; a.NodeSize=sizeof(type);}

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

    LA_IDN_REGISTER(LA_IDN_CONTROLLER, IDN_ControllerInit, IDN_ControllerDestroy, IDN_ControllerVisit, IDN_ControllerEval, laInputControllerNode);
    LA_IDN_REGISTER(LA_IDN_VISUALIZER, IDN_InputVisualizeInit, IDN_InputVisualizeDestroy, IDN_InputVisualizeVisit, IDN_InputVisualizerEval, laInputVisualizerNode);

    laCreateOperatorType("LA_add_input_mapper_rack", "Add Rack", "Add a rack for input mapper nodes", 0,0,0,OPINV_AddInputMapperRack,0,'+',0);
    at=laCreateOperatorType("LA_add_input_mapper_node", "Add Node", "Add a input mapper node",0,0,0,OPINV_AddInputMapperNode,OPMOD_FinishOnData,'+',0);
    at->UiDefine=laui_AddInputMapperNode;

    pc=laAddPropertyContainer("la_input_rack", "Input Rack", "Input rack for putting input mapping nodes",0,0,sizeof(laInputRack),0,0,1);
    laAddStringProperty(pc,"name","Name","Name of this rack",0,0,0,0,1,offsetof(laInputRack,Name),0,0,0,0,LA_AS_IDENTIFIER);
    p=laAddSubGroup(pc,"nodes","Nodes","Nodes under this rack","la_input_node",laget_InputNodeType,0,0,-1,0,0,0,0,0,0,offsetof(laInputRack,Nodes),0);
    laSubGroupExtraFunctions(p,0,0,laget_InputNodeGap);
    laAddOperatorProperty(pc,"add_node","Add Node","Add a node into this rack","LA_add_input_mapper_node",'+',0);

    pc=laAddPropertyContainer("la_input_node", "Input Node", "Input logic node",0,0,sizeof(laInputMapperNode),0,0,1);
    LA_PC_IDN_GENERIC=pc;
    laAddStringProperty(pc,"name","Name","Name of this input node",0,0,0,0,1,offsetof(laInputMapperNode,Name),0,0,0,0,LA_AS_IDENTIFIER);
    laAddIntProperty(pc,"__gap", "Gap", "Gap of the node", 0,0,0,0,0,0,0,0,offsetof(laInputMapperNode,Gap),0,laset_InputNodeGap,0,0,0,0,0,0,0,0,0);

    pc=laAddPropertyContainer("la_input_controller_node", "Controller output", "Output controller values",0,laui_ControllerNode,sizeof(laInputControllerNode),0,0,1);
    LA_PC_IDN_CONTROLLER=pc;
    laAddSubGroup(pc,"base","Base","Base node","la_input_node",0,0,0,0,0,0,0,0,0,0,0,LA_UDF_LOCAL);
    laAddIntProperty(pc,"user_id", "User ID", "Which controller should the data come from", 0,0,0,0,0,0,0,0,offsetof(laInputControllerNode,UserID),0,0,0,0,0,0,0,0,0,0,0);
    laAddSubGroup(pc,"out0","Out 0","Output 0","la_input_controller_node_socket",0,0,0,offsetof(laInputControllerNode, Sockets[0]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
    laAddSubGroup(pc,"out1","Out 1","Output 1","la_input_controller_node_socket",0,0,0,offsetof(laInputControllerNode, Sockets[1]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
    laAddSubGroup(pc,"out2","Out 2","Output 2","la_input_controller_node_socket",0,0,0,offsetof(laInputControllerNode, Sockets[2]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
    laAddSubGroup(pc,"out3","Out 3","Output 3","la_input_controller_node_socket",0,0,0,offsetof(laInputControllerNode, Sockets[3]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
    laAddSubGroup(pc,"out4","Out 4","Output 4","la_input_controller_node_socket",0,0,0,offsetof(laInputControllerNode, Sockets[4]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
    laAddSubGroup(pc,"out5","Out 5","Output 5","la_input_controller_node_socket",0,0,0,offsetof(laInputControllerNode, Sockets[5]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
    laAddSubGroup(pc,"out6","Out 6","Output 6","la_input_controller_node_socket",0,0,0,offsetof(laInputControllerNode, Sockets[6]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
    laAddSubGroup(pc,"out7","Out 7","Output 7","la_input_controller_node_socket",0,0,0,offsetof(laInputControllerNode, Sockets[7]),0,0,0,0,0,0,0,LA_UDF_LOCAL);

    pc=laAddPropertyContainer("la_input_controller_node_socket", "Controller Socket", "One value from a controller output",0,0,sizeof(laInputControllerNodeSocket),0,0,1|LA_PROP_OTHER_ALLOC);
    laAddStringProperty(pc,"which","Which","Select which output from the controller",0,0,0,0,1,offsetof(laInputControllerNodeSocket,Which),0,0,laset_InputControllerNodeSocketWhich,0,LA_AS_IDENTIFIER);
    laAddFloatProperty(pc,"axis", "🡘", "Axis value", LA_WIDGET_VALUE_METER,0,0,1,-1,0,0,0,offsetof(laInputControllerNodeSocket,RealVal),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
    laAddFloatProperty(pc,"axis2d", "2D Axis", "2D Axis value", LA_WIDGET_VALUE_METER,0,0,1,-1,0,0,0,offsetof(laInputControllerNodeSocket,RealVal),0,0,2,0,0,0,0,0,0,0,LA_READ_ONLY);
    p=laAddEnumProperty(pc,"switch", "SW", "Switch value", LA_WIDGET_ENUM_HIGHLIGHT,0,0,0,0,offsetof(laInputControllerNodeSocket,IntVal),0,0,0,laget_SocketEnumArrayLength,0,0,0,0,0,LA_READ_ONLY);
    laAddEnumItemAs(p,"IDLE", "Idle", "Button is not pressed", 0, 0);
    laAddEnumItemAs(p,"ACTIVE", "Active", "Button is pressed", 1, 0);
    laAddSubGroup(pc, "out", "Out","Output value","la_out_socket",0,0,0,offsetof(laInputControllerNodeSocket,Out),0,0,0,0,0,0,0,LA_UDF_SINGLE);

    pc=laAddPropertyContainer("la_input_visualizer_node", "Visualizer", "Visualizer node",0,laui_InputVisualizeNode,sizeof(laInputVisualizerNode),0,0,1);
    LA_PC_IDN_VISUALIZER=pc;
    laAddSubGroup(pc,"base","Base","Base node","la_input_node",0,0,0,0,0,0,0,0,0,0,0,LA_UDF_LOCAL);
    laAddSubGroup(pc, "in", "In","Input value","la_in_socket",0,0,0,offsetof(laInputVisualizerNode,In),0,0,0,0,0,0,0,LA_UDF_SINGLE);
    laAddFloatProperty(pc,"axis", "🡘", "Axis value", LA_WIDGET_VALUE_METER,0,0,1,-1,0,0,0,offsetof(laInputVisualizerNode,RealVal),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
    laAddFloatProperty(pc,"axis2d", "2D Axis", "2D Axis value", LA_WIDGET_VALUE_METER_2D,0,0,1,-1,0,0,0,offsetof(laInputVisualizerNode,RealVal),0,0,2,0,0,0,0,0,0,0,LA_READ_ONLY);
    p=laAddEnumProperty(pc,"switch", "SW", "Switch value", LA_WIDGET_ENUM_HIGHLIGHT,0,0,0,0,offsetof(laInputVisualizerNode,IntVal),0,0,0,laget_VisualizerArrayLength,0,0,0,0,0,LA_READ_ONLY);
    laAddEnumItemAs(p,"IDLE", "Idle", "Button is not pressed", 0, 0);
    laAddEnumItemAs(p,"ACTIVE", "Active", "Button is pressed", 1, 0);
}



void laMappingRequestRebuild(){ MAIN.MappingNeedRebuild=1; }
void laMappingRequestEval(){ MAIN.MappingNeedEval=1; }

int la_RunInputMapping(){
    MAIN.MappingNeedEval = 0;
    for(laListItemPointer*lip=MAIN.InputMappingEval.pFirst;lip;lip=lip->pNext){
        laInputMapperNode* n=lip->p; n->Type->Eval(n);
    }
    return 1;
}
int la_RebuildInputMapping(){
    MAIN.MappingNeedRebuild = 0;
    while(lstPopPointer(&MAIN.InputMappingEval));
    laListHandle pending={0};
    for(laInputRack* ir=MAIN.InputMappingRacks.pFirst;ir;ir=ir->Item.pNext){
        for(laInputMapperNode*imn=ir->Nodes.pFirst;imn;imn=imn->Item.pNext){ lstAppendPointer(&pending,imn); imn->Eval=0; }
    }
    laInputMapperNode*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.InputMappingEval); if(result==LA_DAG_FLAG_ERR){ while(lstPopPointer(&pending)); break; }
    }
    if(result==LA_DAG_FLAG_ERR){ while(lstPopPointer(&MAIN.InputMappingEval)); return LA_DAG_FLAG_ERR; }
    return LA_DAG_FLAG_PERM;
}