/// merge N events into 1.
  /// to compile: g++ convert.cpp -O3 -Icode/Common -o convert
  /// to run:  convert NMergeEvents NGeneratedEvents OutputDir InputDir. If you want merge 20 events into 10, then print: convert 2 10

#define DEBUG
#define MUTE1
#define MUTE2
 
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <stdio.h> // for atoi
#include <stdlib.h>

using namespace std;


typedef  float fscal;


#include "AliHLTTPCCAMCPoint.h"
#include "AliHLTTPCCAMCTrack.h"
#include "AliHLTTPCCAGBHit.h"
#include "AliHLTTPCPerformanceBase.h"



  char work_dir[100] = "/u/akishina/STT/Data_Panda/1GeV_10tr/";
  char out_dir[100] = "/u/akishina/STT/Data_Panda/Valia/";




struct TData{

  TData(){};
  
  vector<AliHLTTPCCAGBHit> vHits;
  vector<AliHLTTPCCALocalMCPoint> vMCPoints;  
  vector<AliHLTTPCCAMCTrack> vMCTracks; 
  vector<AliHLTTPCPerformanceBase::AliHLTTPCCAHitLabel> vHitLabel;
 
  
  bool ReadDataFromFiles(string prefix);
  bool ReadHitsFromFile(string prefix);
  bool WriteDataToFiles(string prefix);
  bool WriteHitsToFile(string prefix);
  void Add(TData& data_new, int iEv);
  void Reserve(TData& data_new);
  void SetNHits( int nHits )
   {
  //* set the number of hits
  vHits.resize( nHits );
 // fNHits = nHits;
   }
};

void TData::Reserve(TData& data_new)
{

// vHits.size() = vHits.size() + data_new.vHits.size();
// vMCPoints.size() =+ data_new.vMCPoints.size();
// vMCTracks.size() =+ data_new.vMCTracks.size();
// vHitLabel.size() =+ data_new.vHitLabel.size(); 
//   const int k = 1.2*nEv;
//   
// #define res(AAAA) AAAA.reserve(AAAA.size()*k)
//   
//   res(vStsStrips);
//   res(vStsStripsB);
//   res(vStsHits);
//   res(vSFlag);
//   res(vSFlagB);
//   res(vMCPoints);
//   res(vMCTracks);
//   res(vHitMCRef);
//   res(vHitStore);
//   res(vStsHitsPerfo);
// #undef res
}


void TData::Add(TData& data_new, int iEv)
{

  int Tracks = vMCTracks.size();
  int Hits = vHits.size();
  int Points = vMCPoints.size();
  
for (unsigned int i = 0; i < data_new.vHits.size(); i++)
{AliHLTTPCCAGBHit &p = data_new.vHits[i];
     p.SetID( p.ID()+Hits);
//  p.SetEvN(iEv);
  vHits.push_back(data_new.vHits[i]);
 
}
	 cout <<  " vHits.push_back"<<endl;
   
   
  for (unsigned int i = 0; i < data_new.vMCPoints.size(); i++){
    
    
  
     AliHLTTPCCALocalMCPoint &p = data_new.vMCPoints[i];
      p.SetTrackID(p.TrackID()+Tracks);
      p.SetTrackI(p.TrackI()+Tracks);

      //p.SetEvN(iEv);
      vMCPoints.push_back(data_new.vMCPoints[i]);
      }
		 cout <<  " vMCPoints.push_back"<<endl;
  
     
     for (unsigned int i = 0; i < data_new.vMCTracks.size(); i++){
     
     
     AliHLTTPCCAMCTrack &p = data_new.vMCTracks[i];
      p.SetFirstMCPointID(p.FirstMCPointID ()+Points);
      //p.SetEvN(iEv);
      vMCTracks.push_back(data_new.vMCTracks[i]);
     }
	   cout <<  " vMCTracks.push_back"<<endl;
 
   for (unsigned int i = 0; i < data_new.vHitLabel.size(); i++){
   
  
      AliHLTTPCPerformanceBase::AliHLTTPCCAHitLabel &p = data_new.vHitLabel[i];
    
      for (unsigned int j = 0; j < 3; j++){
        if (p.fLab[j]==-1) continue;
        p.fLab[j] += Tracks;
      }
      
       vHitLabel.push_back(data_new.vHitLabel[i]);
   }
 cout <<  " vHitLabel.push_back"<<endl;
}



void ReadStAPAlgoData(TData &data)
{
  
    data.vHits.clear();
    data.vMCPoints.clear();
    data.vMCTracks.clear();
    data.vHitLabel.clear();
    
#ifndef MUTE0
  cout <<  " ReadStAPAlgoData"<<endl;
#endif
  static int iEvent = 1;

  
  { 
    char buf[6];
    sprintf( buf, "%d", iEvent-1 );
    const string fileName = work_dir + string("event") + string(buf) + string("_");
  


   
   
    
    data.ReadHitsFromFile(fileName);
    data.ReadDataFromFiles(fileName);

   
    
  }

  iEvent++;
}

     

void WriteStAPAlgoData(TData &data_out)  // must be called after ReadEvent
    
