//------------------------------------------------------------------------------------------------------
#include <iostream>
#include <vector>
#include <string>

#include <cstdlib>
#include <cstring>

#include <stdint.h>
#include <algorithm> 
#include <functional> 
#include <cctype>
#include <locale>
#include <sstream>
#include <unistd.h>

#include "sls_receiver_defs.h"
#include "slsReceiverUsers.h"

#include "sls_detector_defs.h"
#include "slsDetectorUsers.h"

#define GOTTHARD_25_TEST
//#define JUNGFRAU_TEST
//#define GOTTHARD_TEST

//======================================================================================================
// test configuration
//======================================================================================================
int      acquisition_nb    = 1; // number of acquisition to make
int      acquisition_nb_ok = 0; // number of correct acquisition
uint64_t last_acquisition_received_frames; // number of received frames during the last acquisition
std::vector <int> acquisition_nb_list;

bool use_trace = false; // activate the acquisition log

//------------------------------------------------------------------------------------------------------
// GOTTHARD 25um
//------------------------------------------------------------------------------------------------------
#ifdef GOTTHARD_25_TEST
    const int receivers_nb = 2; // number of receivers
    const int receivers_rx_tcpport[receivers_nb] = {1954, 1955}; // tcp port for each receiver

    const int detector_id = 0; // detector identifier for slsDetectorUsers constructor
    const std::string detector_config_file_name = "gotthard25.config"; // configuration file name (must be present in the same folder of this application)

    const long        detector_receiver_fifo_depth        = 2500;
    double            detector_exposure_time_sec          = 0.005;
    double            detector_exposure_period_sec        = 0.10;
    const double      detector_delay_after_trigger_sec    = 0.0;
    const std::string detector_trig_mode                  = "auto"; // "auto" or "trigger"
    int64_t           detector_nb_frames_per_cycle        = 10;
    const int64_t     detector_nb_cycles                  = 1;
    int               detector_module_index[receivers_nb] = {0, 1};
#else
//------------------------------------------------------------------------------------------------------
// GOTTHARD
//------------------------------------------------------------------------------------------------------
#ifdef GOTTHARD_TEST
    const int receivers_nb = 1; // number of receivers
    const int receivers_rx_tcpport[receivers_nb] = {1954}; // tcp port for each receiver

    const int detector_id = 0; // detector identifier for slsDetectorUsers constructor
    const std::string detector_config_file_name = "gotthard25.config"; // configuration file name (must be present in the same folder of this application)

    const long        detector_receiver_fifo_depth        = 2500;
    double            detector_exposure_time_sec          = 0.005;
    double            detector_exposure_period_sec        = 0.1;
    const double      detector_delay_after_trigger_sec    = 0.0;
    const std::string detector_trig_mode                  = "auto"; // "auto" or "trigger"
    int64_t           detector_nb_frames_per_cycle        = 10;
    const int64_t     detector_nb_cycles                  = 1;
    int               detector_module_index[receivers_nb] = {0};
#else
//------------------------------------------------------------------------------------------------------
// JUNGFRAU
//------------------------------------------------------------------------------------------------------
#ifdef JUNGFRAU_TEST
    const int receivers_nb = 1; // number of receivers
    const int receivers_rx_tcpport[receivers_nb] = {1954}; // tcp port for each receiver

    const int detector_id = 0; // detector identifier for slsDetectorUsers constructor
    const std::string detector_config_file_name = "jungfrau_nanoscopium_switch.config"; // configuration file name (must be present in the same folder of this application)

    const long        detector_receiver_fifo_depth        = 2500;
    double            detector_exposure_time_sec          = 0.0005;
    double            detector_exposure_period_sec        = 0.001;
    const double      detector_delay_after_trigger_sec    = 0.0;
    const std::string detector_trig_mode                  = "auto"; // "auto" or "trigger"
    int64_t           detector_nb_frames_per_cycle        = 10000;
    const int64_t     detector_nb_cycles                  = 1;
    const int         detector_clock_divider              = 1;
    int               detector_module_index[receivers_nb] = {0};
#endif
#endif
#endif

//------------------------------------------------------------------------------------------------------
// test instances
//------------------------------------------------------------------------------------------------------
std::vector<slsReceiverUsers *> receivers;
slsDetectorUsers * detector = NULL;

