/*
* ConfigRegister is a interface class between the USBpix-board and the GUIs
* It contains all functionality to handle thee test system configuration and handle the read data
*/

#ifndef CONFIGREGISTER_H
#define CONFIGREGISTER_H

#include "defines.h"
#include "SiUSBLib.h"

#ifdef __VISUALC__
#define  DllExport  __declspec( dllexport )
class DllExport ConfigRegister
#else
class ConfigRegister
#endif
{

public:
	ConfigRegister(SiUSBDevice * Handle, bool isFEI4B);
	//~ConfigRegister();

public:
	void SetUSBHandle(SiUSBDevice * Handle); // sets USB-handle tp current boards. This function needs to be called by the applications, everytime the USB-handle changed (Plug'n'Play)
	void ResetAll(); // sets all registers in the fpga to zero

	// access to FPGA configuration registers
	int ReadRegister(int CS); // read 8bit register, wrapper for ReadXilinx() to protect against accidental misuse
	void WriteRegister(int CS, int data); // write 8bit register, wrapper for WriteXilinx() to protect against accidental misuse

	//---write strb & LV1 registers---------------
	void WriteStrbSave(unsigned char *data); // saves all parameters for injection / LV1 generating state machine
	void WriteStrbStart(); // start measurements / LV1 FSM
	void WriteStrbStop(); // stop measurements / LV1 FSM

	//---write ConfigSM registers-----------------
	void SetCableLengthReg(int value);
	void WriteFEMemBlockRAMReset(); // resets BlockRAM. FE-configurations are stored in the BlockRAM
	void resetRunModeAdd();
	void SetCalibrationMode(); // sets system to calibration mode (HIT-HISTOGRAMMING)
	void SetRunMode(); // sets system to run mode (FULL DATA STORAGE)
	void SetTOTMode(); // sets system to tot mode (TOT-HISTOGRAMMING)
	void SetTLUMode(); // sets system to TLU Mode (FULL DATA Storage + Trigger Number recieved from TLU)
	void WriteStrbQuantity(int value); // writes quantity of generated strobe and LV1 signals
	void enableExtLV1(); // sets TriggerMode to 2 => simple external trigger via LEMO or RJ45
	void disableExtLV1(); // disables external triggers via LEMO (TX0) or ethernet connector
	void setTriggerMode(int TriggerMode); // sets mode for external triggers via LEMO, RJ45 or MULTI_IO pins
	void enableTriggerReplicationMaster(); // enables forwarding of triggers via MULTI_IO pins
	void disableTriggerReplicationMaster(); // disables forwarding of triggers via MULTI_IO pins
	void enable_8b10_Decoding(); // enables decoding
	void disable_8b10_Decoding(); // disables decoding
	void enableCMDLV1(); // sets LV1 generating state machine to CMD mode
	void disableCMDLV1(); // sets LV1 generating state machine to external pad mode
	void enable_160Mbps_data_rate(); // sets system to 160 Mbps data rate
	void disable_160Mbps_data_rate(); // sets system to 40 Mbps data rate
	void EnablePowerChannel(bool on_off, int channel); // disables/enables power channel number "channel", channel defined in defines.h
	void stopXCK(bool status); // stops XCK output
	void SetAuxClkFreq(int freq); // sets auxiliary clk frequency to 40 MHz / n. n is 1 for freq = 0, 2 for freq[0] = 1, 4 for freq[0] = 0 && freq[1] = 1, 8 for freq[0] = 0 && freq[1] = 0 && freq[2] = 1, ...
	void incr_phase_shift(); // increments incoming data synchronization by 1/256 clock duration
	void decr_phase_shift(); // decrements incoming data synchronization by 1/256 clock duration
	bool check_phase_shift_overflow(); // checks for overflow of phase shift
	double StartSyncCheck(double min_BitErrorRate); // starts synchro checker until min_BitErrorRate was achieved
	bool StartSyncScan(double min_BitErrorRate);  // Scans for opimal Sync clk-phase 
	void StoreSyncCheckPattern(); // stores new SyncCheckPattern
	void ResetSyncCheckPattern(); // resets SyncCheckPattern
	void ResetSRAMCounter(); // set SRAM address to 0
	void SetSRAMCounter(int startadd); // set RAM address to any value
	void ReadSRAM(); // reads complete SRAM, further data handling dependent on system mode
	void ReadSRAM(int scan_nr); // reads complete SRAM, further data handling dependent on system mode and fills correct scansteps of ConfData
	void ReadSRAM(int StartAdd, int NumberOfWords); // reads SRAM partially
	void ClearSRAM(); // clears SRAM
	void WriteSRAM(int StartAdd, int NumberOfWords); // writes SRAM, only for debugging purposes needed
	void GetConfHisto(int col, int row, int confstep, int &Value); // writes histogram-value for col, row, step to &Value (needs calibration mode)
	void GetTOTHisto(int col, int row, int tot, int& Value);
	void ClearTOTHisto();
	void ClearConfHisto();
	void GetHitTOTHistoFromRawData(int col, int row, int TOT, int& Value);
	void GetHitHistoFromRawData(int col, int row, int& Value);
	void GetHitLV1HistoFromRawData(int LV1ID, int& Value);
	void ClearHitTOTHistoFromRawData();
	void ClearHitHistoFromRawData();
	void ClearHitLV1HistoFromRawData();

	// cluster histograms
	void GetClusterSizeHistoFromRawData(int Size, int& Value);
	void GetClusterTOTHistoFromRawData(int TOT, int Size, int& Value);
	void GetClusterSeedTOTHistoFromRawData(/*int col, int row, */int TOT, int Size, int& Value);
	void GetClusterSeedLV1HistoFromRawData(int LV1ID, int Size, int& Value);
	void GetClusterSeedHistoFromRawData(int col, int row, int Size, int& Value);
	void GetClusterSeedPerTriggerHistoFromRawData(int Amount, int& Value);
	void ClearClusterSizeHistoFromRawData();
	void ClearClusterTOTHistoFromRawData();
	void ClearClusterSeedTOTHistoFromRawData();
	void ClearClusterSeedLV1HistoFromRawData();
	void ClearClusterSeedHistoFromRawData();
	void ClearClusterSeedPerTriggerHistoFromRawData();

	bool WriteFileFromRawData(std::string filename, bool new_file = true, bool close_file = true, bool fillSourceScanHistograms = true, bool fillClusterHistograms = true, int max_cluster_col_distance = 1, int max_cluster_row_distance = 2, int max_cluster_depth = 2, int timewalk_threshold_max = 15); // new raw data format, human & machine readable file format
	bool FileSaveRB(const char *filename, int event_quant, bool attach_data); // old raw data format
	bool CheckDataConsisty(const char * filename, bool attach_data, bool write_summary);
	bool WriteToTHisto(const char *filename);
	bool WriteConfHisto(const char *filename);
	void GetSourceScanStatus(bool &SRAMFull, bool &MeasurementRunning, int &SRAMFillLevel, int &CollectedEvents, int &TriggerRate);
	void BuildWords(); // in run mode: makes array of words out of character array
	bool WriteSRAMWords(char* filename);
	bool WriteSRAMBitsFromWords(char *filename);
	bool WriteSRAMBytes(char* filename);
	bool WriteSRAMBitsFromBytes(char *filename);
	void GetSystemMode(bool &CalMode, bool &TOTMode);
	void SetMeasurementMode(int mode); // selects which events to count (LV1, DH, DR...)
	void StartMeasurement();
	void StopMeasurement();
	void PauseMeasurement();
	void ResumeMeasurement();
	void SetNumberOfEvents(int data);
	int GetCountedEvents();
	void GetScanStatus(bool & scanReady, bool & scanCancelled, bool & scanError, int & scanStep);
	void SetScanReady();
	void SetScanCancelled();
	void SetScanError();
	void ResetScanStatus();
	int GetCurrentPhaseshift();
	void SetCurrentPhaseshift(int value);
	bool CheckRX0State();
	bool CheckRX1State();
	bool CheckRX2State();
	bool CheckExtTriggerState();
	void GetSyncScanResult(double* dataX, double* dataY, int size);
	void GetSRAMWordsRB(unsigned int* data, int size);



	// member variables for scan status
	bool m_scanReady;
	bool m_scanCancelled;
	bool m_scanError;
	int m_scanStep;

private:
	SiUSBDevice * myUSB;

	int ConfHisto[80][336][1024];
	int TOTHisto[80][336][16];

	int current_phaseshift;

	unsigned char SRAMdata[SRAM_BYTESIZE]; // write buffer
	unsigned char SRAMdataRB[SRAM_BYTESIZE]; // read buffer

	void MakeConfHisto(int scan_nr); // makes hit histogram in scan mode / calib mode
	void MakeTOTHisto(); // makes TOT histogram in TOT mode

	bool isCalMode;
	bool isTOTMode;

	unsigned int SRAMwordsRB[SRAM_WORDSIZE]; // read buffer, 32-bit words

	double SyncScanResultsX[201];
	double SyncScanResultsY[201];

	int total_trigger_counter;
	int total_valid_bcid_window;
	int	total_no_dr_counter;
	int total_dr_counter;
	int total_hit_counter;
	int total_dh_counter;
	int m_lengthLVL1;
	int bcid_window_trigger_number;
	int total_processing_time;

	int HitHistoFromRawData[80][336];
	int HitTOTHistoFromRawData[80][336][16];
	int HitLV1HistoFromRawData[16];

	// cluster methods and data arrays
	bool HitIsSeed(int seed_col, int seed_row, int seed_eoe, int max_cluster_depth, int col_start = 0, int col_end = 79, int row_start = 0, int row_end = 335);
	bool FindNextSeed(int& seed_col, int& seed_row, int eoe, int max_cluster_depth, int col_start = 0, int col_end = 79, int row_start = 0, int row_end = 335);
	void Clustering(int max_cluster_col_distance, int max_cluster_row_distance, int max_cluster_depth, int timewalk_threshold_max, int& bcid_window_cluster_counter);
	void AdvancedClustering(int seed_col, int seed_row, int seed_eoe, int eoe_start, int max_cluster_col_distance, int max_cluster_row_distance, int max_cluster_depth, int timewalk_threshold_max, int bcid_window_cluster_number);
	bool Collision(int eoe, int bcid_window_cluster_number);
	void SeedNeighbours(int seed_col, int seed_row, int seed_eoe, int eoe_start, int max_cluster_depth, int& cluster_size, int& cluster_tot);
	int ClusterSizeHistoFromRawData[16];
	int ClusterTOTHistoFromRawData[16][16];
	int ClusterSeedTOTHistoFromRawData/*[80][336]*/[16][16];
	int ClusterSeedLV1HistoFromRawData[16][16];
	int ClusterSeedHistoFromRawData[80][336][16];
	int ClusterSeedPerTriggerHistoFromRawData[16];
	int bcid_window_tot_array[80][336][16];
	bool bcid_window_hit_array[80][336][16];
	int bcid_window_hit_cluster_number[80][336][16];
	int bcid_window_seed_cluster_number[80][336][16];
	int bcid_window_hit_collision_cluster_number[80][336][16];
	bool seed_neighbours_hit_processed_array[80][336][16];

	time_t start_time;
	time_t stop_time;

	int nr_SR_detected;
	int nr_DH_inconsistent;
	int nr_DR_wo_DH;
	int nr_lv1_jumps;
	int nr_bcid_jumps;

	bool FEI4B; // Is set in constructor, if FE flavor is FEI4B.

	void write_debug_file();

	void FillHistosFromRawData();
};

#endif // CONFIGREGISTER_H