/*
 * boardAsynPar.hh
 *
 *  Created on: February 18, 2015
 *      Author: Hovanes Egiyan
 *
 *      This file defines an augmenting class for asynDrvBoard to keep track of asyn parameters.
 *      Some of the methods  of this class expect to receive the pointer of the asynDrvBoard object
 *      for which the parameter instance is used for. So, this class is very much tied to the
 *      asynDrvBoard class and should not be considered as "an" independent class, these objects expect
 *      to be members of asynDrvBoard class object.
 */

#ifndef __BOARD_ASYNPAR_HH__
#define __BOARD_ASYNPAR_HH__

/************/
/* Includes */
/************/
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>

/* EPICS includes */
#include <cantProceed.h>
#include <asynPortDriver.h>
#include <epicsEvent.h>
#include <epicsTypes.h>
#include <epicsThread.h>
#include <epicsString.h>
#include <epicsTimer.h>
#include <epicsExport.h>
#include <epicsMutex.h>
#include <epicsEvent.h>
#include <errlog.h>
#include <iocsh.h>
#include <initHooks.h>
#include <alarm.h>

#include <iostream>
#include <string>

#include "new"
#include "boost/function.hpp"
#include "boost/bind.hpp"

#include "asynDrvBoard.hh"
#include "MtxLock.hh"
#include "MutexedClass.hh"
#include "boardVAsynPar.hh"


// Template class for asyn parameters. For different parameters types we will
// use specialized methods for particular variable types. This class inherits
// from the virtual base class.
template<typename VarType, typename BoardClass>
class boardAsynPar: public boardVAsynPar<BoardClass> {
protected:
	VarType bapValue; // Parameter value
	// Read function
	boost::function<VarType( unsigned )> 			bapReadFunc;
	// Write function
	boost::function<VarType( unsigned, VarType )> 	bapWriteFunc;
	// Alarms status function
	boost::function<epicsAlarmCondition( unsigned )> bapAlarmStatusFunc;
	// Alarms severity function
	boost::function<epicsAlarmSeverity( unsigned )> bapAlarmSeverityFunc;

public:

	// Default constructor
	boardAsynPar() :
			bapValue() {
		return;}


	// Main constructor
	boardAsynPar(string parName, int parNum,
			boost::function<VarType( unsigned )> 			readFun,
			boost::function<VarType( unsigned, VarType )> 	writeFun,
			epicsUInt32 mask = boardVAsynPar<BoardClass>::bvapAllBitMask);

	virtual ~boardAsynPar() {
		return;
	}

	// Copy constructor
	boardAsynPar(const boardAsynPar<VarType, BoardClass>& par);

	// Copy operator
	virtual boardAsynPar<VarType, BoardClass>& operator=(
			const boardAsynPar<VarType, BoardClass>& argPar);

	// Method to create the parameter for the driver passed by the argument.
	// This method is expected to be called from the AsynDriver constructor
	virtual void Connect2Driver(asynDrvBoard<BoardClass>* driver);

	virtual asynStatus Write(asynDrvBoard<BoardClass>* driver, unsigned channel, void* valPtr =
			0, epicsUInt32 mask = boardVAsynPar<BoardClass>::bvapAllBitMask); // Virtual Write asyn parameter
	virtual asynStatus Read(asynDrvBoard<BoardClass>* driver, unsigned channel,
			void* valPtr = 0, epicsUInt32* mask = 0); // Virtual Read asyn parameter

	virtual asynStatus WriteTmpl(asynDrvBoard<BoardClass>* driver, unsigned channel,
			void* valPtr = 0, epicsUInt32 mask =
					boardVAsynPar<BoardClass>::bvapAllBitMask); // Write asyn parameter
	virtual asynStatus ReadTmpl(asynDrvBoard<BoardClass>* driver, unsigned channel,
			void* valPtr = 0, epicsUInt32* mask = 0); // Read asyn parameter

