// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#ifndef JUNGFRAULGADSTRIXELSDATA_H
#define JUNGFRAULGADSTRIXELSDATA_H
#ifdef CINT
#include "sls/sls_detector_defs_CINT.h"
#else
#include "sls/sls_detector_defs.h"
#endif
#include "slsDetectorData.h"

// #define VERSION_V2
/**
    @short  structure for a Detector Packet or Image Header
    @li frameNumber is the frame number
    @li expLength is the subframe number (32 bit eiger) or real time exposure
   time in 100ns (others)
    @li packetNumber is the packet number
    @li bunchId is the bunch id from beamline
    @li timestamp is the time stamp with 10 MHz clock
    @li modId is the unique module id (unique even for left, right, top, bottom)
    @li xCoord is the x coordinate in the complete detector system
    @li yCoord is the y coordinate in the complete detector system
    @li zCoord is the z coordinate in the complete detector system
    @li debug is for debugging purposes
    @li roundRNumber is the round robin set number
    @li detType is the detector type see :: detectorType
    @li version is the version number of this structure format
*/

#include <algorithm>
#include <numeric>
#include <tuple>

namespace strixelSingleChip {
constexpr int nc_rawimg = 1024; // for full images  //256;
constexpr int nr_rawimg = 512;
constexpr int nr_chip = 256;
constexpr int gr = 9;

// Group 1: 25um pitch, groups of 3, 1 column of square pixels
constexpr int g1_ncols{(nc_rawimg - (2 * gr) - 1) / 3}; // 79
constexpr int g1_nrows{((nr_chip / 4) - gr) * 3};       // 165

// Group 2: 15um pitch, groups of 5, 3 columns of square pixels
constexpr int g2_ncols{(nc_rawimg - (2 * gr) - 3) / 5}; // 47
constexpr int g2_nrows{(nr_chip / 4) * 5};              // 320

// Group 3: 18.75um pitch, groups of 4, 2 columns of square pixels (double the
// size of the other groups)
constexpr int g3_ncols{(nc_rawimg - (2 * gr) - 2) / 4}; // 59
constexpr int g3_nrows{(((nr_chip / 4) * 2) - gr) * 4}; // 476

constexpr int nc_strixel =
    2 * gr + 1 + g1_ncols; // group 1 is the "longest" group in x and has one
                           // extra square pixel
constexpr int nr_strixel = 2 * gr + g1_nrows + g2_nrows + g3_nrows;

// chip and group boundaries in ASIC coordinates (pixels at both bounds are
// included in the group) y does NOT take into account the shifts for M408!
constexpr int c1g1_xstart = 256 + gr + 1;          // 266
constexpr int c1g2_xstart = 256 + gr + 3;          // 268
constexpr int c1g3_xstart = 256 + gr + 2;          // 267
constexpr int c1_xend = 255 + 256 - gr;            // 502
constexpr int c1g1_ystart = gr;                    //  9
constexpr int c1g1_yend = 63;                      // 63
constexpr int c1g2_ystart = c1g1_yend + 1;         // 64
constexpr int c1g2_yend = c1g1_yend + 64;          // 127
constexpr int c1g3_ystart = c1g2_yend + 1;         // 128
constexpr int c1g3_yend = c1g2_yend + 2 * 64 - gr; // 246

constexpr int c6_xstart = 256 + 256 + gr;         // 521
constexpr int c6g1_xend = 255 + 2 * 256 - gr - 1; // 757
constexpr int c6g2_xend = 256 + 2 * 256 - gr - 3; // 755
constexpr int c6g3_xend = 256 + 2 * 256 - gr - 2; // 756
constexpr int c6g3_ystart = 256 + gr;             // 265
constexpr int c6g3_yend = 255 + 2 * 64;           // 383
constexpr int c6g2_ystart = c6g3_yend + 1;        // 384
constexpr int c6g2_yend = c6g3_yend + 64;         // 447
constexpr int c6g1_ystart = c6g2_yend + 1;        // 448
constexpr int c6g1_yend = c6g2_yend + 64 - gr;    // 502

// y shift due to faulty bonding (relevant for M408)
constexpr int bond_shift_y = 0; // CHANGE IF YOU CHANGE MODULE!

} // namespace strixelSingleChip

typedef struct {
    uint64_t bunchNumber; /**< is the frame number */
    uint64_t pre;         /**< something */

} jf_header; // Aldo's header

using namespace strixelSingleChip;

class jungfrauLGADStrixelsData : public slsDetectorData<uint16_t> {

