#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>
#include <time.h>

#include <sys/types.h>
#include <sys/stat.h>

#include <ellLib.h>
#include <epicsTypes.h>
#include <epicsTime.h>
#include <epicsThread.h>
#include <epicsString.h>
#include <epicsTimer.h>
#include <epicsMutex.h>
#include <epicsEvent.h>

#include <iocsh.h>

#include <drvSup.h>
#include <epicsExport.h>

#include <asynPortDriver.h>
#include <asynOctetSyncIO.h>

#include <yamlLoader.h>
#include <jitterCleanerYaml.hh>
#include <jitterCleanerAsynDriver.h>


typedef struct {
    ELLNODE      node;
    char         port_name[64];
    char         phaseLock_path_name[256];
    char         Si5317a_path_name[256];
    JitterCleaner::JitterCleanerYaml  *pApiDrv;
    jitterCleanerAsynDriver           *pAsynDrv;
}  jitterCleanerAsynDriverList_t;

static const char *drvName = "JitterCleanerAsynDriver";
static ELLLIST    *pList   = NULL;

static void init_pList(void)
{
    if(!pList) {
        pList = new ELLLIST;
        ellInit(pList);
    }
}


static double phaseCnt2Degree(uint32_t count)
{
    double degree = 360. * double(count) / double(1<<15);

     while(degree > 180.) degree -=360.;

     return degree;
}

static double delay2Degree(uint32_t delay)
{
    double degree = 360. * double(delay) / 336.;

    while(degree > 180.) degree -= 360.;

    return degree;
}





jitterCleanerAsynDriver::jitterCleanerAsynDriver(const char *portName, const char *phaseLock_pathName, const char *Si5317a_pathName)
    : asynPortDriver(portName,
                     1,
                     NUM_JITTERCLEANER_DET_PARAMS,
                     asynInt32Mask | asynFloat64Mask | asynOctetMask | asynDrvUserMask | asynInt32ArrayMask | asynInt16ArrayMask,
                     asynInt32Mask | asynFloat64Mask | asynOctetMask | asynEnumMask | asynInt32ArrayMask | asynInt16ArrayMask,
                     1,
                     1,
                     0,
                     0)
{

    Path phase_lock_path = cpswGetRoot()->findByName(phaseLock_pathName);
    Path Si5317a_path    = cpswGetRoot()->findByName(Si5317a_pathName);

    pApiDrv              = new JitterCleaner::JitterCleanerYaml(phase_lock_path, Si5317a_path); 

    CreateParameters();
}


void jitterCleanerAsynDriver::CreateParameters(void)
{
    createParam(phaseTargetString,   asynParamInt32, &p_phaseTarget);
    createParam(delayValueString,    asynParamInt32, &p_delayValue);
    createParam(lockStatusString,    asynParamInt32, &p_lockStatus);
    createParam(phaseValidCntString, asynParamInt32, &p_phaseValidCnt);
    createParam(phaseLateCntString,  asynParamInt32, &p_phaseLateCnt);
    createParam(delaySetValueString, asynParamInt32, &p_delaySetValue);
    createParam(scanStateString,     asynParamInt32, &p_scanState);
    createParam(scanValidCntString,  asynParamInt32, &p_scanValidCnt);
    createParam(phaseCenterString,   asynParamInt32, &p_phaseCenter);
    createParam(phaseCalcString,     asynParamInt32, &p_phaseCalc);
    createParam(reScanString,        asynParamInt32, &p_reScan);

    createParam(phaseTargetConvString,  asynParamFloat64, &p_phaseTarget_conv);
    createParam(phaseLateCntConvString, asynParamFloat64, &p_phaseLateCnt_conv);
    createParam(phaseCenterConvString,  asynParamFloat64, &p_phaseCenter_conv);
    createParam(phaseCalcConvString,    asynParamFloat64, &p_phaseCalc_conv);

    createParam(delayValueConvString,    asynParamFloat64, &p_delayValue_conv);
    createParam(delaySetValueConvString, asynParamFloat64, &p_delaySetValue_conv);

    createParam(cntLosString,        asynParamInt32, &p_cntLos);
    createParam(cntLolString,        asynParamInt32, &p_cntLol);
    createParam(cntLockedString,     asynParamInt32, &p_cntLocked);

}

