/*----------------------------------------------------------------------------

				H I S T S I M
				
  A simulated histogram memory for regression tests. 
 
  All the counting error stuff is redirected to a regression counter; see
  documentation there. This just adds data handling.
  
 copyright: see file COPYRIGHT
 
 Mark Koennecke, October 2006 
 ----------------------------------------------------------------------------*/
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include "fortify.h"
#include "sics.h"
#include "countdriv.h"
#include "counter.h"
#include "stringdict.h"
#include "HistMem.h"
#include "HistDriv.i"
#include "histsim.h"

static int iSet = 0;
static HistInt iSetVal = 0;
static HistMode eHistMode;
/*--------------------------------------------------------------------------*/
static int RegressConfig(pHistDriver self, SConnection *pCon, 
                       pStringDict pOption, SicsInterp *pSics)
{
    int i, iLength = 1, status;
    char pData[132];
    float fFail;
    pCounterDriver count;

    count = (pCounterDriver)self->pPriv;
    
    if(eHistMode == eHTOF)
    {
      for(i = 0; i < self->data->rank; i++)
      {
        iLength *= self->data->iDim[i];
      }       
      iLength *= self->data->nTimeChan;
    }

    /*
      deal with error settings
    */
    status = StringDictGet(pOption,"errortype",pData,131);
    if(status)
    {
         
      fFail = atof(pData);
      count->Set(count,"errortype",1,fFail); 
    }    
    status = StringDictGet(pOption,"recover",pData,131);
    if(status)
    {
         
      fFail = atof(pData);
      count->Set(count,"recover",1,fFail); 
    }    
    status = StringDictGet(pOption,"finish",pData,131);
    if(status)
    {
         
      fFail = atof(pData);
      count->Set(count,"finish",1,fFail); 
    }    
    
    /*
      configured test value
    */
    status = StringDictGet(pOption,"testval",pData,131);
    if(status)
    {
      iSet = 1;
      iSetVal = atoi(pData);
    }

    return 1;
  }  	
/*-------------------------------------------------------------------------*/
 static int RegressStart(pHistDriver self, SConnection *pCon)
 {
    pCounterDriver pDriv;
    
    pDriv = (pCounterDriver)self->pPriv;
    pDriv->fPreset = self->fCountPreset;
    pDriv->eMode = self->eCount;
    return pDriv->Start(pDriv);
 }  			
/*-------------------------------------------------------------------------*/
 static int RegressPause(pHistDriver self, SConnection *pCon)
 {
    pCounterDriver pDriv;
    
    pDriv = (pCounterDriver)self->pPriv;
    pDriv->fPreset = self->fCountPreset;
    pDriv->eMode = self->eCount;
    return pDriv->Pause(pDriv);
 }  
/*------------------------------------------------------------------------*/
 static int RegressContinue(pHistDriver self, SConnection *pCon)
 {
    pCounterDriver pDriv;
    
    pDriv = (pCounterDriver)self->pPriv;
    pDriv->fPreset = self->fCountPreset;
    pDriv->eMode = self->eCount;
    return pDriv->Continue(pDriv);
 }  
/*-------------------------------------------------------------------------*/
 static int RegressHalt(pHistDriver self)
 {
    pCounterDriver pDriv;
    
    pDriv = (pCounterDriver)self->pPriv;
    return pDriv->Halt(pDriv);
 }  			
/*-------------------------------------------------------------------------*/
 static int RegressGetCountStatus(pHistDriver self, SConnection *pCon)
 {
    pCounterDriver pDriv;
    float fControl;
    
    pDriv = (pCounterDriver)self->pPriv;
    return pDriv->GetStatus(pDriv,&fControl);
 } 
/*-------------------------------------------------------------------------*/
 static int RegressGetError(pHistDriver self, int *iCode, char *pError, int iLen)
 {
    pCounterDriver pDriv;
    
    pDriv = (pCounterDriver)self->pPriv;
    return pDriv->GetError(pDriv, iCode,pError,iLen);
 } 
