#include <gpData.h>

gpData::gpData() {
   this->initPointers();
}

gpData::gpData(const Char_t *fileName, const Char_t *fileType) {
        //cout << "0.1"<< endl; 
   this->initPointers();
   //cout << "0.2"<< endl; 
   this->loadFile(fileName, fileType);
}

void gpData::initPointers() {
   pairsptr = 0;
   hadronsptr = 0;
   photonsptr = 0;
   beams1ptr = 0;
   beams2ptr = 0;
   lumisptr = 0;
}

bool gpData::loadFile(const Char_t *fileName, const Char_t *fileType) {

  //cout << "0.3"<< endl; 
  ifstream istr(fileName,ios::in);
  //cout << "0.4"<< endl; 
  Int_t iLoadLoop = 0;
  //cout << "0.5"<< endl; 

  if( !strcmp( fileType, "pair") ) {
     //cout << "1"<< endl; 
     if( pairsptr != 0 )   delete pairsptr;
     pairsptr = new pairs;
     //cout << "2"<< endl; 
     pair_part dummyPairs[NMAXPART] = {};
     //cout << "3"<< endl; 
     pairsptr->parts = dummyPairs;
     //cout << "4"<< endl;
     //cout << dummyPairs[78].e << endl;

     while( istr.peek()!= EOF ) {
      istr >> pairsptr->parts[iLoadLoop].e >> pairsptr->parts[iLoadLoop].vx
      >> pairsptr->parts[iLoadLoop].vy >> pairsptr->parts[iLoadLoop].vz
      >> pairsptr->parts[iLoadLoop].x >> pairsptr->parts[iLoadLoop].y
      >> pairsptr->parts[iLoadLoop].z;
      iLoadLoop++;
      istr.ignore( 1 );
     }

     //cout << "after"<< endl;
     pairsptr->npart = iLoadLoop;

  }else if( !strcmp( fileType, "hadron") ) {

     if( hadronsptr != 0 )   delete hadronsptr;

     hadronsptr = new hadrons;
     hadron_part dummyHadrons[NMAXPART] = {};
     hadronsptr->parts = dummyHadrons;

     while(istr.peek()!= EOF) {
      istr >> hadronsptr->parts[iLoadLoop].e1 >> hadronsptr->parts[iLoadLoop].e2 ;
      iLoadLoop++;
      istr.ignore( 1 );
     }

     hadronsptr->npart = iLoadLoop;

  }else if( !strcmp( fileType, "lumi") ) {

     if( lumisptr != 0 )   delete lumisptr;

     lumisptr = new lumis;
     lumi_part dummyLumis[NMAXPART] = {};
     lumisptr->parts = dummyLumis;

     while(istr.peek()!= EOF) {
      istr >> lumisptr->parts[iLoadLoop].epos >> lumisptr->parts[iLoadLoop].eele
      >> lumisptr->parts[iLoadLoop].x >> lumisptr->parts[iLoadLoop].y
      >> lumisptr->parts[iLoadLoop].z;
      iLoadLoop++;
      istr.ignore( 1 );
     }

     lumisptr->npart = iLoadLoop;

  }else if( !strcmp( fileType, "beam1") ) {

     if( beams1ptr != 0 )   delete beams1ptr;

     beams1ptr = new beams1;
     beam1_part dummyBeams[NMAXPART] = {};
     beams1ptr->parts = dummyBeams;

     while(istr.peek()!= EOF) {
      istr >> beams1ptr->parts[iLoadLoop].e
      >> beams1ptr->parts[iLoadLoop].tx >> beams1ptr->parts[iLoadLoop].ty
      >> beams1ptr->parts[iLoadLoop].x  >> beams1ptr->parts[iLoadLoop].y;
      iLoadLoop++;
      istr.ignore( 1 );
     }

     beams1ptr->npart = iLoadLoop;


  }else if( !strcmp( fileType, "beam2") ) {

     if( beams2ptr != 0 )   delete beams2ptr;

     beams2ptr = new beams2;
     beam2_part dummyBeams[NMAXPART] = {};
     beams2ptr->parts = dummyBeams;

     while(istr.peek() != EOF) {
           istr >> beams2ptr->parts[iLoadLoop].e
      >> beams2ptr->parts[iLoadLoop].tx >> beams2ptr->parts[iLoadLoop].ty
      >> beams2ptr->parts[iLoadLoop].x  >> beams2ptr->parts[iLoadLoop].y;
      iLoadLoop++;
      istr.ignore( 1 );
     }

     beams2ptr->npart = iLoadLoop;


  }else if( !strcmp( fileType, "photon") ) {

     if( photonsptr != 0 )   delete photonsptr;
     //cout << "1";
     photonsptr = new photons;
     //cout << "2";
     photon_part dummyPhotons[NMAXPART] = {};
     //cout << "3";
     photonsptr->parts = dummyPhotons;
     //cout << "4";
     while(istr.peek() != EOF) {
      istr >> photonsptr->parts[iLoadLoop].e
      >> photonsptr->parts[iLoadLoop].tx  >> photonsptr->parts[iLoadLoop].ty;
      iLoadLoop++;
      istr.ignore( 1 );
      //if( (iLoadLoop % 100)== 0 ) cout <<"\n5- "<< iLoadLoop ;
     }
     //cout << "6";
     photonsptr->npart = iLoadLoop;
     //cout << "7";
  }

  return true;


}