void jitterCleanerAsynDriver::Monitor(void)
{
    uint32_t val;

    val = pApiDrv->phaseTarget();    setIntegerParam(p_phaseTarget,   val);
                                     setDoubleParam(p_phaseTarget_conv, phaseCnt2Degree(val));
    val = pApiDrv->delayValue();     setIntegerParam(p_delayValue,    val);
                                     setDoubleParam(p_delayValue_conv,  delay2Degree(val));
    val = pApiDrv->locked();         setIntegerParam(p_lockStatus,    val);
    val = pApiDrv->phaseValid();     setIntegerParam(p_phaseValidCnt, val);
    val = pApiDrv->phaseCount();     setIntegerParam(p_phaseLateCnt,  val);
                                     setDoubleParam(p_phaseLateCnt_conv, phaseCnt2Degree(val));
    val = pApiDrv->scanState();      setIntegerParam(p_scanState,     val);
    val = pApiDrv->delaySet();       setIntegerParam(p_delaySetValue, val);
                                     setDoubleParam(p_delaySetValue_conv, delay2Degree(val));
    val = pApiDrv->scanCount();      setIntegerParam(p_scanValidCnt,  val);
    val = pApiDrv->phaseCenter();    setIntegerParam(p_phaseCenter,   val);
                                     setDoubleParam(p_phaseCenter_conv, phaseCnt2Degree(val));
    val = pApiDrv->phaseCalc();      setIntegerParam(p_phaseCalc,     val);
                                     setDoubleParam(p_phaseCalc_conv, phaseCnt2Degree(val));
    val = pApiDrv->reScan();         setIntegerParam(p_reScan,        val);

    val = pApiDrv->cntLos();         setIntegerParam(p_cntLos,        val);
    val = pApiDrv->cntLol();         setIntegerParam(p_cntLol,        val);
    val = pApiDrv->cntLocked();      setIntegerParam(p_cntLocked,     val);

    callParamCallbacks();
}


void jitterCleanerAsynDriver::Dump(void)
{
    uint32_t val;

    getIntegerParam(p_phaseTarget,   (int*) &val); printf("\t\tPhase Target     : %8.8x\n", val);
    getIntegerParam(p_delayValue,    (int*) &val); printf("\t\tDelay Value      : %8.8x\n", val);
    getIntegerParam(p_lockStatus,    (int*) &val); printf("\t\tLock Sttus       : %8.8x\n", val);
    getIntegerParam(p_phaseValidCnt, (int*) &val); printf("\t\tPhase Valid Count: %8.8x\n", val);
    getIntegerParam(p_phaseLateCnt,  (int*) &val); printf("\t\tPhase Late Count : %8.8x\n", val);
    getIntegerParam(p_delaySetValue, (int*) &val); printf("\t\tDelay Set Value  : %8.8x\n", val);
    getIntegerParam(p_scanState,     (int*) &val); printf("\t\tScan State       : %8.8x\n", val);
    getIntegerParam(p_phaseCenter,   (int*) &val); printf("\t\tPhase Center     : %8.8x\n", val);
    getIntegerParam(p_phaseCalc,     (int*) &val); printf("\t\tPhase Calc       : %8.8x\n", val);
    getIntegerParam(p_reScan,        (int*) &val); printf("\t\tRe-Scan          : %8.8x\n", val);
}