{
   static int vNEvent = 1;
   { 
    char buf[6];
    sprintf( buf, "%d", vNEvent-1 );
    const string fileName = out_dir + string("event") + string(buf) + string("_");

    data_out.WriteHitsToFile(fileName);
    data_out.WriteDataToFiles(fileName);
    
   
  

  
   }
  vNEvent++;
}



  
int main(int argc, char *argv[])
{
  int NMergeEvents = 2;
  int NEvents = 1;

  if (argc >= 2){
    NMergeEvents = atoi(argv[1]);
  }

  if (argc >= 3){
    NEvents = atoi(argv[2]);
  }

  if (argc >= 4){
    strcpy(out_dir,argv[3]);
  }

  if (argc >= 5){
    strcpy(work_dir,argv[4]);
  }
  std::cout << " Create " << NEvents << " groups of events. " << NMergeEvents << " events in group " << std::endl;
  std::cout << " Output Dir = " << out_dir << std::endl;
  std::cout << " Input  Dir = " << work_dir << std::endl;
 
  
  for (int igEv = 0; igEv < NEvents; igEv++ ){
    TData data;
    TData data_out;

    ReadStAPAlgoData(data);
  
    data_out = data;
  
   
    
    for (int iEv = 1; iEv < NMergeEvents; iEv++ ){
      ReadStAPAlgoData(data);
	  data_out.Reserve(data);
      data_out.Add(data,iEv);
     cout<<"ADD!!"<<endl;
    }

    std::sort( data_out.vHits.begin(), data_out.vHits.end(), AliHLTTPCCAGBHit::Compare );
    vector<AliHLTTPCPerformanceBase::AliHLTTPCCAHitLabel> vHitLabelSorted(data_out.vHitLabel.size());
    for(int iH=0; iH<data_out.vHits.size(); iH++){
      int currentHitID = data_out.vHits[iH].ID();
      vHitLabelSorted[iH] = data_out.vHitLabel[currentHitID];
      data_out.vHits[iH].SetID(iH);
    }
    data_out.vHitLabel = vHitLabelSorted;

    WriteStAPAlgoData(data_out);
    
  } // igEv
  
  return 1;
}


   

bool TData::ReadHitsFromFile(string prefix)
{


    static ifstream ifile;
	ifile.open((prefix+"hits.data").data());
    if ( !ifile.is_open() ) return 0;
    int Size;
	
    ifile >> Size;
	cout<<Size<<"SizeHitsRead"<<endl;
    vHits.resize(Size);   
    SetNHits(Size);
	
    for (int i = 0; i < Size; i++){
      AliHLTTPCCAGBHit &l = vHits[i];
      ifile >> l;
	
    }
    ifile.close();
    return 1;
}

bool TData::ReadDataFromFiles(string prefix)
 {
 

  {
    ifstream ifile((prefix+"hitLabels.data").data());
    if ( !ifile.is_open() ) return 0;
    int Size;
    ifile >> Size;
	 cout<<Size<<"SizeLabRead"<<endl;
    vHitLabel.resize(Size);
    for (int i = 0; i < Size; i++){
      AliHLTTPCPerformanceBase::AliHLTTPCCAHitLabel &l = vHitLabel[i];
      ifile >> l;
    }
    ifile.close();
  }

  {
    ifstream ifile((prefix+"MCTracks.data").data());
    if ( !ifile.is_open() ) return 0;
    int Size;
    ifile >> Size;
	 cout<<Size<<"SizeMCTracksRead"<<endl;
    vMCTracks.resize(Size);
    for (int i = 0; i < Size; i++){
      AliHLTTPCCAMCTrack &l = vMCTracks[i];
      ifile >> l;
    }
    ifile.close();
  }


  {
    ifstream ifile((prefix+"MCPoints.data").data());
    if ( !ifile.is_open() ) return 0;
    int Size;
    ifile >> Size;
	cout<<Size<<"SizeMCPointRead"<<endl;
    vMCPoints.resize(Size);
    for (int i = 0; i < Size; i++){
      AliHLTTPCCALocalMCPoint &l = vMCPoints[i];
      ifile >> l;
    }
    ifile.close();
  }
 }

bool TData::WriteHitsToFile(string prefix)
{
std::cout << "!!!!!!!!!!!!  " << std::endl;
    fstream  ifile;
	ifile.open((prefix+"hits.data").data(),fstream::out | fstream::app);
    if ( !ifile.is_open() ) return 0;
    int Size = vHits.size();
    ifile << Size<<endl;
   cout<<Size<<"SizeWriteHits"<<endl;

    for (int i = 0; i < Size; i++){
      AliHLTTPCCAGBHit &l = vHits[i];
      ifile << l;
    }

   ifile.close();
    return 1;
}

bool TData::WriteDataToFiles(string prefix)
 {
 

  {
    ofstream ifile((prefix+"hitLabels.data").data());
    if ( !ifile.is_open() ) return 0;
    int Size = vHitLabel.size();
    ifile << Size<<endl;
	 cout<<Size<<"SizeLabWrite"<<endl;
   
    for (int i = 0; i < Size; i++){
      AliHLTTPCPerformanceBase::AliHLTTPCCAHitLabel &l = vHitLabel[i];
      ifile << l;
    }
    ifile.close();
  }

  {
    ofstream ifile((prefix+"MCTracks.data").data());
    if ( !ifile.is_open() ) return 0;
    int Size = vMCTracks.size();
    ifile << Size<<endl;
	 cout<<Size<<"MCTrackWrite"<<endl;
    for (int i = 0; i < Size; i++){
      AliHLTTPCCAMCTrack &l = vMCTracks[i];
      ifile << l;
    }
    ifile.close();
  }


  {
    ofstream ifile((prefix+"MCPoints.data").data());
    if ( !ifile.is_open() ) return 0;
    int Size = vMCPoints.size();
    ifile << Size<<endl;
	 cout<<Size<<"MCPointWrite"<<endl;
    for (int i = 0; i < Size; i++){
      AliHLTTPCCALocalMCPoint &l = vMCPoints[i];
      ifile << l;
    }
    ifile.close();
  }
 }