	virtual VarType GetValue()  ;
	virtual VarType SetValue(const VarType value) ;

	virtual boost::function<VarType( unsigned )>  			GetReadFunc()  ;
	virtual boost::function<VarType( unsigned, VarType )> 	GetWriteFunc() ;
	virtual boost::function<epicsAlarmCondition( unsigned )> GetAlarmStatusFunc()  ;
	virtual boost::function<epicsAlarmSeverity( unsigned )> GetAlarmSeverityFunc()  ;
	virtual void SetAlarmStatusFunc(boost::function<epicsAlarmCondition( unsigned )>& func)  ;
	virtual void SetAlarmSeverityFunc(boost::function<epicsAlarmSeverity( unsigned )>& func)  ;
};




// Template class for asyn unsigned  parameters.  This class inherits
// from the double-template class base class and is a partial specialization for epicsUInt32.
template<typename BoardClass>
class boardAsynParUInt32 : public boardAsynPar<epicsUInt32,BoardClass> {
public:
	boardAsynParUInt32(string parName, int parNum,
			boost::function<uint32_t( unsigned )> 			readFun,
			boost::function<uint32_t( unsigned, uint32_t )> writeFun,
			epicsUInt32 mask = boardVAsynPar<BoardClass>::bvapAllBitMask );

	virtual ~boardAsynParUInt32() {; }
	// Method to create the parameter for the driver passed by the argument.
	// This method is expected to be called from the AsynDriver constructor
	virtual void Connect2Driver(asynDrvBoard<BoardClass>* driver);

	virtual asynStatus WriteTmpl(asynDrvBoard<BoardClass>* driver, unsigned channel,
			void* valPtr = 0, epicsUInt32 mask =
					boardVAsynPar<BoardClass>::bvapAllBitMask); // Write asyn parameter
	virtual asynStatus ReadTmpl(asynDrvBoard<BoardClass>* driver,  unsigned channel,
			void* valPtr = 0, epicsUInt32* mask = 0); // Read asyn parameter
};


// Template class for asyn double  parameters.  This class inherits
// from the double-template class base class and is a partial specialization for epicsUInt32.
template<typename BoardClass>
class boardAsynParDouble : public boardAsynPar<epicsFloat64,BoardClass> {
public:
	boardAsynParDouble(string parName, int parNum,
			boost::function<epicsFloat64( unsigned )> 			readFun,
			boost::function<epicsFloat64( unsigned, epicsFloat64 )> 	writeFun,
			epicsUInt32 mask = boardVAsynPar<BoardClass>::bvapAllBitMask );

	virtual ~boardAsynParDouble() {; }
	// Method to create the parameter for the driver passed by the argument.
	// This method is expected to be called from the AsynDriver constructor
	virtual void Connect2Driver(asynDrvBoard<BoardClass>* driver);

	virtual asynStatus WriteTmpl(asynDrvBoard<BoardClass>* driver, unsigned channel,
			void* valPtr = 0, epicsUInt32 mask =
					boardVAsynPar<BoardClass>::bvapAllBitMask); // Write asyn parameter
	virtual asynStatus ReadTmpl(asynDrvBoard<BoardClass>* driver,  unsigned channel,
			void* valPtr = 0, epicsUInt32* mask = 0); // Read asyn parameter
};



//========================================================================
//				Implementation for double template class boardAsynPar
//========================================================================
// Main constructor
template<typename VarType, typename BoardClass>
boardAsynPar<VarType, BoardClass>::boardAsynPar(string parName, int parNum,
		boost::function<VarType( unsigned )> 			readFun,
		boost::function<VarType( unsigned, VarType )> 	writeFun,
		epicsUInt32 mask ) :
		boardVAsynPar<BoardClass>(parName, parNum, mask), bapValue(), bapReadFunc(readFun), bapWriteFunc(writeFun) {
	cout << "Created boardAsynPar " << this->GetName() << endl;
	return;
}