gpData::~gpData() {
}

///////////////////////////////////////////////////////////
//
//
///////////////////////////////////////////////////////////

bool gpData::getPcle(Int_t i, pair_part& myPart) {

   if( i <= pairsptr->npart ) {
      myPart = pairsptr->parts[i];
      return true;
   }
   else return false;
};


bool gpData::getPcle(Int_t i, hadron_part& myPart) {

   if( i <= hadronsptr->npart ) {
      myPart = hadronsptr->parts[i];
      return true;
   }
   else return false;
};

bool gpData::getPcle(Int_t i, lumi_part& myPart) {

   if( i <= lumisptr->npart ) {
      myPart = lumisptr->parts[i];
      return true;
   }
   else return false;
};


bool gpData::getPcle(Int_t i, beam1_part& myPart) {

   if( i <= beams1ptr->npart ) {
      myPart = beams1ptr->parts[i];
      return true;
   }
   else return false;
};

bool gpData::getPcle(Int_t i, beam2_part& myPart) {

   if( i <= beams2ptr->npart ) {
      myPart = beams2ptr->parts[i];
      return true;
   }
   else return false;
};

bool gpData::getPcle(Int_t i, photon_part& myPart) {

   if( i <= photonsptr->npart ) {
     //cout << "1" << i;
     myPart = photonsptr->parts[i];
     //cout <<"2"<< i;
     return true;
   }
   else return false;
};



///////////////////////////////////////////////////////////
//
//
///////////////////////////////////////////////////////////

Int_t gpData::numOfPcles( Char_t *type) {

   if( !strcmp( type, "pair") ) {

      return pairsptr->npart;

   }else if ( !strcmp( type, "hadron") ) {

      return hadronsptr->npart;

   }else if ( !strcmp( type, "lumi") ) {

      return lumisptr->npart;

   }else if ( !strcmp( type, "beam1") ) {

      return beams1ptr->npart;

   }else if ( !strcmp( type, "beam2") ) {

      return beams2ptr->npart;

   }else if( !strcmp( type, "photon") ) {

      return photonsptr->npart;

   }else return -1;
};

/*
Int_t gpData::numOfPcles(hadron_part& myPart) {
  return hadronsptr->npart;
};

Int_t gpData::numOfPcles(beam_part& myPart) {
  return beamsptr->npart;
};

Int_t gpData::numOfPcles(photon_part& myPart) {
  return photonsptr->npart;
};

Int_t gpData::numOfPcles(lumi_part& myPart) {
  return lumisptr->npart;
}; */



/*bool gpData::getPcle(Int_t i, Char_t *type) {

   if( !strcmp( type, "pair") ) {
      pair_part& myPart = pairsptr->parts[i];
      return true;
   }else if ( !strcmp( type, "hadron") ) {
      hadron_part& myPart = hadron->parts[i];
      return true;
   }else if ( !strcmp( type, "lumi") ) {
      lumi_part& myPart = lumisptr->parts[i];
      return true;
   }else if ( !strcmp( type, "bream") ) {
      beam_part& myPart = beamsptr->parts[i];
      return true;
   }( !strcmp( type, "photon") ) {
      photon_part& myPart = photonsptr->parts[i];
      return true;
   }  
   else return false;
};*/