// ---------------------------------------------------------------------
// -----               KrattaRecognizer source file                -----
// -----            Created 10/11/13  by P. Pawlowski              -----
// ---------------------------------------------------------------------




#include "KrattaRecognizer.hxx"
#include <cmath>

KrattaRecognizer::KrattaRecognizer(const char * filemask,const  char * obj)
    :GridMask(filemask), Obj(obj), tolerance(0)
{
	memset(grid, 0, sizeof(grid));
  ///DEBUG SK1119 printf("[KrattaRecognizer::KrattaRecognizer] constructor 1 called \n");
  Load();
  ///getchar();
}

KrattaRecognizer::KrattaRecognizer(const std::string filemask, const char * obj )
    :GridMask( filemask.c_str() ), Obj(obj), tolerance(0)
{
	memset(grid, 0, sizeof(grid));
  ///DEBUG SK1119  printf("[KrattaRecognizer::KrattaRecognizer] constructor 2 called \n");
  Load();
  ///getchar();
}

KrattaRecognizer::~KrattaRecognizer(){
  for(int i=0; i<Nmodules; i++){
    if(grid[i]) {
      grid[i]->Destroy();
      delete grid[i];
    }
 }
}

KrattaGrid * KrattaRecognizer::GetGrid(int module){
  if(!grid[module]) Read(module);
  return grid[module];
}

//bool KrattaRecognizer::Recognize(TRootKRATParticle * part){
//  //printf ("KrattaRecognizer::Recognize:] grid[part->Module] =%d",grid[part->Module]  );
//  if(    !grid[part->Module] 
//      && !Read(part->Module)      /// <= MEMORY LEAK (>>>>>)
//    )
//  {
//    part->PID = UFO;
//  }
//  else SetUp(part);
//  return part->PID;
//}

bool KrattaRecognizer::Recognize(TRootKRATParticle * part){
  
  
  ///DEBUG SK1119 printf ("[KrattaRecognizer::Recognize:] grid[part->Module] =%d, part->Module=%d\n",grid[part->Module], part->Module  );
  if( grid[part->Module] != 0 )
  {
    SetUp(part);
  }
  else
  {
    ///DEBUG SK1119 printf("[KrattaRecognizer::Recognize:] Trzeba zaladowac modul %d! Gdzie grid[part->Module]=%d\n", part->Module, grid[part->Module]);
    if( Read(part->Module)  )    /// <= MEMORY LEAK (>>>>>) 
    {
      SetUp(part);
    }else{
      ///DEBUG SK1119 printf("Nie ma gridu - UFO\n");
      part->PID = UFO;  
    }
  }
  return part->PID;
}




void KrattaRecognizer::SetUp(TRootKRATParticle * part){
  SetUp(part, grid[part->Module]);
}

void KrattaRecognizer::SetUp(TRootKRATParticle * part, KrattaGrid * grid, double tolerance){
  part->PID = grid->GetPID(part->Xident, part->Yident, tolerance);
  GetIntAZ(part->PID, part->A, part->Z);
  part->RealZ = GetRealZ(part->Xident, part->Yident, grid);
  part->RealA = GetRealA(part->Xident, part->Yident, grid);
  if(part->RealA) part->A = (int)(part->RealA + 0.5);
}

void KrattaRecognizer::GetIntAZ(int pid, int & A, int & Z){
  switch(pid){
    case UFO: A = 0;  Z = 0; return;
    case H1:  A = 1;  Z = 1; return;
    case H2:  A = 2;  Z = 1; return;
    case H3:  A = 3;  Z = 1; return;
    case He3: A = 3;  Z = 2; return;
    case He4: A = 4;  Z = 2; return;
    case He6: A = 6;  Z = 2; return;
    case Li6: A = 6;  Z = 3; return;
    case Li7: A = 7;  Z = 3; return;
    case Li8: A = 8;  Z = 3; return;
    case Li9: A = 9;  Z = 3; return;
    case Be7: A = 7;  Z = 4; return;
    case Be9: A = 9;  Z = 4; return;
    case Be10:A = 10; Z = 4; return;
    case B10: A = 10; Z = 5; return;
    case B11: A = 11; Z = 5; return;
    case B12: A = 12; Z = 5; return;
    case B13: A = 13; Z = 5; return;
    case C12: A = 12; Z = 6; return;
    case C13: A = 13; Z = 6; return;
    case N15: A = 15; Z = 7; return;
    default: printf("KrattaRecognizer::GetIntAZ: PID %d should never happen!\n",pid);
  }
}