// Copy constructor
template<typename VarType, typename BoardClass>
boardAsynPar<VarType, BoardClass>::boardAsynPar(
		const boardAsynPar<VarType, BoardClass>& par) :
		boardVAsynPar<BoardClass>(par),
		bapValue(par.GetValue(), bapReadFunc(par.GetReadFunc()), bapWriteFunc(par.GetWriteFunc() ) ) {
	return;
}

// Method to create the parameter for the driver passed by the argument.
// This method is expected to be called from the AsynDriver constructor
template<typename VarType, typename BoardClass>
void boardAsynPar<VarType, BoardClass>::Connect2Driver(
		asynDrvBoard<BoardClass>* driver) {
	throw std::runtime_error("boardAsynPar: Must use a specialized Connect2Driver method");
}

template<typename VarType, typename BoardClass>
asynStatus boardAsynPar<VarType, BoardClass>::Write(
		asynDrvBoard<BoardClass>* driver, unsigned channel, void* valPtr, epicsUInt32 mask) // Virtual Write asyn parameter
		{
	return this->WriteTmpl(driver, channel, valPtr, mask);
}

template<typename VarType, typename BoardClass>
asynStatus boardAsynPar<VarType, BoardClass>::Read(
		asynDrvBoard<BoardClass>* driver, unsigned channel, void* valPtr, epicsUInt32* mask) // Virtual Read asyn parameter
		{
	return this->ReadTmpl(driver, channel, valPtr, mask);
}

template<typename VarType, typename BoardClass>
asynStatus boardAsynPar<VarType, BoardClass>::WriteTmpl(
		asynDrvBoard<BoardClass>* driver, unsigned channel, void* valPtr, epicsUInt32 mask) // Write asyn parameter
		{
	throw std::runtime_error("boardAsynPar: Must use a specialized Write method");
}

template<typename VarType, typename BoardClass>
asynStatus boardAsynPar<VarType, BoardClass>::ReadTmpl(
		asynDrvBoard<BoardClass>* driver, unsigned channel, void* valPtr, epicsUInt32* mask) // Read asyn parameter
		{
	throw std::runtime_error("boardAsynPar: Must use a specialized Read method");
}

template<typename VarType, typename BoardClass>
boardAsynPar<VarType, BoardClass>& boardAsynPar<VarType, BoardClass>::operator=(
		const boardAsynPar<VarType, BoardClass>& argPar) {
	boardAsynPar<VarType, BoardClass>& par = const_cast<boardAsynPar<
			VarType, BoardClass>&>(argPar);
	boardVAsynPar<BoardClass>* baseClassPtr = dynamic_cast<boardVAsynPar<
			BoardClass>*>(this);
	baseClassPtr->operator=(par);
	MtxLock selfObjLock(this->mcMutex);
	MtxLock otherObjLock(par.mcMutex);
	bapValue = par.bapValue;
	return *this;
}

template<typename VarType, typename BoardClass>
inline VarType boardAsynPar<VarType, BoardClass>::GetValue() {
	MtxLock objLock(this->mcMutex);
	return bapValue;
}

template<typename VarType, typename BoardClass>
inline VarType boardAsynPar<VarType, BoardClass>::SetValue(
		const VarType value) {
	MtxLock objLock(this->mcMutex);
	return (bapValue = value);
}

template<typename VarType, typename BoardClass>
inline boost::function<VarType( unsigned )>  boardAsynPar<VarType, BoardClass>::GetReadFunc() {
	MtxLock objLock(this->mcMutex);
	return bapReadFunc;
}

template<typename VarType, typename BoardClass>
inline boost::function<VarType( unsigned, VarType )>  boardAsynPar<VarType, BoardClass>::GetWriteFunc() {
	MtxLock objLock(this->mcMutex);
	return bapWriteFunc;
}