//------------------------------------------------------------------------------------------------------
// tools functions
//------------------------------------------------------------------------------------------------------
/** Define Colors to print data call back in different colors for different recievers */
#define PRINT_IN_COLOR(c,f, ...) 	printf ("\033[%dm" f RESET, 30 + c+1, ##__VA_ARGS__)

#define PRINT_SEPARATOR()  	cprintf(RED, "============================================\n")

/************************************************************************
 * \brief cleans the shared memory used by the camera
 ************************************************************************/
void clean_shared_memory()
{
    std::string cmd = "rm /dev/shm/slsDetectorPackage*;";
    std::system(cmd.c_str());
}

/*******************************************************************
 * \brief converts a version id to a string
 * \return version in string format (uppercase & hexa)
 *******************************************************************/
std::string convertVersionToString(int64_t in_version)
{
    std::stringstream tempStream;
    tempStream << "0x" << std::uppercase << std::hex << in_version;
    return tempStream.str();
}

//==================================================================
// Related to commands (put & get)
//==================================================================
/*******************************************************************
 * \brief Converts a standard string to args arguments
 * \param in_command command in command line format
 * \param out_argv output c-strings c-array
 * \param out_argc output number of arguments of out_argv
 *******************************************************************/
void convertStringToArgs(const std::string & in_command,
                         char  * *         & out_argv  ,
                         int               & out_argc  )
{
    out_argv = NULL;
    out_argc = 0   ;

    // filling a string vector with the command line elements
    std::vector<std::string> elements;
    std::stringstream ss(in_command);

	while (ss) 
    {
        std::string element;
		ss >> element;

        if(element.size() > 0)
        {
            elements.push_back(element);
        }
	}

    // setting argc value
    out_argc = elements.size();

    // allocating argv array
	out_argv = new char * [out_argc];
    
    // filling argv array
	for (int element_index = 0; element_index < out_argc; element_index++)
    {
        out_argv[element_index] = new char[elements[element_index].size() + 1]; // adding the allocation of end of c-string 
        strcpy(out_argv[element_index], elements[element_index].c_str()); // copying the string including the eos
    }
}

/*******************************************************************
 * \brief Releases args arguments
 * \param in_out_argv output c-strings c-array*(static_cast<int *>(p))
 * \param in_out_argc output number of arguments of out_argv
 *******************************************************************/
void releaseArgs(char * * & in_out_argv  ,
                 int      & in_out_argc  )
{
    if(in_out_argv != NULL)
    {
        // releasing the c_strings array content
        for (int element_index = 0; element_index < in_out_argc; element_index++)
        {
            delete [] in_out_argv[element_index];
        }

        // releasing the c_strings array
        delete [] in_out_argv;

        in_out_argv = NULL;
        in_out_argc = 0   ;
    }
}

/*******************************************************************
 * \brief Executes a set command
 * \param in_command command in command line format
 * \param in_module_index module index
 * \return the command result
 *******************************************************************/
std::string setCmd(const std::string & in_command, int in_module_index=-1)
{
    std::cout << "setCmd - execute set command:\"" << in_command << "\"" << std::endl;

    char  * *   argv  ;
    int         argc  ;
    std::string result;

    convertStringToArgs(in_command, argv, argc);

    if(argc > 0)
    {
        result = detector->putCommand(argc, argv, in_module_index);
    }

    releaseArgs(argv, argc);

	std::cout << "result=\"" << result << "\"" << std::endl;
    return result;
}

/*******************************************************************
 * \brief Executes a get command
 * \param in_command command in command line format
 * \param in_module_index module index
 * \return the command result
 *******************************************************************/
std::string getCmd(const std::string & in_command, int in_module_index=-1)
{
    std::cout << "getCmd - execute get command:\"" << in_command << "\"" << std::endl;

    char  * *   argv  ;
    int         argc  ;
    std::string result;

    convertStringToArgs(in_command, argv, argc);

    if(argc > 0)
    {
        result = detector->getCommand(argc, argv, in_module_index);
    }

    releaseArgs(argv, argc);

	std::cout << "result=\"" << result << "\"" << std::endl;
    return result;
}

//------------------------------------------------------------------------------------------------------
// Receivers callbacks
//------------------------------------------------------------------------------------------------------
/**
 * Start Acquisition Call back
 * slsReceiver writes data if file write enabled.
 * Users get data to write using call back if registerCallBackRawDataReady is registered.
 * @param filepath file path
 * @param filename file name
 * @param fileindex file index
 * @param datasize data size in bytes
 * @param p pointer to object
 * \returns ignored
 */