float KrattaRecognizer::GetRealZ(double x, double y, KrattaGrid * grid){
  static const KrattaPID ref[] = {H2, He4, Li7, Be9, B11, C12, N15};
  static const int Nref = sizeof(ref)/sizeof(KrattaPID);
  float dist[Nref];
  float dmin = fabs(grid->Distance(x, y, ref[0]));
  int imin = 0;
  float dmod, d0, d1, Z0;
  for(int i=0; i<Nref; i++){
    dist[i] = grid->Distance(x, y, ref[i]);
    dmod = fabs(dist[i]);
    if(dmod  < dmin){
      dmin = dmod;
      imin = i;
    }
  }
  int opt = 0;
  if(imin == 0){
    	  d0 = dist[imin];
	  d1 = dist[imin+1];
	  Z0 = imin+1;
	  opt = 1;
  }
  else if(imin == Nref - 1){
    	  d0 = dist[imin-1];
	  d1 = dist[imin];
 	  Z0 = imin;
	  opt = 2;
  }
  else {
 	if(fabs(dist[imin-1]) < fabs(dist[imin+1])) {
	  d0 = dist[imin-1];
	  d1 = dist[imin];
	  Z0 = imin;
	  opt = 3;
	}
	else {
	  d0 = dist[imin];
	  d1 = dist[imin+1];
	  Z0 = imin+1;
	  opt = 4;
	}
  }
  float d = -d0/(d1 - d0);
 return Z0 + d;
}

float KrattaRecognizer::GetRealA(double x, double y, KrattaGrid * grid){
  KrattaPID pid0, pid1;
  double d;
  grid->GetTwoNearestLines(x, y, pid0, pid1, d);
  if(!pid0 || d < -1.5 || d > 2.5) return 0;

  if(!pid1){ 			// Only one line in grid
    int iZ, iA;
    GetIntAZ(pid0, iA, iZ);
    return iA;
  }

    int A0, A1, Z0, Z1;
    GetIntAZ(pid0, A0, Z0);
    GetIntAZ(pid1, A1, Z1);
    if(Z0 != Z1)
      return 0;
    else
      return A0 + d*(A1 - A0);
}


TFile * KrattaRecognizer::GetFile(int module){
//  printf("KrattaRecognizer: openning file %s\n",Form(GridMask, module));
    return new TFile(Form(GridMask, module));
}

void  KrattaRecognizer::Remove(int module){
    grid[module]->Destroy();
    delete grid[module];
    grid[module] = 0;
}

// Oryginal PP function:
//bool KrattaRecognizer::Read(int module){
  
  ////printf("[KrattaRecognizer::Read] Read(int module=%d)\n", module );
  //if(grid[module]) Remove(module);
  //TFile * f = GetFile(module);
  ///// //PP:  if(*Obj)
  //grid[module] = new KrattaGrid(KrattaGrid(f, Obj));   /// <= MEMORY LEAK (>>>>>>)
  ///// //PP:  grid[module]->ls();
  ///// //PP:  else
  ///// //PP:    grid[module] = new KrattaGrid(KrattaGrid(&f));
  //f->Close();
  //return  (bool)grid[module];
//}

bool KrattaRecognizer::Read(int module){
  
  ///DEBUG SK1119 printf("[KrattaRecognizer::Read] Read(int module=%d)\nWrite any key to continue..", module );
  //printf("[KrattaRecognizer::Read] Read(int module=%d)\n", module );
  ///getchar();
  bool return_value = kTRUE;
  if(grid[module]==0){
    //Remove(module)
    TFile * f = GetFile(module);
    /// //PP:  if(*Obj)
    grid[module] = new KrattaGrid(KrattaGrid(f, Obj));   /// <= MEMORY LEAK (>>>>>>)
    /// //PP:  grid[module]->ls();
    /// //PP:  else
    /// //PP:    grid[module] = new KrattaGrid(KrattaGrid(&f));
    f->Close();
    if (grid[module]==0){
      return_value = kFALSE;
    }
  }
  //return  (bool)grid[module];
  return return_value;
}

void KrattaRecognizer::Load(){
  
  ///DEBUG SK1119printf( "[KrattaRecognizer::Load:] Loading grid modules by calling function Read\n" );
  for(int i=0; i<Nmodules; i++)
    Read(i);
}

void KrattaRecognizer::ls(){
  for(int i=0; i<Nmodules; i++){
    printf("Module %02d\n",i);
    if(!grid[i]) Read(i);
    grid[i]->ls();
  }
}