template<typename VarType, typename BoardClass>
inline boost::function<epicsAlarmCondition( unsigned )>  boardAsynPar<VarType, BoardClass>::GetAlarmStatusFunc() {
	MtxLock objLock(this->mcMutex);
	return bapAlarmStatusFunc;
}
template<typename VarType, typename BoardClass>
inline boost::function<epicsAlarmSeverity( unsigned )>  boardAsynPar<VarType, BoardClass>::GetAlarmSeverityFunc() {
	MtxLock objLock(this->mcMutex);
	return bapAlarmSeverityFunc;
}

template<typename VarType, typename BoardClass>
void  boardAsynPar<VarType, BoardClass>::SetAlarmStatusFunc( boost::function<epicsAlarmCondition( unsigned )>& func ) {
	MtxLock objLock(this->mcMutex);
	bapAlarmStatusFunc = func;
}
template<typename VarType, typename BoardClass>
void  boardAsynPar<VarType, BoardClass>::SetAlarmSeverityFunc( boost::function<epicsAlarmSeverity( unsigned )>& func ) {
	MtxLock objLock(this->mcMutex);
	bapAlarmSeverityFunc = func;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Below are the implementation of partially specialized classes

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//==========================================================================================================
// Specialized for unsigned type parameters
//==========================================================================================================

template <typename BoardClass>
boardAsynParUInt32<BoardClass>::boardAsynParUInt32(string parName, int parNum,
		boost::function<uint32_t (unsigned)> readFun,
		boost::function<uint32_t (unsigned, uint32_t )> writeFun,
		epicsUInt32 mask ) :
		boardAsynPar<epicsUInt32, BoardClass>( parName, parNum, readFun, writeFun, mask ) {
	boost::function<uint32_t (unsigned)> tmpFunc = readFun;
	cout << "Received read function " << readFun << endl;
	cout << "Kept read function " << this->bapReadFunc << endl;
	cout << "Test Func is " << tmpFunc << endl;
	return;
}


// Specialized method for UInt32 to create the  parameter for the driver passed by the argument.
// This method is expected to be called from the AsynDriver constructor
template <typename BoardClass>
void boardAsynParUInt32<BoardClass>::Connect2Driver( asynDrvBoard<BoardClass>* driver ) {
//	cout << "Inside boardAsynPar<epicsUInt32>::Connect2Driver" << endl;
	MtxLock objLock(this->mcMutex);
	driver->createParam( this->bvapParName.c_str(), asynParamUInt32Digital, &this->bvapParNum ) ;
	return;
}


// Specialized for UInt32 method to write asyn parameter
template<typename BoardClass>
asynStatus boardAsynParUInt32<BoardClass>::WriteTmpl(
		asynDrvBoard<BoardClass>* driver, unsigned channel, void* valPtr,
		epicsUInt32 mask) {
//	cout << "Inside boardAsynParUInt32>::WriteTmpl" << endl;
//	BoardClass* board = driver->getBoard();
	MtxLock objLock(this->mcMutex);
	asynStatus aStat = asynError;

	epicsUInt32 value = *static_cast<epicsUInt32*>(valPtr);
	cout << "Setting UInt32 parameter " << this->bvapParName << " to " << value << endl;

//	this->bapWriteFunc( channel, value );
//		( (*board).*(this->bvapWriteFun) ) ( value );
	aStat = driver->setUIntDigitalParam(channel, this->bvapParNum, value, mask,	mask);

	return aStat;
}

// Specialized for UInt32 to read asyn parameter
template<typename BoardClass>
asynStatus boardAsynParUInt32<BoardClass>::ReadTmpl(
		asynDrvBoard<BoardClass>* driver, unsigned channel, void* valPtr,
		epicsUInt32* mask) {
	cout << "Inside boardAsynParUInt32<BoardClass>::ReadTmpl" << endl;
//	BoardClass* board = driver->getBoard();
	MtxLock objLock(this->mcMutex);

	asynStatus aStat = asynError;
		cout << "Calling read function for parameter " << this->bvapParName << endl;
//		this->bapValue = ((*board).*(this->bvapReadFun))();
	this->bapValue = this->bapReadFunc(channel);
	cout << "Setting Digital param" << endl;
	aStat = driver->setUIntDigitalParam(channel, this->bvapParNum, this->bapValue, *mask, *mask);
	*(static_cast<epicsUInt32*>(valPtr)) = this->bapValue;
	return aStat;
}


//==========================================================================================================
// Specialized for double type parameters
//==========================================================================================================

template <typename BoardClass>
boardAsynParDouble<BoardClass>::boardAsynParDouble(string parName, int parNum,
		boost::function<epicsFloat64 (unsigned)> readFun,
		boost::function<epicsFloat64 (unsigned, epicsFloat64 )> writeFun,
		epicsUInt32 mask ) :
		boardAsynPar<epicsFloat64, BoardClass>( parName, parNum, readFun, writeFun, mask ) {
	cout << "Received read function " << readFun << endl;
	cout << "Kept read function " << this->bapReadFunc << endl;
	return;
}


// Specialized method for Double to create the  parameter for the driver passed by the argument.
// This method is expected to be called from the AsynDriver constructor
template <typename BoardClass>
void boardAsynParDouble<BoardClass>::Connect2Driver( asynDrvBoard<BoardClass>* driver ) {
//	cout << "Inside boardAsynPar<epicsFloat64>::Connect2Driver" << endl;
	MtxLock objLock(this->mcMutex);
	driver->createParam( this->bvapParName.c_str(), asynParamFloat64, &this->bvapParNum ) ;
	return;
}


// Specialized for double method to write asyn parameter
template<typename BoardClass>
asynStatus boardAsynParDouble<BoardClass>::WriteTmpl(
		asynDrvBoard<BoardClass>* driver, unsigned channel, void* valPtr,
		epicsUInt32 mask) {
//	cout << "Inside boardAsynParDouble>::WriteTmpl" << endl;
//	BoardClass* board = driver->getBoard();
	MtxLock objLock(this->mcMutex);
	asynStatus aStat = asynError;

	epicsFloat64 value = *static_cast<epicsFloat64*>(valPtr);
	cout << "Setting epicsFloat64 parameter " << this->bvapParName << " to " << value << endl;

//	this->bapWriteFunc( channel, value );
//		( (*board).*(this->bvapWriteFun) ) ( value );
	aStat = driver->setDoubleParam(channel, this->bvapParNum, value );
	return aStat;
}

// Specialized for UInt32 to read asyn parameter
template<typename BoardClass>
asynStatus boardAsynParDouble<BoardClass>::ReadTmpl(
		asynDrvBoard<BoardClass>* driver, unsigned channel, void* valPtr,
		epicsUInt32* mask) {
//	BoardClass* board = driver->getBoard();
	MtxLock objLock(this->mcMutex);

	asynStatus aStat = asynError;

//	if( this->bapValue ) {
//		this->bapValue = this->bapReadFunc(channel);
//	}
	this->bapValue = this->bapReadFunc(channel);

	aStat = driver->setDoubleParam(channel, this->bvapParNum, this->bapValue );
	// Set the alarm status and severity for this parameter
	if( ! this->bapAlarmStatusFunc.empty() ) {
		aStat = driver->setParamAlarmStatus(channel, this->bvapParNum,  this->bapAlarmStatusFunc(channel) );
	}
	if( ! this->bapAlarmSeverityFunc.empty() ) {
		aStat = driver->setParamAlarmSeverity(channel, this->bvapParNum,  this->bapAlarmSeverityFunc(channel) );
	}

	*(static_cast<epicsFloat64*>(valPtr)) = this->bapValue;
	return aStat;
}



#endif /* __BOARD_ASYNPAR_HH__ */