  private:
    int iframe;
    int mchip;
    int chip_x0;
    int chip_y0;
    int x0, y0, x1, y1, shifty;
    struct {
      uint16_t xmin;
      uint16_t xmax;
      uint16_t ymin;
      uint16_t ymax;
      int nc;
    } globalROI;

    int getMultiplicator(const int group) {
        int multiplicator;
        switch (group) {
        default:
        case 1:
            multiplicator = 3;
            break;
        case 2:
            multiplicator = 5;
            break;
        case 3:
            multiplicator = 4;
            break;
        }
        return multiplicator;
    }

    void setMappingShifts(const int group) {

        if (mchip == 1) {

            chip_x0 = 256;
            chip_y0 =
                bond_shift_y; // because of bump bonding issues(+1 row)  on M408

            switch (group) {
            default:
            case 1:
                x0 = 10 + chip_x0; // 9 gr + 1 sq pixel
                x1 = 246 + chip_x0;
                y0 = 9 + chip_y0;
                y1 = 63 + chip_y0;
                shifty = 0;
                break;
            case 2:
                x0 = 12 + chip_x0;
                x1 = 247 + chip_x0;
                y0 = 64 + chip_y0;
                y1 = 127 + chip_y0;
                shifty = g1_nrows;
                break;
            case 3:
                x0 = 11 + chip_x0;
                x1 = 247 + chip_x0;
                y0 = 128 + chip_y0;
                y1 = 246 + chip_y0;
                shifty = g2_nrows + g1_nrows;
                break;
            }
        }

        if (mchip == 6) {

            chip_x0 = 512;
            chip_y0 =
                256 - bond_shift_y; // should be 256 but is 255 because of bump
                                    // bonding issues (+1 row) on M408

            switch (group) {
            default:
            case 1:

                x0 = 9 + chip_x0; // 9 gr sq pixel
                x1 = 245 + chip_x0; // was 246
                y0 = 192 + chip_y0;
                y1 = 246 + chip_y0;

                shifty = g1_nrows + 2 * g2_nrows + 2 * g3_nrows;
                break;

            case 2:

                x0 = 9 + chip_x0;
                x1 = 243 + chip_x0; //was 244
                y0 = 128 + chip_y0;
                y1 = 191 + chip_y0;

                shifty = g1_nrows + g2_nrows + 2 * g3_nrows;
                ;
                break;
            case 3:

                x0 = 9 + chip_x0;
                x1 = 244 + chip_x0;
                y0 = 9 + chip_y0;
                y1 = 127 + chip_y0;
                shifty = g1_nrows + g2_nrows + g3_nrows;

                break;
            }
        }
    }

    void remapGroup(const int group) {
        int multiplicator = getMultiplicator(group);
        //int shiftx;
        int ix, iy = 0;

        setMappingShifts(group);

        // remapping loop
        for (int ipy = y0; ipy <= y1; ipy++) {
            for (int ipx = x0; ipx <= x1; ipx++) {

                ix = int((ipx - x0) / multiplicator);
                for (int m = 0; m < multiplicator; m++) {
                    if ((ipx - x0) % multiplicator == m)
                        iy = (ipy - y0) * multiplicator + m + shifty;
                }

                //	  if (iy< 40)	  cout << iy << "  " << ix <<endl;
                dataMap[iy][ix] = sizeof(header) + (nc_rawimg * ipy + ipx) * 2;
                groupmap[iy][ix] = group - 1;
            }
        }
    }


    std::tuple< uint16_t, uint16_t, uint16_t, uint16_t > adjustROItoLimits(uint16_t xmin,
									   uint16_t xmax,
									   uint16_t ymin,
									   uint16_t ymax,
									   uint16_t lim_roi_xmin,
									   uint16_t lim_roi_xmax,
									   uint16_t lim_roi_ymin,
									   uint16_t lim_roi_ymax) {
      uint16_t xmin_roi, xmax_roi, ymin_roi, ymax_roi;
      if ( xmin < lim_roi_xmin)
        xmin_roi = lim_roi_xmin;
      else
        xmin_roi = xmin;
      if ( xmax > lim_roi_xmax )
        xmax_roi = lim_roi_xmax;
      else
        xmax_roi = xmax;
      if ( ymin < lim_roi_ymin )
        ymin_roi = lim_roi_ymin;
      else
        ymin_roi = ymin;
      if ( ymax > lim_roi_ymax )
        ymax_roi = lim_roi_ymax;
      else
        ymax_roi = ymax;
      return std::make_tuple(xmin_roi, xmax_roi, ymin_roi, ymax_roi);
    }

