/**
 *  This is the new Hipadaba based queuing system in support of the MountainGum 
 *  user interface. 
 * 
 *  copyright: see file COPYRIGHT
 * 
 *  Mark Koennecke, July 2007
 */
#include <stdlib.h>
#include <assert.h> 
#include <sics.h>
#include "sicsobj.h"
#include "hdbqueue.h"
#include "sicshipadaba.h"
#include "dynstring.h"
#include "exeman.h"
#include "macro.h"
/*--------------------------------------------------------------------------*/
typedef struct {
        int iStop;
        int isRunning;
        SConnection *pCon;
}HdbQueue, *pHdbQueue;
/*--------------------------------------------------------------------------*/
static pHdbCallback CopyCallbackChain(pHdbCallback source){
    pHdbCallback current = NULL;
    pHdbCallback result = NULL;
    pHdbCallback head = NULL;
    pHdbCallback tail = NULL;
     
    current = source;
    while(current != NULL){
        result = MakeHipadabaCallback(current->userCallback,
            current->userData,
            NULL,
            current->id,
            current->internalID);
        if(head == NULL){
            head = result;
            tail = result;
        } else {
            tail->next = result;
            result->previous = tail;
            tail = result;            
        }    
        current = current->next;
    }
    return head;
}
/*---------------------------------------------------------------------------*/
static pHdb MakeNewEntry(char *name, pHdbCallback update){
    pHdb entry = NULL, child = NULL;
    hdbValue v;

    v = MakeHdbText("Undefined");    
    entry = MakeHipadabaNode(name,HIPNONE, 1);
    entry->updateCallbacks = CopyCallbackChain(update);
    child = MakeSICSHdbPar("description",usUser,v);
    child->updateCallbacks = CopyCallbackChain(update);
    AddHipadabaChild(entry,child,NULL);
    child = MakeSICSHdbPar("commands",usUser,v);
    child->updateCallbacks = CopyCallbackChain(update);
    AddHipadabaChild(entry,child,NULL);
    child = MakeSICSHdbPar("log",usUser,v);
    child->updateCallbacks = CopyCallbackChain(update);
    AddHipadabaChild(entry,child,NULL);
    
    return entry;
}
/*---------------------------------------------------------------------------*/
static int EnqueFunc(pSICSOBJ self, SConnection *pCon, Hdb commandNode,
    pHdb par[], int nPar){
   pHdb entry = NULL;
   pHdb work = NULL;
   char name[80];
   hdbValue v;
   
   if(nPar < 1){
    SCWrite(pCon,"ERROR: internal: not enough parameters to EnqueFunc",eError);
    return 0;
   }
   
   /*
    * new entry
    */
   memset(&v,0,sizeof(hdbValue));
   work = GetHipadabaNode(self->objectNode,"control/maxEntry");
   assert(work != NULL);
   snprintf(name,80,"%3.3d", work->value.v.intValue);
   entry = MakeNewEntry(name, work->updateCallbacks);
   if(entry == NULL){
        SCWrite(pCon,"ERROR: out of memory in EnqueFunc",eError);
        return 0;
   }
   /*
    * Update maxEntry
    */
   cloneHdbValue(&work->value,&v);
   v.v.intValue++;
   UpdateHipadabaPar(work,v,pCon);
   
   work = GetHipadabaNode(self->objectNode,"queue");
   assert(work != NULL);
   AddHipadabaChild(work, entry, pCon);
 
   /*
    * save description
    */
   work = GetHipadabaNode(entry,"description");
   assert(work != NULL);
   UpdateHipadabaPar(work,par[0]->value,pCon);

    
   return 1; 
}
/*---------------------------------------------------------------------------*/
static int AddCmdData(pSICSOBJ self, SConnection *pCon, Hdb comNode,
    pHdb par[], int nPar){
    pHdb work = NULL;
    pHdb commandNode = NULL;
    char name[80];
    pDynString txt = NULL;
    
    if(nPar < 1){
        SCWrite(pCon,"ERROR: internal: not enough parameters to AddCmdData",eError);
        return 0;
    }    

    work = GetHipadabaNode(self->objectNode,"control/maxEntry");
    assert(work != NULL);
    snprintf(name,80,"queue/%3.3d/commands", work->value.v.intValue-1);
    commandNode =  GetHipadabaNode(self->objectNode,name);
    if(commandNode == NULL){
        SCWrite(pCon,"ERROR: Internal error in AddCommand",eError);
        return 0;
    }
    txt = CreateDynString(80,80);
    if(strstr(commandNode->value.v.text,"Undefined") == NULL){
        DynStringCopy(txt,commandNode->value.v.text);
    }
    DynStringConcat(txt,par[0]->value.v.text);
    DynStringConcat(txt,"\n");
    free(commandNode->value.v.text);
    commandNode->value.v.text = strdup(GetCharArray(txt));
    NotifyHipadabaPar(commandNode,pCon);
    DeleteDynString(txt);
    return 1;
}
/*--------------------------------------------------------------------------*/
static void sequentialNames(pHdb obj,SConnection *pCon){
    pHdb work = NULL;
    pHdb current = NULL;
    int count = 0;
    char name[80];
    
    work = GetHipadabaNode(obj,"queue");
    assert(work != NULL);
    current = work->child;
    while(current != NULL){
        snprintf(name,80,"%3.3d",count);
        if(current->name != NULL){
            free(current->name);
        }
        current->name = strdup(name);
        count++;
        current = current->next;
    }
    InvokeCallbackChain(work->treeChangeCallbacks,work,pCon,work->value);
    
    work = GetHipadabaNode(obj,"control/maxEntry");
    assert(work != NULL);
    work->value.v.intValue = count; 
    NotifyHipadabaPar(work,pCon);
}
/*---------------------------------------------------------------------------*/
static int Dequeue(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
    pHdb par[], int nPar){
    pHdb work = NULL;
    char name[80];
    pHdbQueue priv = (pHdbQueue)self->pPrivate;

    if(priv->isRunning == 1){
        SCWrite(pCon,"ERROR: cannot dequeue while running",eError);
        return 0;
    }    

    
    if(nPar < 1){
        SCWrite(pCon,"ERROR: internal: not enough parameters to Dequeue",eError);
        return 0;
    }    
    
    snprintf(name,80,"queue/%3.3d", par[0]->value.v.intValue);
    work = GetHipadabaNode(self->objectNode,name);
    if(work != NULL){
        DeleteHipadabaNode(work,pCon);
        sequentialNames(self->objectNode, pCon); 
        return 1;       
    }
    
    return 0;
}
/*---------------------------------------------------------------------------*/
static int Clean(pSICSOBJ self, SConnection *pCon,Hdb commandNode,
     pHdb par[], int nPar){
    int i;
    pHdb current = NULL, queue = NULL;
    pHdb currentEntry  = NULL, tmp = NULL;
    pHdbQueue priv = (pHdbQueue)self->pPrivate;

    if(priv->isRunning == 1){
        SCWrite(pCon,"ERROR: cannot clean while running",eError);
        return 0;
    }    
    currentEntry = GetHipadabaNode(self->objectNode,"control/currentEntry");
    queue = GetHipadabaNode(self->objectNode,"queue");
    current = queue->child;
    for(i = 0; i < currentEntry->value.v.intValue; i++){
        if(current != NULL){
            tmp = current->next;
            DeleteNodeData(current);
            current = tmp;
        }
    }    
    queue->child = tmp;
    currentEntry->value.v.intValue = 0;
    sequentialNames(self->objectNode, pCon);
    NotifyHipadabaPar(currentEntry,pCon);
    return 1;
}
/*---------------------------------------------------------------------------*/
static int CleanAll(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
    pHdb par[], int nPar){
    int i;
    pHdb current = NULL, queue = NULL;
    pHdb currentEntry  = NULL, tmp;
    pHdbQueue priv = (pHdbQueue)self->pPrivate;
    
    if(priv->isRunning == 1){
        SCWrite(pCon,"ERROR: cannot clear queue while executing",eError);
        return 0;
    }
    currentEntry = GetHipadabaNode(self->objectNode,"control/currentEntry");
    queue = GetHipadabaNode(self->objectNode,"queue");
    current = queue->child;
    while(current != NULL){
        tmp = current->next;
        DeleteNodeData(current);
        current = tmp;
    }       
    queue->child = NULL;
    currentEntry->value.v.intValue = 0;
    sequentialNames(self->objectNode, pCon);
    NotifyHipadabaPar(currentEntry,pCon);
    return 1;
}
/*----------------------------------------------------------------------------*/
static int QueueTask(void *pData){
    pSICSOBJ self = (pSICSOBJ)pData;
    int status, pos;
    pHdb work = NULL;
    pHdb exeNode = NULL;
    pHdb max   = NULL;
    char name[80];
    pHdbQueue priv = (pHdbQueue)self->pPrivate;

    if(priv->iStop == 1){
        priv->isRunning = 0;
        return 0;
    }
        
    work = GetHipadabaNode(self->objectNode,"control/currentEntry");
    max = GetHipadabaNode(self->objectNode,"control/maxEntry");
    assert(work != NULL && max != NULL);
    pos = work->value.v.intValue;
    snprintf(name,80,"queue/%3.3d", pos);

    exeNode = GetHipadabaNode(self->objectNode,name);
    if(exeNode != NULL){
        MacroPush(priv->pCon);
        exeHdbNode(exeNode, priv->pCon);
        MacroPop();
    }
    if(priv->iStop == 1 || SCGetInterrupt(priv->pCon) != eContinue){
        priv->isRunning = 0;
        return 0;
    }
    
    pos++;
    work->value.v.intValue = pos;
    NotifyHipadabaPar(work,priv->pCon);
    if(pos >= max->value.v.intValue){
        priv->isRunning = 0;
        return 0;
    }
    
    return 1;
}
/*---------------------------------------------------------------------------*/
static int Start(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
    pHdb par[], int nPar){
    pHdbQueue priv = (pHdbQueue)self->pPrivate;

    priv->iStop = 0;    
    priv->pCon = pCon;

    if(priv->isRunning == 1){
        SCWrite(pCon,"ERROR: Hdbqueue is already running",eError);
        return 0;
    }    
    priv->isRunning = 1;
    
    TaskRegister(pServ->pTasker,
            QueueTask,
            NULL,
            NULL,
            self,
            10);
    return 1;
}   
/*---------------------------------------------------------------------------*/
static int Restart(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
    pHdb par[], int nPar){
    pHdbQueue priv = (pHdbQueue)self->pPrivate;
    pHdb maxCurrent  = NULL;
    
    maxCurrent = GetHipadabaNode(self->objectNode,"control/currentEntry");
    if(maxCurrent != NULL){
        maxCurrent->value.v.intValue = 0;
        NotifyHipadabaPar(maxCurrent,pCon);
    }

    return Start(self,pCon,commandNode,par,nPar);
}   
/*---------------------------------------------------------------------------*/
static int Stop(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
    pHdb par[], int nPar){
    pHdbQueue priv = (pHdbQueue)self->pPrivate;
    
    priv->iStop = 1;
    return 1; 
}
/*----------------------------------------------------------------------------*/
static int Move(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
     pHdb par[], int nPar){
    pHdb moveNode = NULL;
    pHdb insertNode = NULL;
    pHdb prevNode = NULL, queueNode = NULL;
    pHdb tmp;
    char name[80];
    pHdbQueue priv = (pHdbQueue)self->pPrivate;

    if(priv->isRunning == 1){
        SCWrite(pCon,"ERROR: cannot move while running",eError);
        return 0;
    }    
    
    if(nPar < 2){
        SCWrite(pCon,"ERROR: internal: not enough parameters to Move",eError);
        return 1;
    }       
   
    if(par[1]->value.v.intValue == par[0]->value.v.intValue + 1){
        /*
         * already in right sequence, nothing to do
         */
        return 1;
    }
   
    snprintf(name,80,"queue/%3.3d", par[1]->value.v.intValue);
    moveNode = GetHipadabaNode(self->objectNode,name);

    snprintf(name,80,"queue/%3.3d", par[0]->value.v.intValue);
    insertNode = GetHipadabaNode(self->objectNode,name);
    if(moveNode == NULL || insertNode == NULL){
        SCWrite(pCon,"ERROR: move not possible, participating nodes not found",
            eError);
        return 0;
    }
    queueNode = GetHipadabaNode(self->objectNode,"queue");

    if(moveNode == queueNode->child){
        queueNode->child = queueNode->child->next;
        moveNode->next = insertNode->next;
        insertNode->next = moveNode;
    }    else {
        prevNode = queueNode->child;
        while(prevNode != NULL && prevNode->next != moveNode){
            prevNode = prevNode->next;
        }
        if(insertNode == queueNode->child ){
            /*
            * insert at top
            */
            tmp = queueNode->child;
            queueNode->child = moveNode;
            prevNode->next = moveNode->next;
            moveNode->next = tmp;
        } else {
            tmp = insertNode->next;
            insertNode->next = moveNode;
            prevNode->next = moveNode->next;
            moveNode->next = tmp;
        } 
    }
    sequentialNames(self->objectNode, pCon);
  
    return 1;
}
/*---------------------------------------------------------------------------*/
static void Configure(pSICSOBJ self){
    pHdb n = NULL, par = NULL;
    hdbValue intValue, textValue, funcValue;
    pHdb obj = self->objectNode;
    
    intValue = MakeHdbInt(0);
    textValue = MakeHdbText("Undefined");
    
    n = MakeHipadabaNode("control",HIPNONE,1);
    AddHipadabaChild(obj,n,NULL);
    AddSICSHdbPar(n,"maxEntry",usInternal,intValue);
    AddSICSHdbPar(n,"currentEntry",usInternal,intValue);

    
    n = MakeHipadabaNode("queue",HIPNONE,1);
    AddHipadabaChild(obj,n, NULL);

    funcValue = MakeSICSFunc(EnqueFunc);
    n = MakeSICSHdbPar("enqueue",usUser, funcValue);
    AddSICSHdbPar(n,"description",usUser,textValue);
    AddHipadabaChild(obj,n,NULL);
    AppendHipadabaCallback(n,HCBSET,MakeSICSFuncCallback(self));

    funcValue = MakeSICSFunc(AddCmdData);
    n = MakeSICSHdbPar("addcommand",usUser, funcValue);
    AddSICSHdbPar(n,"command",usUser,textValue);
    AddHipadabaChild(obj,n,NULL);
    AppendHipadabaCallback(n,HCBSET,MakeSICSFuncCallback(self));


    funcValue = MakeSICSFunc(Dequeue);
    n = MakeSICSHdbPar("dequeue",usUser,funcValue);
    AddHipadabaChild(obj,n,NULL);
    AddSICSHdbPar(n,"index",usUser,intValue);
    AppendHipadabaCallback(n,HCBSET,MakeSICSFuncCallback(self));


    funcValue = MakeSICSFunc(Clean);
    n = MakeSICSHdbPar("clean",usUser, funcValue);
    AddHipadabaChild(obj,n,NULL);
    AppendHipadabaCallback(n,HCBSET,MakeSICSFuncCallback(self));

    funcValue = MakeSICSFunc(CleanAll);
    n = MakeSICSHdbPar("cleanall",usUser, funcValue);
    AddHipadabaChild(obj,n,NULL);
    AppendHipadabaCallback(n,HCBSET,MakeSICSFuncCallback(self));

    funcValue = MakeSICSFunc(Start);
    n = MakeSICSHdbPar("start",usUser, funcValue);
    AddHipadabaChild(obj,n,NULL);
    AppendHipadabaCallback(n,HCBSET,MakeSICSFuncCallback(self));

    funcValue = MakeSICSFunc(Restart);
    n = MakeSICSHdbPar("restart",usUser, funcValue);
    AddHipadabaChild(obj,n,NULL);
    AppendHipadabaCallback(n,HCBSET,MakeSICSFuncCallback(self));

    funcValue = MakeSICSFunc(Stop);
    n = MakeSICSHdbPar("stop",usUser, funcValue);
    AddHipadabaChild(obj,n,NULL);
    AppendHipadabaCallback(n,HCBSET,MakeSICSFuncCallback(self));

    funcValue = MakeSICSFunc(Move);
    n = MakeSICSHdbPar("move",usUser,funcValue);
    AddHipadabaChild(obj,n,NULL);
    AddSICSHdbPar(n,"moveindex",usUser,intValue);
    AddSICSHdbPar(n,"insertindex",usUser,intValue);
    AppendHipadabaCallback(n,HCBSET,MakeSICSFuncCallback(self));

}
/*---------------------------------------------------------------------------*/
int MakeHDBQueue(SConnection *pCon, SicsInterp *pSics, void *pData, 
    int argc, char *argv[]){
        pSICSOBJ self = NULL;
        pHdbQueue priv = NULL;
        
        priv = (pHdbQueue)malloc(sizeof(HdbQueue));
        self = SetupSICSOBJ(pCon,pSics, pData,argc, argv);
        if(self == NULL || priv == NULL){
            return 0;
        }
        Configure(self);
        memset(priv,0,sizeof(HdbQueue)); 
        self->pPrivate = priv;
        self->KillPrivate = free;
        return 1;
}