/*
 * jlabFADC250Board.hh
 *
 *  Created on: June 16, 2014
 *      Author:
 *
 *      This class provides interface that EPICS support will use to monitor
 *      and control the JLAB discriminator boards.
 *      All methods, including accesssors, need to be thread-safe since they
 *      may be executing simultaneously on multiple threads.
 */

#ifndef _jlabFADC250Board_HH_
#define _jlabFADC250Board_HH_

#include <stdint.h>

#include <iostream>
#include <string>
#include <vector>
#include <map> 

#include "jlabBoard.hh" 
#include "jlabROCSharedMemoryWrapper.hh"

using namespace std;

class jlabFADC250Board : public jlabBoard
{
	public:

		// Constructor. Create FADC250 board object specified by base address
		// Create all channel objects on that board and fill the channel vector. 
		// Throws an exception if fails to create the object.
		jlabFADC250Board(uint32_t locSlotNumber, jlabROCSharedMemoryWrapper* locROCSharedMemoryWrapper);

		// Destructor. Destroys this board. 
		virtual ~jlabFADC250Board();
	
		// Return boards type FADC250_v2 or whatever
		virtual string 				GetType();

		// Return the 32-bit status word for this board
		virtual uint32_t			GetStatus();

		// Return the number of channels this board is serving
		static uint32_t				GetNumberOfChannels();

		// Start reading the scaler data for this board from VME bus
		virtual void 				StartScalers( const string scalerType = "" );
		// Stop reading the scaler data for this board from VME bus
		virtual void				StopScalers( const string scalerType = "" );

		// Return scaler values for particular channel for this board, in Hz or raw
			// Time is in seconds
			// Scalar Type: Readout1, Readout2, Trigger1, Trigger2
		virtual vector<double>		GetScalers(uint32_t locChannel, string locScalarType, vector<double>& locTimes, bool locOutputInHzFlag = true);
		virtual double				GetScaler(uint32_t locChannel, string locScalarType, bool locOutputInHzFlag = true);
		// Return clock counts for this board
		virtual vector<double>		GetClockCounts(void);
		
		// Get a vector of thresholds for a particular type of thresholds
		virtual vector<double>		GetThresholds( const string threshType );
		// Get the values of threshold for a single channel of a particular threshold type
		virtual double				GetThreshold( const unsigned chanNumb, const string threshType );

		// Set thresholds for particular type of thresholds for all channels
		virtual void				SetThresholds( const double threshold, const string threshType = "" );
		// Set thresholds for particular type of threshold for a single channel
		virtual void 				SetThreshold(uint32_t locChannelNumber, const double threshold, const string threshType );

		// Return the histogram for energy spectrum for a particular channel
		vector<double>				GetSpectrum( const unsigned chanNumb );

		void Set_Data(F250_Scalers locInputScalars);

	protected:
		// Prevent copying boards
		jlabFADC250Board(const jlabFADC250Board& board);
		jlabFADC250Board& operator=(const jlabFADC250Board& board);

		static const unsigned dNumChannels = 16;

		// Only access the below within a lock!
		// Time is in seconds, and frequency is in Hz
		// vector<double>: For when data is collected over a period of time (each index one point in time)
		vector<double> dScalarCountTimer_Readout1;
		vector<double> dScalarRateTimer_Readout1;

		vector<double> dScalarCountTimer_Readout2;
		vector<double> dScalarRateTimer_Readout2;

		vector<double> dScalarCountTimer_Trigger1;
		vector<double> dScalarRateTimer_Trigger1;

		vector<double> dScalarCountTimer_Trigger2;
		vector<double> dScalarRateTimer_Trigger2;

		// The keys are the channel number
		map<uint32_t, vector<double> > dScalarCountMap_Readout1;
		map<uint32_t, vector<double> > dScalarRateMap_Readout1;

		map<uint32_t, vector<double> > dScalarCountMap_Readout2;
		map<uint32_t, vector<double> > dScalarRateMap_Readout2;

		map<uint32_t, vector<double> > dScalarCountMap_Trigger1;
		map<uint32_t, vector<double> > dScalarRateMap_Trigger1;

		map<uint32_t, vector<double> > dScalarCountMap_Trigger2;
		map<uint32_t, vector<double> > dScalarRateMap_Trigger2;
};

// DEFINE ME
inline jlabFADC250Board::jlabFADC250Board(uint32_t locSlotNumber, jlabROCSharedMemoryWrapper* locROCSharedMemoryWrapper) : 
jlabBoard(locSlotNumber, locROCSharedMemoryWrapper) {}

// DEFINE ME
inline jlabFADC250Board::~jlabFADC250Board(void) {}

inline string jlabFADC250Board::GetType()
{
	return "FADC250";
}

// DEFINE ME
inline uint32_t jlabFADC250Board::GetStatus()
{
	return 0;
}

// DEFINE ME
inline uint32_t jlabFADC250Board::GetNumberOfChannels()
{
	return dNumChannels;
}

inline void jlabFADC250Board::StartScalers(const string scalerType)
{
	// DEFINE ME
	return;
}

inline void jlabFADC250Board::StopScalers(const string scalerType)
{
	// DEFINE ME
	return;
}

// DEFINE ME
inline vector<double> jlabFADC250Board::GetClockCounts(void)
{
	return vector<double>();
}

// DEFINE ME
inline void jlabFADC250Board::SetThresholds(const double threshold, const string threshType)
{
	return;
}

// DEFINE ME
inline void jlabFADC250Board::SetThreshold(const unsigned chanNumber, const double threshold, const string threshType)
{
	return;
}

// DEFINE ME
inline vector<double> jlabFADC250Board::GetThresholds(const string threshType)
{
	return vector<double>();
}

// DEFINE ME
inline double jlabFADC250Board::GetThreshold(const unsigned chanNumb, const string threshType)
{
	return 0.0;
}

// DEFINE ME
inline vector<double> jlabFADC250Board::GetSpectrum(const unsigned chanNumb)
{
	return vector<double>();
}

#endif /* _jlabFADC250Board_HH_ */