int StartAcq(char* filepath, char* filename, uint64_t fileindex, uint32_t datasize, void*p){
	cprintf(BLUE, "#### StartAcq:  filepath:%s  filename:%s fileindex:%llu  datasize:%u ####\n",
			filepath, filename, fileindex, datasize);

	cprintf(BLUE, "--StartAcq: returning 0\n");
    last_acquisition_received_frames = 0LL;
	return 0;
}

/**
 * Acquisition Finished Call back
 * @param frames Number of frames caught
 * @param p pointer to object
 */
void AcquisitionFinished(uint64_t frames, void*p){
	cprintf(BLUE, "#### AcquisitionFinished: frames:%llu ####\n",frames);
    last_acquisition_received_frames = frames;
}

/**
 * Get Receiver Data Call back
 * Prints in different colors(for each receiver process) the different headers for each image call back.
 * @param metadata sls_receiver_header metadata
 * @param datapointer pointer to data
 * @param datasize data size in bytes.
 * @param p pointer to object
 */
void GetData(char* metadata, char* datapointer, uint32_t datasize, void* p)
{
    if(use_trace)
    {
        slsReceiverDefs::sls_receiver_header* header = (slsReceiverDefs::sls_receiver_header*)metadata;
        const slsReceiverDefs::sls_detector_header & detectorHeader = header->detHeader;

        PRINT_IN_COLOR (*(static_cast<int *>(p)),
			        "#### %d GetData: ####\n"
			        "frameNumber: %llu\t\texpLength: %u\t\tpacketNumber: %u\t\tbunchId: %llu"
			        "\t\ttimestamp: %llu\t\tmodId: %u\t\t"
			        "row: %u\t\tcolumn: %u\t\treserved: %u\t\tdebug: %u"
			        "\t\troundRNumber: %u\t\tdetType: %u\t\tversion: %u"
			        //"\t\tpacketsMask:%s"
			        "\t\tfirstbytedata: 0x%x\t\tdatsize: %u\n\n",
                               *(static_cast<int *>(p)),
                                (long long unsigned int)detectorHeader.frameNumber,
                                detectorHeader.expLength, 
                                detectorHeader.packetNumber, 
                                (long long unsigned int)detectorHeader.bunchId,
                                (long long unsigned int)detectorHeader.timestamp,
                                detectorHeader.modId,
			        detectorHeader.row,
                                detectorHeader.column,
                                detectorHeader.reserved,
			        detectorHeader.debug,
                                detectorHeader.roundRNumber,
			        detectorHeader.detType,
			        detectorHeader.version,
			        //header->packetsMask.to_string().c_str(),
			        ((uint8_t)(*((uint8_t*)(datapointer)))),
			        datasize);
    }

    if((datapointer != NULL) && (datasize > 0))
    {
        char * buffer = new char[datasize];
        memcpy(buffer, datapointer, datasize);
        delete [] buffer;
    }
}

//------------------------------------------------------------------------------------------------------
// CreateReceivers
//------------------------------------------------------------------------------------------------------
void CreateReceivers(void)
{
    // preparing the args for receivers creation
    char        temp_port[10];
    const int   argc       = 3;
    char      * args[argc] = {(char*)"slsReceiver", (char*)"--rx_tcpport", temp_port};

    // creating the receivers instances 
    for(int i = 0 ; i < receivers_nb ; i++)
    {
    	int ret = slsReceiverDefs::OK;

        // changing the udp port in the args
        sprintf(temp_port, "%d", receivers_rx_tcpport[i]);

        // creating the receiver using the args
        slsReceiverUsers * receiver = new slsReceiverUsers(argc, args, ret);

        // managing a failed result
        if(ret==slsReceiverDefs::FAIL)
        {
            delete receiver;
            exit(EXIT_FAILURE);
        }

        // adding the receiver to the receivers container
        receivers.push_back(receiver);

        std::cout << "receiver (" << i << ") created - port (" << receivers_rx_tcpport[i] << ")" << std::endl;

        // registering callbacks
        // Call back for start acquisition
        cprintf(BLUE, "Registering StartAcq()\n");
        receiver->registerCallBackStartAcquisition(StartAcq, NULL);

        // Call back for acquisition finished
        cprintf(BLUE, "Registering AcquisitionFinished()\n");
        receiver->registerCallBackAcquisitionFinished(AcquisitionFinished, NULL);

        // Call back for raw data
        cprintf(BLUE, "Registering GetData() \n");
        receiver->registerCallBackRawDataReady(GetData, NULL);//&(detector_module_index[i]));

        // starting tcp server thread
        if (receiver->start() == slsReceiverDefs::FAIL)
        {
            delete receiver;
            cprintf(BLUE,"Could not start receiver (%d)\n", i);
            exit(EXIT_FAILURE);
        }
    }
}