/*-------------------------------------------------------------------------*/
 static int RegressTryAndFixIt(pHistDriver self, int iCode)
 {
    pCounterDriver pDriv;
    
    pDriv = (pCounterDriver)self->pPriv;
    return pDriv->TryAndFixIt(pDriv, iCode);
 } 
/*--------------------------------------------------------------------------*/
 static int RegressGetData(pHistDriver self, SConnection *pCon)
 {
    pCounterDriver pDriv;
    
    pDriv = (pCounterDriver)self->pPriv;

    return pDriv->ReadValues(pDriv);
 } 
/*--------------------------------------------------------------------------*/
 static int RegressGetHistogram(pHistDriver self, SConnection *pCon,
                            int i, int iStart, int iEnd, HistInt *lData)
 {
      int ii;
      
      if(i < 0)
      {
        SCWrite(pCon,"ERROR: histogram out of range",eError);
        return 0;
      }   

      if(iSet == 1)
      {
        for(ii = iStart; ii < iEnd; ii++)
        {
          lData[ii-iStart] = iSetVal;
        }
      }
      else
      {
         for(ii = iStart; ii < iEnd; ii++)
         {
            lData[ii-iStart] = random();
         }
      }
      return 1;
 }                              			
/*------------------------------------------------------------------------*/
 static int RegressSetHistogram(pHistDriver self, SConnection *pCon,
                            int i, int iStart, int iEnd, HistInt *lData)
 {
   iSet = 1;
   iSetVal = lData[0];
   return 1;
 }

/*-------------------------------------------------------------------------*/
 static int RegressPreset(pHistDriver self, SConnection *pCon, HistInt iVal)
 {
   iSet = 1;
   iSetVal = iVal;
   return 1;
 }
/*------------------------------------------------------------------------*/
 static int RegressFreePrivate(pHistDriver self)
 {
    pCounterDriver pDriv;
    
    pDriv = (pCounterDriver)self->pPriv;
    DeleteCounterDriver(pDriv);
    return 1;
 } 
/*------------------------------------------------------------------------*/
 static long RegressGetMonitor(pHistDriver self, int i, SConnection *pCon)
 {
    pCounterDriver pDriv;
    long lVal;
    
    pDriv = (pCounterDriver)self->pPriv;
    return pDriv->lCounts[i];
    
 }
/*------------------------------------------------------------------------*/
 static float RegressGetTime(pHistDriver self, SConnection *pCon)
 {
    pCounterDriver pDriv;
    long lVal;
    
    pDriv = (pCounterDriver)self->pPriv;
    return pDriv->fTime;
    
 }
/*-------------------------------------------------------------------------*/
 pHistDriver CreateRegressHM(pStringDict pOpt)
 {
    pHistDriver pNew = NULL;
    
    /* create the general driver */
    pNew = CreateHistDriver(pOpt);
    if(!pNew)
    {
      return NULL;
    } 
    
    /* put a Regresscounter in */
    pNew->pPriv = (void *)NewRegressCounter("HistoRegress");
    if(!pNew->pPriv)
    {
      DeleteHistDriver(pNew);
      return NULL;
    }
    
    /* configure all those functions */
    pNew->Configure = RegressConfig;
    pNew->Start     = RegressStart;
    pNew->Halt      = RegressHalt;
    pNew->GetCountStatus = RegressGetCountStatus;
    pNew->GetError  = RegressGetError;
    pNew->TryAndFixIt = RegressTryAndFixIt;
    pNew->GetData   = RegressGetData;
    pNew->GetHistogram =  RegressGetHistogram;
    pNew->SetHistogram =  RegressSetHistogram;
    pNew->GetMonitor   =  RegressGetMonitor;
    pNew->GetTime      =  RegressGetTime;
    pNew->Preset    = RegressPreset;
    pNew->FreePrivate = RegressFreePrivate;
    pNew->Pause       = RegressPause;
    pNew->Continue    = RegressContinue;
    StringDictAddPair(pOpt,"errortype","0");
    StringDictAddPair(pOpt,"recover","1");
    StringDictAddPair(pOpt,"testval","0");
    
    return pNew;
 }