/*--------------------------------------------------------------------------
 This is a counter for use in automated regression tests. 
 
 copyright: see file COPYRIGHT
 
 Mark Koennecke, September 2006
----------------------------------------------------------------------------*/
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <time.h>
#include "fortify.h"
#include <string.h>
#include "sics.h"
#include "countdriv.h"
/*---------------------------------- possible error types ------------------*/
#define NONE 0
#define STARTFAIL   1
#define STATUSFAIL  2
#define PAUSEFAIL   3
#define CONTFAIL    4
#define READFAIL    5

#define STATEIDLE 0
#define STATERUN  1
#define STATEPAU  2
/*--------------------------------------------------------------------------*/
typedef struct {
    int errType;
    int recover;
    int state;
    time_t endTime;
} RegressSt;
/*---------------------------------------------------------------------------*/
static int RegressGetStatus(struct __COUNTER *self, float *fControl){
    RegressSt *pSim = NULL;
    time_t tD, tDe;
    int iRun;

    assert(self);
    pSim = (RegressSt *) self->pData;
    assert(pSim);

    if(pSim->errType == STATUSFAIL){
        return HWFault;
    }
    if(time(NULL) > pSim->endTime){
        pSim->state = STATEIDLE;
    }
    switch(pSim->state){
        case STATEIDLE:
            return HWIdle;
            break;
        case STATERUN:
            return HWBusy;
            break;
        case STATEPAU:
            return HWPause;
            break;
    }
    assert(0);
    return HWFault;
}
/*---------------------------------------------------------------------------*/
static int RegressStart(struct __COUNTER *self){
    RegressSt *pSim = NULL;
    time_t tD;
    int iRun;

    assert(self);
    pSim = (RegressSt *) self->pData;
    assert(pSim);

    if(pSim->errType == STARTFAIL){
        return HWFault;
    }
    pSim->state = STATERUN;
    if(self->eMode == eTimer){
        pSim->endTime = time(NULL) + (int)self->fPreset;
    } else {
        pSim->endTime = time(NULL) + 7;
    }
 
    return OKOK;
}
/*---------------------------------------------------------------------------*/
static int RegressPause(struct __COUNTER *self){
    RegressSt *pSim = NULL;
    time_t tD;
    int iRun;

    assert(self);
    pSim = (RegressSt *) self->pData;
    assert(pSim);

    if(pSim->errType == PAUSEFAIL){
        return HWFault;
    }

    pSim->state = STATEPAU;

    return OKOK;
}
/*---------------------------------------------------------------------------*/
static int RegressContinue(struct __COUNTER *self){
    RegressSt *pSim = NULL;

    assert(self);
    pSim = (RegressSt *) self->pData;
    assert(pSim);

    if(pSim->errType == CONTFAIL){
        return HWFault;
    }

    pSim->state = STATERUN;
 
    return OKOK;
}
/*--------------------------------------------------------------------------*/
static int RegressHalt(struct __COUNTER *self){
    RegressSt *pSim = NULL;

    assert(self);
    pSim = (RegressSt *) self->pData;
    assert(pSim);
    
    pSim->state = STATEIDLE;

    return OKOK;
}

/*-------------------------------------------------------------------------*/
static int RegressReadValues(struct __COUNTER *self){
    RegressSt *pSim = NULL;
    int i;

    assert(self);
    pSim = (RegressSt *) self->pData;
    assert(pSim);

    if(pSim->errType == READFAIL){
        return HWFault;
    }
 
    for (i = 0; i < MAXCOUNT; i++) {
        self->lCounts[i] = i*10+5;
    }
    self->lCounts[1] = self->fPreset;
    self->fTime = self->fPreset;
    return OKOK;
}
/*-------------------------------------------------------------------------*/
static int RegressGetError(struct __COUNTER *self, int *iCode, char *error,
                int iErrLen){
    strncpy(error, "Regression counter error", iErrLen);
    *iCode = 1;
    return 1;
}
/*--------------------------------------------------------------------------*/
static int RegressTryAndFixIt(struct __COUNTER *self, int iCode){
    RegressSt *pSim = NULL;

    assert(self);
    pSim = (RegressSt *) self->pData;
    assert(pSim);
    
    if(pSim->recover == 1){
        pSim->errType = NONE;
        return COREDO;
    } else {
        return COTERM;
    }
}
/*--------------------------------------------------------------------------*/
static int RegressSet(struct __COUNTER *self, char *name, int iCter, float FVal){
    RegressSt *pSim = NULL;

    assert(self);
    pSim = (RegressSt *) self->pData;
    assert(pSim);

    if(strcmp(name,"errortype") == 0){
        pSim->errType = (int)FVal;
        return 1;
    }
    if(strcmp(name,"recover") == 0){
        pSim->recover = (int)FVal;
        return 1;
    }
    if(strcmp(name,"finish") == 0){
        pSim->state = STATEIDLE;
        return 1;
    }
    return 0;
}
/*--------------------------------------------------------------------------*/
static int RegressGet(struct __COUNTER *self, char *name, 
    int iCter, float *fVal){
    RegressSt *pSim = NULL;

    assert(self);
    pSim = (RegressSt *) self->pData;
    assert(pSim);

    if(strcmp(name,"errortype") == 0){
        *fVal = pSim->errType;
        return 1;
    }
    if(strcmp(name,"recover") == 0){
        *fVal  = pSim->recover;
        return 1;
    }
    return 0;
}
/*---------------------------------------------------------------------------*/
static int RegressSend(struct __COUNTER *self, char *pText,
            char *pReply, int iReplyLen){
    strncpy(pReply, "Simulated response", iReplyLen);
    return 1;
}
/*---------------------------------------------------------------------------*/
pCounterDriver NewRegressCounter(char *name){
    pCounterDriver pRes = NULL;
    RegressSt *pData = NULL;
    int iRet;
    int iC1, iC2, iC3;
    char *pErr;
    char pBueffel[132];

    pRes = CreateCounterDriver(name, "Regress");
    if (!pRes) {
        return NULL;
    }

    pData = (RegressSt *) malloc(sizeof(RegressSt));
    if (!pData) {
        DeleteCounterDriver(pRes);
        return NULL;
    }
    memset(pData,0,sizeof(RegressSt));
    pRes->pData = pData;

    /*
     * assign functions 
     */
    pRes->GetStatus = RegressGetStatus;
    pRes->Start = RegressStart;
    pRes->Halt = RegressHalt;
    pRes->ReadValues = RegressReadValues;
    pRes->GetError = RegressGetError;
    pRes->TryAndFixIt = RegressTryAndFixIt;
    pRes->Pause = RegressPause;
    pRes->Continue = RegressContinue;
    pRes->Set = RegressSet;
    pRes->Get = RegressGet;
    pRes->Send = RegressSend;
    pRes->KillPrivate = NULL;
    pRes->iNoOfMonitors = 8;

    return pRes;
}