//------------------------------------------------------------------------------------------------------
// ReleaseReceivers
//------------------------------------------------------------------------------------------------------
void ReleaseReceivers(void)
{
    // deleting the receivers instances 
    for(int i = 0 ; i < receivers.size() ; i++)
    {
        slsReceiverUsers * receiver = receivers[i];

		// stoping tcp server thread
        receiver->stop();

        delete receiver;
    }
}

//------------------------------------------------------------------------------------------------------
// CreateDetector
//------------------------------------------------------------------------------------------------------
void CreateDetector(void)
{
    int result;

    // create the detector instance
    detector = new slsDetectorUsers(result, detector_id);

    if(result == slsDetectorDefs::FAIL)
    {
		std::cout << "slsDetectorUsers constructor failed! Could not initialize the camera!" << std::endl;
		exit(EXIT_FAILURE);
    }

    // configuration file is used to properly configure advanced settings in the shared memory
    result = detector->readConfigurationFile(detector_config_file_name);

    if(result == slsDetectorDefs::FAIL)
    {
		std::cout << "readConfigurationFile failed! Could not initialize the camera!" << std::endl;
		exit(EXIT_FAILURE);
    }

	// set detector in shared memory online (in case no config file was used) */
	detector->setOnline(slsDetectorDefs::ONLINE_FLAG);

	// set receiver in shared memory online (in case no config file was used) */
	detector->setReceiverOnline(slsDetectorDefs::ONLINE_FLAG);

    // disabling the file write by the camera
    detector->enableWriteToFile(slsDetectorDefs::DISABLED);

    // logging some versions informations
    std::cout << "Detector developer        : " << detector->getDetectorDeveloper() << std::endl;
    std::cout << "Detector type             : " << detector->getDetectorType() << std::endl;
    std::cout << "Detector Firmware Version : " << convertVersionToString(detector->getDetectorFirmwareVersion()) << std::endl;
    std::cout << "Detector Software Version : " << convertVersionToString(detector->getDetectorSoftwareVersion()) << std::endl;

	// ensuring detector status is idle
	int status = detector->getDetectorStatus();

    if((status != slsDetectorDefs::IDLE) && (status != slsDetectorDefs::STOPPED))
    {
		std::cout << "Detector not ready: " << slsDetectorUsers::runStatusType(status) << std::endl;
		exit(EXIT_FAILURE);
	}
}

//------------------------------------------------------------------------------------------------------
// ReleaseDetector
//------------------------------------------------------------------------------------------------------
void ReleaseDetector(void)
{
    if(detector != NULL)
    {
        detector->setReceiverOnline(slsDetectorDefs::OFFLINE_FLAG);
        detector->setOnline(slsDetectorDefs::OFFLINE_FLAG);

        delete detector;
        detector = NULL;
    }
}