asynStatus jitterCleanerAsynDriver::writeInt32(asynUser *pasynUser, epicsInt32 value)
{
    int function = pasynUser->reason;
    asynStatus status = asynSuccess;
    const char *functionName = "writeInt32";

    /* set the parameter in the parameter library */
    status = (asynStatus) setIntegerParam(function, value);

    if(function == p_reScan) {
        pApiDrv->setReScan(value?1:0);
    }

    callParamCallbacks();

    return status;
}


JitterCleaner::JitterCleanerYaml* jitterCleanerAsynDriver::getApi(void)
{
    return pApiDrv;
}



extern "C" {

static void jitterCleanerAsynDriverConfigure(const char *port_name, const char *phaseLock_path_name, const char *Si5317a_path_name)
{
    jitterCleanerAsynDriverList_t *pDrvNode = new jitterCleanerAsynDriverList_t;
    pDrvNode->pAsynDrv                      = new jitterCleanerAsynDriver(port_name, phaseLock_path_name, Si5317a_path_name);
    pDrvNode->pApiDrv                       = pDrvNode->pAsynDrv->getApi();

    strcpy(pDrvNode->port_name, port_name);
    strcpy(pDrvNode->phaseLock_path_name, phaseLock_path_name);
    strcpy(pDrvNode->Si5317a_path_name,   Si5317a_path_name);


    init_pList(); ellAdd(pList, &pDrvNode->node);
}


static void jitterCleanerAsynDriverMonitor(void)
{
    jitterCleanerAsynDriverList_t *p;

    if(!pList || !ellCount(pList)) return;

    while(1) {
        p = (jitterCleanerAsynDriverList_t*) ellFirst(pList);
        while(p) {
            p->pAsynDrv->Monitor();
            p = (jitterCleanerAsynDriverList_t*) ellNext(&p->node);
        }
        epicsThreadSleep(1.);
    }
}


static int jitterCleanerAsynDriverReport(int interest);
static int jitterCleanerAsynDriverInitialize(void);
static struct drvet jitterCleanerAsynDriver = {
    2, 
    (DRVSUPFUN) jitterCleanerAsynDriverReport,
    (DRVSUPFUN) jitterCleanerAsynDriverInitialize
};

epicsExportAddress(drvet, jitterCleanerAsynDriver);


static int jitterCleanerAsynDriverReport(int interest)
{
    jitterCleanerAsynDriverList_t *p;

    if(!pList || !ellCount(pList)) return 0;


    p = (jitterCleanerAsynDriverList_t*) ellFirst(pList);
    while(p) {
        printf("\tport_name: %s, phaseLock_path_name: %s\n",  p->port_name, p->phaseLock_path_name);
        p->pAsynDrv->Dump();

        p = (jitterCleanerAsynDriverList_t *) ellNext(&p->node);
    }


    return 0;
}


static int jitterCleanerAsynDriverInitialize(void)
{

   if(!pList || !ellCount(pList)) return 0;

   epicsThreadCreate("jitterCleaner", epicsThreadPriorityLow,
                     epicsThreadGetStackSize(epicsThreadStackMedium),
                     (EPICSTHREADFUNC) jitterCleanerAsynDriverMonitor, 0);

    return 0;
}



static const iocshArg initArg0 = {"port name",              iocshArgString };
static const iocshArg initArg1 = {"phase locker path name", iocshArgString };
static const iocshArg initArg2 = {"Si5317a path name",      iocshArgString };
static const iocshArg * const initArgs[] = { &initArg0, &initArg1, &initArg2 };
static const iocshFuncDef initFuncDef = {"jitterCleanerAsynDriverConfigure", 3, initArgs };
static void  initCallFunc(const iocshArgBuf *args)
{
    jitterCleanerAsynDriverConfigure(args[0].sval, args[1].sval, args[2].sval);
}



static void jitterCleanerAsynDriverRegister(void)
{
    iocshRegister(&initFuncDef, initCallFunc);
}



epicsExportRegistrar(jitterCleanerAsynDriverRegister);

} /* extern C */