    std::vector < std::tuple< int, int, uint16_t, uint16_t, uint16_t, uint16_t > > mapSubROIs(uint16_t xmin,
											      uint16_t xmax,
											      uint16_t ymin,
											      uint16_t ymax) {
      bool chip_1_1 = false;
      bool chip_1_2 = false;
      bool chip_1_3 = false;
      bool chip_6_1 = false;
      bool chip_6_2 = false;
      bool chip_6_3 = false;

      for ( int x=xmin; x!=xmax+1; ++x ) {
	for ( int y=ymin; y!=ymax; ++y ) {
	  if ( c1g1_xstart<=x && x<=c1_xend && (c1g1_ystart+bond_shift_y)<=y && y<=(c1g1_yend+bond_shift_y) )
	    chip_1_1 = true;
	  if ( c1g2_xstart<=x && x<=c1_xend && (c1g2_ystart+bond_shift_y)<=y && y<=(c1g2_yend+bond_shift_y) )
	    chip_1_2 = true;
	  if ( c1g3_xstart<=x && x<=c1_xend && (c1g3_ystart+bond_shift_y)<=y && y<=(c1g3_yend+bond_shift_y) )
	    chip_1_3 = true;
	  if ( c6_xstart<=x && x<=c6g1_xend && (c6g1_ystart-bond_shift_y)<=y && y<=(c6g1_yend-bond_shift_y) )
	    chip_6_1 = true;
	  if ( c6_xstart<=x && x<=c6g2_xend && (c6g2_ystart-bond_shift_y)<=y && y<=(c6g2_yend-bond_shift_y) )
	    chip_6_2 = true;
	  if ( c6_xstart<=x && x<=c6g3_xend && (c6g3_ystart-bond_shift_y)<=y && y<=(c6g3_yend-bond_shift_y) )
	    chip_6_3 = true;
	}
      }

      uint16_t xmin_roi{}, xmax_roi{}, ymin_roi{}, ymax_roi{};
       //[ chip, group, xmin, xmax, ymin, ymax ]
      std::vector < std::tuple< int, int, uint16_t, uint16_t, uint16_t, uint16_t > > rois{};

      if (chip_1_1) {
	std::tie( xmin_roi, xmax_roi, ymin_roi, ymax_roi ) =
	  adjustROItoLimits( xmin, xmax, ymin, ymax,
			     c1g1_xstart, c1_xend, 0, c1g1_yend+bond_shift_y );
	rois.push_back( std::make_tuple( 1, 1, xmin_roi, xmax_roi, ymin_roi, ymax_roi ) );
      }
      if (chip_1_2) {
	std::tie( xmin_roi, xmax_roi, ymin_roi, ymax_roi ) =
	  adjustROItoLimits( xmin, xmax, ymin, ymax,
			     c1g2_xstart, c1_xend, c1g2_ystart+bond_shift_y, c1g2_yend+bond_shift_y );
	rois.push_back( std::make_tuple( 1, 2, xmin_roi, xmax_roi, ymin_roi, ymax_roi ) );
      }
      if (chip_1_3) {
	std::tie( xmin_roi, xmax_roi, ymin_roi, ymax_roi ) =
	  adjustROItoLimits( xmin, xmax, ymin, ymax,
			     c1g3_xstart, c1_xend, c1g3_ystart+bond_shift_y, c1g3_yend+bond_shift_y );
	rois.push_back( std::make_tuple( 1, 3, xmin_roi, xmax_roi, ymin_roi, ymax_roi ) );
      }
      if (chip_6_3) {
	std::tie( xmin_roi, xmax_roi, ymin_roi, ymax_roi ) =
	  adjustROItoLimits( xmin, xmax, ymin, ymax,
			     c6_xstart, c6g3_xend, c6g3_ystart-bond_shift_y, c6g3_yend-bond_shift_y );
	rois.push_back( std::make_tuple( 6, 3, xmin_roi, xmax_roi, ymin_roi, ymax_roi ) );
      }
      if (chip_6_2) {
	std::tie( xmin_roi, xmax_roi, ymin_roi, ymax_roi ) =
	  adjustROItoLimits( xmin, xmax, ymin, ymax,
			     c6_xstart, c6g2_xend, c6g2_ystart-bond_shift_y, c6g2_yend-bond_shift_y );
	rois.push_back( std::make_tuple( 6, 2, xmin_roi, xmax_roi, ymin_roi, ymax_roi ) );
      }
      if (chip_6_1) {
	std::tie( xmin_roi, xmax_roi, ymin_roi, ymax_roi ) =
	  adjustROItoLimits( xmin, xmax, ymin, ymax,
			     c6_xstart, c6g1_xend, c6g1_ystart-bond_shift_y, 511 );
	rois.push_back( std::make_tuple( 6, 1, xmin_roi, xmax_roi, ymin_roi, ymax_roi ) );
      }

      return rois;

    }