//------------------------------------------------------------------------------------------------------
// RunAcquisition
//------------------------------------------------------------------------------------------------------
int RunAcquisition(void)
{
    std::string trig_mode_label;

    double exposure_time  ;
    double exposure_period;
    double delay_after_trigger;

    int64_t nb_frames_per_cycle;
    int64_t nb_cycles;
    int64_t nb_frames;
#ifdef JUNGFRAU_TEST
    int clock_divider;
#endif
    //----------------------------------------------------------------------------------------------------
    // setting the receiver fifo depth (number of frames in the receiver memory)
    detector->setReceiverFifoDepth(detector_receiver_fifo_depth);

    //----------------------------------------------------------------------------------------------------
    detector->setExposureTime     (detector_exposure_time_sec  , true); // in seconds
    detector->setExposurePeriod   (detector_exposure_period_sec, true); // in seconds
    detector->setDelayAfterTrigger(detector_delay_after_trigger_sec, true); // in seconds

    exposure_time       = detector->setExposureTime     (-1, true); // in seconds
    exposure_period     = detector->setExposurePeriod   (-1, true); // in seconds
    delay_after_trigger = detector->setDelayAfterTrigger(-1, true, 0); // in seconds

    //----------------------------------------------------------------------------------------------------
    // initing the number of frames per cycle and  number of cycles 
    // to avoid problems during the trigger mode change.
    detector->setNumberOfFrames(1);
    detector->setNumberOfCycles(1);

    // conversion of trigger mode label to trigger mode index
    int trigger_mode_index = slsDetectorUsers::getTimingMode(detector_trig_mode);

    // apply the trigger change
    detector->setTimingMode(trigger_mode_index);

    // converting trigger mode index to trigger mode label
    trig_mode_label = slsDetectorUsers::getTimingMode(trigger_mode_index);

    // setting the number of cycles
    nb_cycles = detector->setNumberOfCycles(detector_nb_cycles);

    // setting the number of frames per cycle
    nb_frames_per_cycle = detector->setNumberOfFrames(detector_nb_frames_per_cycle);

    // setting the gain mode
    detector->setSettings(slsDetectorUsers::getDetectorSettings("dynamicgain"));
#ifndef JUNGFRAU_TEST
    detector->setSettings(slsDetectorUsers::getDetectorSettings("mediumgain"));
#else
    detector->setSettings(slsDetectorUsers::getDetectorSettings("dynamichg0"));
#endif
    // computing the number of frames
    nb_frames = nb_cycles * nb_frames_per_cycle;

    //----------------------------------------------------------------------------------------------------
#ifdef JUNGFRAU_TEST
    // clock divider
    detector->setClockDivider(detector_clock_divider);
    clock_divider = detector->setClockDivider(-1);
#endif
    //----------------------------------------------------------------------------------------------------
    std::cout << "receiver fifo depth : " << detector_receiver_fifo_depth << std::endl;
    std::cout << "Exposure time in seconds : " << exposure_time << std::endl;
    std::cout << "Exposure period in seconds : " << exposure_period << std::endl;
    std::cout << "Delay after trigger in seconds : " << delay_after_trigger << std::endl;
    std::cout << "Trigger mode : " << trig_mode_label << std::endl;
    std::cout << "Nb frames per cycle : " << nb_frames_per_cycle << std::endl;
    std::cout << "Nb cycles : " << nb_cycles << std::endl;
    std::cout << "Nb frames : " << nb_frames << std::endl;
#ifdef JUNGFRAU_TEST
    std::cout << "Clock divider : " << clock_divider << std::endl;
#endif
    std::cout << "Estimated frame rate : " << (1.0 / exposure_period) << std::endl;

    //----------------------------------------------------------------------------------------------------
    // reset the number of caught frames in the sdk
    detector->resetFramesCaughtInReceiver();

    //----------------------------------------------------------------------------------------------------
    const unsigned int sleep_time_sec = 1; // sleep the thread in seconds

    // starting receiver listening mode
    if(detector->startReceiver() == slsDetectorDefs::FAIL)
    {
        std::cout << "Could not start the receiver listening mode!" << std::endl;
        return slsDetectorDefs::FAIL;
    }

    // starting real time acquisition in non blocking mode
    // returns OK if all detectors are properly started, FAIL otherwise
    if(detector->startAcquisition() == slsDetectorDefs::FAIL)
    {
        detector->stopReceiver();
        std::cout << "Could not start real time acquisition!" << std::endl;
        return slsDetectorDefs::FAIL;
    }

    for(;;)
    {
        // checking if the hardware acquisition is running
        int status = detector->getDetectorStatus();

        if((status == slsDetectorDefs::IDLE   ) || 
           (status == slsDetectorDefs::STOPPED) ||
           (status == slsDetectorDefs::ERROR  ))
        {
            // we stop the treatment
            break;
        }
        else
        // hardware acquisition is running, we are waiting for new frames not using the cpu during this time
        {
            usleep(sleep_time_sec * 1000 * 1000); // sleep the thread in seconds
        }
    }

    // stopping receiver listening mode
    if(detector->stopReceiver() == slsDetectorDefs::FAIL)
    {
        std::cout << "Could not stop real time acquisition!" << std::endl;
        return slsDetectorDefs::FAIL;
    }
    
    //----------------------------------------------------------------------------------------------------
    PRINT_SEPARATOR();
    std::cout << "receiver fifo depth : " << detector_receiver_fifo_depth << std::endl;
    std::cout << "Exposure time in seconds : " << exposure_time << std::endl;
    std::cout << "Exposure period in seconds : " << exposure_period << std::endl;
    std::cout << "Delay after trigger in seconds : " << delay_after_trigger << std::endl;
    std::cout << "Trigger mode : " << trig_mode_label << std::endl;
    std::cout << "Nb frames per cycle : " << nb_frames_per_cycle << std::endl;
    std::cout << "Nb cyles : " << nb_cycles << std::endl;
    std::cout << "Nb frames : " << nb_frames << std::endl;
#ifdef JUNGFRAU_TEST
    std::cout << "Clock divider : " << clock_divider << std::endl;
#endif
    std::cout << "Estimated frame rate : " << (1.0 / exposure_period) << std::endl;

    if(last_acquisition_received_frames == nb_frames)
    {
        acquisition_nb_ok++;
        return slsDetectorDefs::OK;
    }

    PRINT_SEPARATOR();
    return slsDetectorDefs::FAIL;
}

