#include <iostream>
#include <math.h>
#include <stdlib.h>

#include "Rtypes.h"
#include "TCanvas.h"
#include "TF1.h"
#include "TFile.h"
#include "TPaveStats.h"
#include "TROOT.h"
#include "TRandom.h"
#include "TRef.h"
#include "TStyle.h"
#include "TTree.h"
#include <Compression.h>

/*
// #ifdef __CINT__
#if defined(__ROOTCLING__)

#pragma link off all globals;
#pragma link off all classes;
#pragma link off all functions;

#pragma link C++ class Event + ;
#pragma link C++ class calib + ;
#pragma link C++ class calibelem + ;

#endif
*/

using namespace std;

#define NJINF 2
#define NTDRS 9
#define NCHAVA 64
#define NVASS 16
#define NVASK 0
#define NCh 1024L

class calib : public TObject {
public:
  float ped[NCh];
  float rsig[NCh];
  float sig[NCh];
  int status[NCh];
  bool valid;

  calib() { valid = true; };

  ClassDef(calib, 2)
};

class calibelem : public TObject {
private:
  float value[NCh];

public:
  float &operator[](size_t idx) {
    if (idx >= NCh) {
      printf("Array index out of bound (%lu, %lu). Setting to zero...\n", idx, NCh);
      idx = 0;
    }
    return value[idx];
  }
  const float &operator[](size_t idx) const {
    if (idx >= NCh) {
      printf("Array index out of bound (%lu, %lu). Setting to zero...\n", idx, NCh);
      idx = 0;
    }
    printf("value[%lu] = %f\n", idx, value[idx]);
    return value[idx];
  }

  ClassDef(calibelem, 2)
};

class Event : public TObject {
public:
  static double CalSigma[NJINF][NTDRS][NCHAVA * (NVASS + NVASK)]; //!
  static double CalPed[NJINF][NTDRS][NCHAVA * (NVASS + NVASK)];   //!
  static int CalStatus[NJINF][NTDRS][NCHAVA * (NVASS + NVASK)];   //!

  TRef refCals[NJINF][NTDRS];
  TRef refCalSigma[NJINF][NTDRS];
  TRef refCalPed[NJINF][NTDRS];
  TRef refCalRawSigma[NJINF][NTDRS];

  ClassDef(Event, 3)
};

int reproducer() {

  int complevel = ROOT::CompressionSettings(ROOT::kZLIB, 2);
  printf("The choosen compression level is %d\n", complevel);
  TFile *foutput = new TFile("foutput.root", "RECREATE", "File with the event tree", complevel);

  TTree *t4 = new TTree("t4", "My cluster tree");

  // int bufsize = 64000;
  // int splitlevel = 2;
  int bufsize = 32000;
  int splitlevel = 99;

  Event *ev = new Event();

  t4->Branch("cluster_branch", "Event", &ev, bufsize, splitlevel);

  TBranch *branch = t4->GetBranch("cluster_branch");
  if (branch)
    branch->SetCompressionLevel(6);

  static calib cals[NJINF][NTDRS];
  static calibelem calped[NJINF][NTDRS];
  static calibelem calsig[NJINF][NTDRS];
  static calibelem calrsig[NJINF][NTDRS];

  for (unsigned int iJinf = 0; iJinf < NJINF; ++iJinf) {
    for (unsigned int iTdr = 0; iTdr < NTDRS; ++iTdr) {
      for (unsigned int iCh = 0; iCh < NVASS * NCHAVA; ++iCh) {
        cals[iJinf][iTdr].ped[iCh] = gRandom->Gaus(800, 3);
        cals[iJinf][iTdr].sig[iCh] = gRandom->Uniform(2.5, 3.5);
        cals[iJinf][iTdr].rsig[iCh] = gRandom->Uniform(3.5, 4.5);

        calped[iJinf][iTdr][iCh] = cals[iJinf][iTdr].ped[iCh];
        calsig[iJinf][iTdr][iCh] = cals[iJinf][iTdr].sig[iCh];
        calrsig[iJinf][iTdr][iCh] = cals[iJinf][iTdr].rsig[iCh];
      }
    }
  }

  for (int ii = 0; ii < NJINF; ii++) {
    for (int jj = 0; jj < NTDRS; jj++) {
      t4->GetUserInfo()->Add(&(cals[ii][jj]));
      t4->GetUserInfo()->Add(&(calped[ii][jj]));
      t4->GetUserInfo()->Add(&(calsig[ii][jj]));
      t4->GetUserInfo()->Add(&(calrsig[ii][jj]));
    }
  }

  for (int ii = 0; ii < 1000; ii++) {

    for (unsigned int iJinf = 0; iJinf < NJINF; ++iJinf) {
      for (unsigned int iTdr = 0; iTdr < NTDRS; ++iTdr) {
        for (unsigned int iCh = 0; iCh < NVASS * NCHAVA; ++iCh) {
          ev->refCals[iJinf][iTdr] = &cals[iJinf][iTdr];
          ev->refCalPed[iJinf][iTdr] = &calped[iJinf][iTdr];
          ev->refCalSigma[iJinf][iTdr] = &calsig[iJinf][iTdr];
          ev->refCalRawSigma[iJinf][iTdr] = &calrsig[iJinf][iTdr];
        }
      }
    }

    t4->Fill();
    std::cout << "\rProcessed " << ii << " events" << std::flush;
  }
  printf("\n");

  foutput->cd();
  t4->Write("", TObject::kOverwrite);

  foutput->Write("", TObject::kOverwrite);
  foutput->Close("R");

  return 0;
}