    void remapROI(std::tuple< int, int, uint16_t, uint16_t, uint16_t, uint16_t > roi) {
        // determine group and chip selected by ROI
      int group, xmin, xmax, ymin, ymax;
      std::tie( mchip, group, xmin, xmax, ymin, ymax ) = roi;
	/*
        if (ymax <= c1g1_yend + bond_shift_y) {
            group = 1;
            mchip = 1;
        } else if (ymax <= c1g2_yend + bond_shift_y) {
            group = 2;
            mchip = 1;
        } else if (ymax <= c1g3_yend + bond_shift_y) {
            group = 3;
            mchip = 1;
        } else if (ymax <= c6g3_yend - bond_shift_y) {
            group = 3;
            mchip = 6;
        } else if (ymax <= c6g2_yend - bond_shift_y) {
            group = 2;
            mchip = 6;
        } else if (ymax <= c6g1_yend - bond_shift_y) {
            group = 1;
            mchip = 6;
	} else if (ymax <= 511) {
            group = 1;
            mchip = 6;
        } else { //to fix compiler warning
	  group = -1;
	  mchip = -1;
	}
	*/
      int multiplicator = getMultiplicator(group);
      setMappingShifts(group);
      
      std::cout << "remapping chip: " << mchip << ", group: " << group << ", m: " << multiplicator
		<< ", x0: " << x0 << ", x1: " << x1 << ", y0: " << y0
		<< ", y1: " << y1 << std::endl;
      std::cout << "Adjusted roi: [" << xmin << ", " << xmax << ", " << ymin << ", " << ymax << "]" << std::endl;

        // make sure loop bounds are correct
	/*
        if (y0 < ymin)
            std::cout << "Error ymin" << std::endl;
        if (y1 > ymax)
            std::cout << "Error ymax - normal for G3 since ROI only 64 row"
                      << std::endl;
        if (x0 < xmin)
            std::cout << "Error xmin" << std::endl;
        if (x1 > xmax)
            std::cout << "Error xmax" << std::endl;
	*/

        // remapping loop
      int ix, iy = 0;
      for (int ipy = y0; ipy <= y1; ++ipy) {
	for (int ipx = x0; ipx <= x1; ++ipx) {

	  ix = int((ipx - x0 /*-xmin*/) / multiplicator);
	  for (int m = 0; m < multiplicator; m++) {
	    if ((ipx - x0 /*-xmin*/) % multiplicator == m)
	      iy = (ipy - y0 /*-ymin*/) * multiplicator + m + shifty;
	  }
	  
	  //	  if (iy< 40)	  cout << iy << "  " << ix <<endl;
	  if ( ipx>=xmin && ipx<=xmax && ipy>=ymin && ipy <=ymax )
	    dataMap[iy][ix] =
	      sizeof(header) + (globalROI.nc * (ipy - globalROI.ymin) + (ipx - globalROI.xmin)) * 2;
	  else dataMap[iy][ix] = sizeof(header);
	  groupmap[iy][ix] = group - 1;
	}
      }
    }

  public:
    int groupmap[512 * 5][1024 / 3];

    using header = sls::defs::sls_receiver_header;