//------------------------------------------------------------------------------------------------------
// test
//------------------------------------------------------------------------------------------------------
void Test(void)
{
    try
    {
        PRINT_SEPARATOR();
        std::cout << "CreateReceivers" << std::endl;
        PRINT_SEPARATOR();

        CreateReceivers();
        
        PRINT_SEPARATOR();
        std::cout << "CreateDetector" << std::endl;
        PRINT_SEPARATOR();

        CreateDetector();

        PRINT_SEPARATOR();
        std::cout << "RunAcquisition" << std::endl;
        PRINT_SEPARATOR();

        for(int acquisition_index = 0 ; acquisition_index < acquisition_nb ; acquisition_index++)
        {
            cprintf(MAGENTA, "Acquisition number : %d\n", acquisition_index);
            if (RunAcquisition() == slsDetectorDefs::FAIL) {
                acquisition_nb_list.push_back(acquisition_index);
            }
        }
        
        PRINT_SEPARATOR();
        std::cout << "ReleaseDetector" << std::endl;
        PRINT_SEPARATOR();

        ReleaseDetector();
        
        PRINT_SEPARATOR();
        std::cout << "ReleaseReceivers" << std::endl;
        PRINT_SEPARATOR();

        ReleaseReceivers();

        PRINT_SEPARATOR();
        std::cout << "Correct acquisition(s) " << acquisition_nb_ok << "/" << acquisition_nb << std::endl;
        if (acquisition_nb - acquisition_nb_ok) {
            std::cout << "Acquisition(s) gone wrong :" << std::endl;
            for (int list_index = 0; list_index < acquisition_nb_list.size(); ++list_index) {
                std::cout << acquisition_nb_list[list_index] << std::endl;
            }
        }
        PRINT_SEPARATOR();
    }
    catch (...)
    {
        std::cout << "unknown exception!" << std::endl;
		exit(EXIT_FAILURE);
    }
}

std::string roi_result = 
"detector 0:\n"
"0       255     -1      -1\n"
"detector 1:\n"
"1024    1279    -1      -1\n"
"\n"
"xmin    xmax    ymin    ymax\n"
"0       255     -1      -1\n"
"2304    2559    -1      -1\n"
"roi 2\n";

#include <vector>

// use example :
// std::vector<slsReceiverDefs::ROI> rois;
// get_rois_from_string(roi_result, rois);
/*******************************************************************
 * \brief Cuts the string in pieces
 * \param[in] in_string source string
 * \param[in] in_delimitor line delimitor
 * \param[out] out_lines line container result
 *******************************************************************/
void split_string_line(const std::string & in_string, const char in_delimitor, std::vector<std::string> & out_lines)
{
    std::stringstream ss(in_string);
    std::string sub_string;

    while (getline(ss, sub_string, in_delimitor))
    {
        out_lines.push_back(sub_string);
    }
}

/*******************************************************************
 * \brief retrieve the ROIs from a string
 * \param[in] in_rois_string string from "get roi" command
 * \param[out] out_rois ROI container result (empty if no set ROI)
 *******************************************************************/
void get_rois_from_string(const std::string & in_rois_string, std::vector<slsReceiverDefs::ROI> & out_rois)
{
    out_rois.clear();

    try
    {
        // cuts the string in lines
        std::vector<std::string> lines;
        split_string_line(in_rois_string, '\n', lines);

        if(lines.size() >= 1)
        {
            // checks if no ROI ?
            if(lines[0] != "roi 0")
            {
                for(int roi_index = 0 ; roi_index < 2 ; roi_index++)
                {
                    if(lines.size() >= ((roi_index + 1) * 2)) // two lines per ROI definition
                    {
                        std::stringstream detector_name;
                        detector_name << "detector " << roi_index << ":";
                        
                        // checks the first line
                        if(lines[roi_index * 2] == detector_name.str())
                        {
                            std::stringstream ss(lines[(roi_index * 2) + 1]);

                            slsReceiverDefs::ROI roi;
                            ss >> roi.xmin;
                            ss >> roi.xmax;  
                            ss >> roi.ymin;
                            ss >> roi.ymax;

                            out_rois.push_back(roi);
                        }
                    }
                }
            }
        }
    }
    catch(...)
    {
        out_rois.clear();
    }
}

//------------------------------------------------------------------------------------------------------
// read_simple_option
//------------------------------------------------------------------------------------------------------
bool read_simple_option(int argc, char* argv[], const char * in_option_name)
{
    int option_index = 1;

    while(option_index < argc)
    {
        if (strcmp(argv[option_index], in_option_name) == 0)
        {
            std::cout << "Found option:" << in_option_name << std::endl;
            return true;
        }

        option_index++;
    }

    return false;
}

//------------------------------------------------------------------------------------------------------
// read_option_value
//------------------------------------------------------------------------------------------------------
template <typename T> bool read_option_value(int argc, char* argv[], const char * in_option_name, T & out_option_value)
{
    int option_index = 1;

    while(option_index < argc)
    {
        if (strcmp(argv[option_index], in_option_name) == 0)
        {
            option_index++;

            if(option_index < argc)
            {
                std::stringstream ss(std::string(argv[option_index]));
                ss >> out_option_value;
                std::cout << "Found option: " << in_option_name << " " << out_option_value << std::endl;
                return true;
            }
        }

        option_index++;
    }

    return false;
}

//------------------------------------------------------------------------------------------------------
// main
//------------------------------------------------------------------------------------------------------
int main (int argc, char* argv[])
{
    if(read_simple_option(argc, argv, "-help") || read_simple_option(argc, argv, "--help"))
    {
        PRINT_SEPARATOR();
        std::cout << "Options:" << std::endl;
        std::cout << "-clean -> clean shared memory" << std::endl;
        std::cout << "-trace -> activate acquisition log" << std::endl;
        std::cout << "-exp <value> -> set exposure time value in seconds (for example: -exp 0.0005)" << std::endl;
        std::cout << "-period <value> -> set period time value in seconds (for example: -period 0.001)" << std::endl;
        std::cout << "-frames <value> -> set number of frames (for example: -frames 10000)" << std::endl;
        std::cout << "-acq <value> -> set number of acquisition (for example: -acq 10)" << std::endl;
        std::cout << std::endl;
        std::cout << "example: ./manual-acq -clean -trace -acq 1 -exp 0.0005 -period 0.001 -frames 1000" << std::endl;
        PRINT_SEPARATOR();
        return 0;
    }

    if(read_simple_option(argc, argv, "-clean"))
    {
        PRINT_SEPARATOR();
        std::cout << "Cleaning shared memory" << std::endl;
        PRINT_SEPARATOR();

        clean_shared_memory();
    }

    if(read_simple_option(argc, argv, "-trace"))
    {
        PRINT_SEPARATOR();
        std::cout << "Activating acquisition log..." << std::endl;
        PRINT_SEPARATOR();

        use_trace = true;
    }

    int64_t frames_value;

    if(read_option_value(argc, argv, "-frames", frames_value))
    {
        detector_nb_frames_per_cycle = frames_value;
    }

    double exp_value;

    if(read_option_value(argc, argv, "-exp", exp_value))
    {
        detector_exposure_time_sec = exp_value;
    }

    double period_value;

    if(read_option_value(argc, argv, "-period", period_value))
    {
        detector_exposure_period_sec = period_value;
    }

    int acq_nb;

    if(read_option_value(argc, argv, "-acq", acq_nb))
    {
        acquisition_nb = acq_nb;
    }

    Test();

    std::cout << "====================== ENDING ======================" << std::endl;

    return 0;
}

//------------------------------------------------------------------------------------------------------