    jungfrauLGADStrixelsData(uint16_t xmin = 0, uint16_t xmax = 0,
                             uint16_t ymin = 0, uint16_t ymax = 0)
        : slsDetectorData<uint16_t>(
              /*nc_strixel*/ g1_ncols,
              /*nr_strixel*/ 2 * g1_nrows + 2 * g2_nrows + 2 * g3_nrows,
              g1_ncols * (2 * g1_nrows + 2 * g2_nrows + 2 * g3_nrows) * 2 +
                  sizeof(header)) {
        std::cout << "Jungfrau strixels 2X single chip with full module data "
                  << std::endl;

        // Fill all strixels with dummy values
        for (int ix = 0; ix != g1_ncols; ++ix) {
            for (int iy = 0; iy != 2 * g1_nrows + 2 * g2_nrows + 2 * g3_nrows;
                 ++iy) {
                dataMap[iy][ix] = sizeof(header);
            }
        }

	globalROI.xmin = xmin;
	globalROI.xmax = xmax;
	globalROI.ymin = ymin;
	globalROI.ymax = ymax;

        std::cout << "sizeofheader = " << sizeof(header) << std::endl;
        std::cout << "Jungfrau strixels 2X single chip with full module data "
                  << std::endl;

        if (xmin < xmax && ymin < ymax) {

	  // get ROI raw image number of columns
	  globalROI.nc = xmax - xmin + 1;
	  std::cout << "nc_roi = " << globalROI.nc << std::endl;
	  
	  dataSize =
	    (xmax - xmin + 1) * (ymax - ymin + 1) * 2 + sizeof(header);
	  std::cout << "datasize " << dataSize << std::endl;

	  //[ chip, group, xmin, xmax, ymin, ymax ]
	  auto rois = mapSubROIs(xmin, xmax, ymin, ymax);
	  //function to fill vector of rois from globalROI

	  for ( auto roi : rois )
	    remapROI(roi);

        } else {

            mchip = 1;
	    for (int group=1; group!=4; ++group)
	      remapGroup(group);

            mchip = 6;
	    for (int group=1; group!=4; ++group)
	      remapGroup(group);

        }

        iframe = 0;
        std::cout << "data struct created" << std::endl;
    };

    /**
       Returns the value of the selected channel for the given dataset as
       double. \param data pointer to the dataset (including headers etc) \param
       ix pixel number in the x direction \param iy pixel number in the y
       direction \returns data for the selected channel, with inversion if
       required as double

    */
    virtual double getValue(char *data, int ix, int iy = 0) {

        uint16_t val = getChannel(data, ix, iy) & 0x3fff;
        return val;
    };

    /**

    Returns the frame number for the given dataset. Purely virtual func.
    \param buff pointer to the dataset
    \returns frame number

    */

    int getFrameNumber(char *buff) {
#ifdef ALDO                                      // VH
        return ((jf_header *)buff)->bunchNumber; // VH
#endif                                           // VH
        return ((header *)buff)->detHeader.frameNumber;
    };

    /**

       Returns the packet number for the given dataset. purely virtual func
       \param buff pointer to the dataset
       \returns packet number number



    */
    int getPacketNumber(char *buff) {
#ifdef ALDO // VH
        // uint32_t fakePacketNumber = 1000;
        // return fakePacketNumber; //VH //TODO: Keep in mind in case of bugs!
        // //This is definitely bad!
        return 1000;
#endif // VH
        return ((header *)buff)->detHeader.packetNumber;
    };

    char *readNextFrame(std::ifstream &filebin) {
        int ff = -1, np = -1;
        return readNextFrame(filebin, ff, np);
    };

    char *readNextFrame(std::ifstream &filebin, int &ff) {
        int np = -1;
        return readNextFrame(filebin, ff, np);
    };

    char *readNextFrame(std::ifstream &filebin, int &ff, int &np) {
        char *data = new char[dataSize];
        char *d = readNextFrame(filebin, ff, np, data);
        if (d == NULL) {
            delete[] data;
            data = NULL;
        }
        return data;
    };

    char *readNextFrame(std::ifstream &filebin, int &ff, int &np, char *data) {
      //char *retval = 0;
      //int nd;
      //int fnum = -1;
        np = 0;
        //int pn;

        //std::cout << dataSize << std::endl;
        //if (ff >= 0) {
          //  fnum = ff; }

        if (filebin.is_open()) {
            if (filebin.read(data, dataSize)) {
                std::cout << "*";
                ff = getFrameNumber(data);
                np = getPacketNumber(data);
                return data;
            }
	    std::cout << "#";
        } else {
	  std::cout << "File not open" << std::endl;
	}
        return NULL;
    };

    /*    Loops over a memory slot until a complete frame is found (i.e. all */
    /*    packets 0 to nPackets, same frame number). purely virtual func \param
     */
    /*    data pointer to the memory to be analyzed \param ndata reference to
     * the */
    /*    amount of data found for the frame, in case the frame is incomplete at
     */
    /*    the end of the memory slot \param dsize size of the memory slot to be
     */
    /*    analyzed \returns pointer to the beginning of the last good frame
     * (might */
    /*    be incomplete if ndata smaller than dataSize), or NULL if no frame is
     */
    /*    found */

    /* *\/ */
    virtual char *findNextFrame(char *data, int &ndata, int dsize) {
        if (dsize < dataSize)
            ndata = dsize;
        else
            ndata = dataSize;
        return data;
    };

    // int getPacketNumber(int x, int y) {return dataMap[y][x]/packetSize;};
};

#endif