#include <iomanip>
#include <cstdio>
#include <string>
#include "Alignment/AlDigiCode.hh"

// use these flags to set the coverage (SVX, ISL..)
// put in constructor or setUsedDetectors(AlDigiCode::SVX || AlDigiCode::L00);
const int AlDigiCode::SVX0=1;
const int AlDigiCode::SVX1=2;
const int AlDigiCode::SVX2=4;
const int AlDigiCode::L00_0=8;
const int AlDigiCode::L00_1=16;
const int AlDigiCode::ISL_6B=32;
const int AlDigiCode::ISL_6C=64;
const int AlDigiCode::ISL_6F=128;
const int AlDigiCode::ISL_7B=256;
const int AlDigiCode::ISL_7F=512;
const int AlDigiCode::SVX=1+2+4;
const int AlDigiCode::L00=8+16;
const int AlDigiCode::SVX_L00=1+2+4+8+16;
const int AlDigiCode::CENTRAL=1+2+4+8+16+64;
const int AlDigiCode::ISL=32+64+128+256+512;
const int AlDigiCode::ALL=0x3FF;

// use these flags to set the resolution (ladders, halfladders...)
// in constructor or setResolution(AlDigiCode::WAFER) for example
const int AlDigiCode::FRAME=1;
const int AlDigiCode::BARREL=2;
const int AlDigiCode::LADDER=3;
const int AlDigiCode::HALFLADDER=4;
const int AlDigiCode::WAFER=5;
const int AlDigiCode::SIDE=6;


AlDigiCode::AlDigiCode(): 
    _barrel(0),_layer(0),_wedge(0),_halfladder(0),_wafer(0),_side(0),
    _validCode(false),_validIndex(true),_index(0),_code(0) 
{
  _cover = 7;
  _resol = 3;
  init();
  count();
  setResolution(LADDER);
  setUsedDetectors(ALL);
}

AlDigiCode::AlDigiCode(int resol, int cover): 
    _barrel(0),_layer(0),_wedge(0),_halfladder(0),_wafer(0),_side(0),
    _validCode(false),_validIndex(true),_index(0),_code(0)
{
  init();
  setResolution(resol);
  setUsedDetectors(cover);
}

AlDigiCode::AlDigiCode(int bar, int lay, int wed, int hbar, int waf, int sid):
  _barrel(bar),_layer(lay),_wedge(wed),_halfladder(hbar),
  _wafer(waf),_side(sid) 
{
  init();
  setResolution(LADDER);
  setUsedDetectors(ALL);
  checkValid();
  restoreIndex();
  restoreCode();
}


AlDigiCode::~AlDigiCode()
{
}


// return a string like: "0 0  0 0 0 0"
//          reflecting    b/l/ w/h/w/s
char* AlDigiCode::getName(char* name)
{
  restoreCode();
  sprintf(name,"%1d %1d %2d %1d %1d %1d\0",
	  _barrel,_layer,_wedge,_halfladder,_wafer,_side);
  return name;
}

// returns a string like:  3703301 breaks down: b/l/w/h/w/s= 3/7/03/3/0/1
char* AlDigiCode::getCompactName(char* name)
{
  restoreCode();
  sprintf(name,"%1d%1d%02d%1d%1d%1d\0",
	  _barrel,_layer,_wedge,_halfladder,_wafer,_side);
  return name;
}

// returns a string like: "brl: 0 lyr: 0 wdg: 00 hld: 0 wfr: 0 sid: 0"
char* AlDigiCode::getTitle(char* title)
{
  restoreCode();
  sprintf(title,"brl: %d lyr: %d wdg: %02d hld: %d wfr: %d sid: %d\0",
              _barrel,_layer,_wedge,_halfladder,_wafer,_side);
  return title;
}

// write it out to a stream like: "0 0  0 0 0 0"
//                   reflecting    b/l/ w/h/w/s
ostream& operator << (std::ostream& os, AlDigiCode& rhs)
{
  char cc[100];
  os << rhs.getName(cc);
  return os;
}

istream& operator >> (std::istream& is, AlDigiCode& rhs) {
  is >> rhs._barrel >> rhs._layer >> rhs._wedge >> 
    rhs._halfladder >> rhs._wafer >> rhs._side ;

  rhs._code = 
    rhs._side             +
    (rhs._layer<<1)       +
    (rhs._halfladder<<4)  +
    (rhs._barrel<<6)      +
    (rhs._wedge<<8)       +
    (rhs._wafer<<14);

  rhs._validCode=true;
  rhs._validIndex=false;
  return is;
}

int AlDigiCode::getBarrel()     { restoreCode(); return _barrel;}
int AlDigiCode::getWedge()      { restoreCode(); return _wedge;}
int AlDigiCode::getLayer()      { restoreCode(); return _layer;}
int AlDigiCode::getHalfLadder() { restoreCode(); return _halfladder;}
int AlDigiCode::getWafer()      { restoreCode(); return _wafer;}
int AlDigiCode::getSide()       { restoreCode(); return _side;}

int AlDigiCode::getNtotal()     { return _nTotal;}

int AlDigiCode::getCode()       { restoreCode(); return _code;}
int AlDigiCode::getIndex()      { restoreIndex(); return _index;}


// when one of these is set, check that it is a legal value and 
// mark the index bad because it is out of sync
void AlDigiCode::setBarrel(int i) {_barrel=i; checkValid(); _validIndex=false;}
void AlDigiCode::setWedge(int i)  {_wedge=i; checkValid(); _validIndex=false;}
void AlDigiCode::setLayer(int i)  {_layer=i; checkValid(); _validIndex=false;}
void AlDigiCode::setHalfLadder(int i) {_halfladder=i; checkValid(); 
                                                    _validIndex=false;}
void AlDigiCode::setWafer(int i) {_wafer=i; checkValid(); _validIndex=false;}
void AlDigiCode::setSide(int i) {_side=i; checkValid(); _validIndex=false;}

void AlDigiCode::setPar( int bar, int lay, int wed, 
			 int hlad, int waf, int sid) 
{
  _barrel=bar; _layer=lay; _wedge=wed; _halfladder=hlad; 
  _wafer=waf; _side= sid;
  checkValid(); 
  _validIndex=false;
}


// set the code to this value
void AlDigiCode::setCode(int icode)
{
  _code = icode;
  _side       = icode & 0x1;   icode=icode>>1;
  _layer      = icode & 0x7;   icode=icode>>3;
  _halfladder = icode & 0x3;   icode=icode>>2;
  _barrel     = icode & 0x3;   icode=icode>>2;
  _wedge      = icode & 0x3F;  icode=icode>>6;
  _wafer      = icode & 0x3;   icode=icode>>2;
  checkValid();
  _validCode=true;
  _validIndex=false;  // index needs to be updated
}


// set the position as a index
void AlDigiCode::setIndex(int ind){
  if(ind>_nTotal || ind<0) {
    std::cerr << "AlDigiCode: index out of range 0-"<<_nTotal<<": "<< ind << std::endl;
    clear();
  } else {
    _index=ind;
  }

  _validIndex=true;
  _validCode=false;  // code now needs to be updated
}

AlDigiCode::operator int () {restoreIndex(); return _index;}

const AlDigiCode& AlDigiCode::operator ++() 
{
  restoreIndex();
  if(_index<_nTotal) _index++; 
  _validCode=false; 
  return *this;
}

const AlDigiCode  AlDigiCode::operator ++(int)
{
  restoreIndex();
  AlDigiCode temp=AlDigiCode(*this); 
  if(_index<_nTotal) _index++; 
  _validCode=false; 
  return temp;
}

const AlDigiCode& AlDigiCode::operator --()
{
  restoreIndex();
  if(_index>0) _index--; 
  _validCode=false; 
  return *this;
}

const AlDigiCode  AlDigiCode::operator --(int)
{
  restoreIndex();
  AlDigiCode temp=AlDigiCode(*this); 
  if(_index>0) _index--; 
  _validCode=false;
  return temp;
}

AlDigiCode& AlDigiCode::operator = (const int rhs)
{
  setIndex(rhs); 
  return *this;
}

bool AlDigiCode::operator <  (AlDigiCode& rhs)
  { restoreIndex(); return (_index <  rhs.getIndex()); }
bool AlDigiCode::operator >  (AlDigiCode& rhs)
  { restoreIndex(); return (_index >  rhs.getIndex()); }
bool AlDigiCode::operator <= (AlDigiCode& rhs)
  { restoreIndex(); return (_index <= rhs.getIndex()); }
bool AlDigiCode::operator >= (AlDigiCode& rhs)
  { restoreIndex(); return (_index >= rhs.getIndex()); }
bool AlDigiCode::operator == (AlDigiCode& rhs)
  { restoreIndex(); return (_index == rhs.getIndex()); }
bool AlDigiCode::operator != (AlDigiCode& rhs)
  { restoreIndex(); return (_index != rhs.getIndex()); }


// set which subdetectors (SVX, L00, ISL...) are used
void AlDigiCode::setUsedDetectors(int detectorFlag)
{
  if(detectorFlag<=0 || detectorFlag>ALL) {
    std::cout << "AlDigiCode::setUsedDetector flag must be >0 and <="
	 << ALL <<", not " << detectorFlag << std::endl;
    clear();
  }
  _cover = detectorFlag;
  if(_resol == FRAME) _cover = ALL;
  _index=0;
  _validIndex=false;
  count();            // reset nTotal
}


// what resolution (ladder, half-ladder, wafer..) to include in index
void AlDigiCode::setResolution(int resolutionFlag)
{
  if(resolutionFlag<1 || resolutionFlag>6) {
    std::cout << "AlDigiCode::setResolution flag must be >0 and <=6, not "
	 << resolutionFlag << ".  Flag not set." << std::endl;
    clear();
  }
  _resol = resolutionFlag;
  if(_resol == FRAME) setUsedDetectors(ALL);
  if(_validIndex) restoreCode();
  _index = 0;
  _validIndex = false;
  count();  // reset nTotal
}


// set ntotal
void AlDigiCode::count()
{

  _nTotal=0;
  for(int i=0; i<10; i++) {
    switch (_resol) {
    case FRAME:
      if(i==0) _nPieces[0]=1; else _nPieces[i]=0;
      break;
    case BARREL:
      if(i<=7) _nPieces[i]=1; else _nPieces[i]=0;
      break;
    case LADDER:
      _nPieces[i] = NLayers[i] * NWedges[i];
      break;
    case HALFLADDER:
      _nPieces[i] = NLayers[i] * NWedges[i] * NHalfLadders[i];
      break;
    case WAFER:
      _nPieces[i] = NLayers[i] * NWedges[i] * NHalfLadders[i] * NWafers[i];
      break;
    case SIDE:
      _nPieces[i] = NLayers[i] * NWedges[i] * NHalfLadders[i] * NWafers[i] * 2;
      break;
    }                           // end switch
    if( (_cover & (1<<i)) !=0 ) _nTotal += _nPieces[i];
  }                             // end for loop
  
}       // end count method



//produce the index from the code
void AlDigiCode::restoreIndex()
{

  if(_validIndex) return;

  if(!_validCode) {
    std::cout << "AlDigiCode::restoreIndex: attempt to restore index from invalid code" << std::endl;
    return;
  }

  int b,l,w,h,f,s;

  b=_barrel;
  l=_layer;
  w=_wedge;
  h=_halfladder;
  f=_wafer;
  s=_side;

  int d;

  //find which of the 10 basic subdetectors this falls into
  if(l>=1 && l<=5) d=b;
  else if(l==0) d=b+3;
  else if(l==6) d=b+5;
  else if(l==7) {if(b==0) d=8; else d=9;};

  //adjust l to the lowest layer in the subdetector
  if(d<=2) l=l-1; else l=0;

  int ind = 0;

  // loop over subdetectors before this one, bring the index along
  for(int i=0; i<d; i++) {
    if( (_cover & (1<<i)) != 0 ) {
      ind += _nPieces[i];
    }
  }

  // fill in the regular (systematic) part of the index
  switch (_resol) {
  case FRAME:
    ind = 0;
    break;
  case LADDER:
    ind += l*NWedges[d] + w;
    break;
  case HALFLADDER:
    ind += l*NWedges[d]*NHalfLadders[d] + w*NHalfLadders[d] + h;
    break;
  case WAFER:
    ind += l*NWedges[d]*NHalfLadders[d]*NWafers[d] + 
      w*NHalfLadders[d]*NWafers[d] + h*NWafers[d] +f;
    break;
  case SIDE:
    ind += l*NWedges[d]*NHalfLadders[d]*NWafers[d]*2 + 
      w*NHalfLadders[d]*NWafers[d]*2 + h*NWafers[d]*2 + f*2 + s;
    break;
  }                           // end switch

  _index = ind;
  _validIndex = true;

}


//produce the code from the index
void AlDigiCode::restoreCode()
{

  if(_validCode) return;

  if(!_validIndex) {
    std::cout << "AlDigiCode::restoreCode: attempt to restore code from invalid index" << std::endl;
    return;
  }

  int indexx = _index;
  if(_index==_nTotal) indexx=_index-1;

  int ind = 0;
  int d;

  // find where this index is in the basic 10 detectors
  for (d=0; d<10; d++) {
    if( (_cover & (1<<d)) != 0 ) {
      if(ind + _nPieces[d] > indexx ) break;
      ind += _nPieces[d];
    }
  }

  indexx -=  ind;  // index now is relative to the start of the subdetector

  int b=0,l=0,w=0,h=0,f=0,s=0;

  // now decode the regular (systematic) part of the index
  // note that the all cases after target case are supposed to be executed
  // (no breaks)

  switch (_resol) {
  case SIDE:
    s = indexx%2;
    indexx = indexx/2;
  case WAFER:
    f = indexx%NWafers[d];
    indexx = indexx/NWafers[d];
  case HALFLADDER:
    h = indexx%NHalfLadders[d];
    indexx = indexx/NHalfLadders[d];
  case LADDER:
    w = indexx%NWedges[d];
    indexx = indexx/NWedges[d];
  }                           // end switch
  l=indexx;    // only thing left is the layer

  if(_resol != FRAME) {
    //last step, convert detector number into barrel and final layer
    switch(d) {
    case 0:  b=0; l=l+1; break;
    case 1:  b=1; l=l+1; break;
    case 2:  b=2; l=l+1; break;
    case 3:  b=0; l=0;   break;
    case 4:  b=1; l=0;   break;
    case 5:  b=0; l=6;   break;
    case 6:  b=1; l=6;   break;
    case 7:  b=2; l=6;   break;
    case 8:  b=0; l=7;   break;
    case 9:  b=2; l=7;   break;
    }
  }

  _barrel=b;
  _layer=l;
  _wedge=w;
  _halfladder=h;
  _wafer=f;
  _side=s;

  _code = 
     _side            +
    (_layer<<1)       +
    (_halfladder<<4)  +
    (_barrel<<6)      +
    (_wedge<<8)       +
    (_wafer<<14);

  _validCode=true;
}


// is if this setting is valid for Run II detector
void AlDigiCode::checkValid()
{
  bool trouble=false;
  if(_layer==0) {
    if(_barrel>=2)     trouble = true;
    if(_wedge>=12)     trouble = true;
    if(_halfladder>=3) trouble = true;
    if(_wafer>=2)      trouble = true;
  } else if(_layer>0 && _layer<=5) {
    if(_barrel>=3)     trouble = true;
    if(_wedge>=12)     trouble = true;
    if(_halfladder>=2) trouble = true;
    if(_wafer>=2)      trouble = true;
  } else if(_layer==6) {
    if(_barrel==0 || _barrel==2) {
      if(_wedge>=24)     trouble = true;
      if(_halfladder>=2) trouble = true;
      if(_wafer>=3)      trouble = true;
    } else if(_barrel==1) {
      if(_wedge>=28)     trouble = true;
      if(_halfladder>=2) trouble = true;
      if(_wafer>=3)      trouble = true;
    } else {
      trouble=true;
    }
  } else if(_layer==7) {
    if(_barrel!=0 && _barrel!=2)  trouble = true;
    if(_wedge>=36)     trouble = true;
    if(_halfladder>=2) trouble = true;
    if(_wafer>=3)      trouble = true;
  } else {
    trouble=true;
  }
  if(_side>1) trouble = true;

  if(_index<0 || _index>_nTotal) trouble=true;
  
  if(trouble) {
    std::cerr << "AlDigiCode: Attempt to initialize to nonexistant detector:"
	 << std::endl;
    char c[100];
    std::cerr << "    " << getTitle(c) << "  Index: " << _index << std::endl;
    clear();
  }

}

// load arrays while avoiding initialization
void AlDigiCode::init()
{
  NLayers[0]=5; NWedges[0]=12; NHalfLadders[0]=2; NWafers[0]=2;
  NLayers[1]=5; NWedges[1]=12; NHalfLadders[1]=2; NWafers[1]=2;
  NLayers[2]=5; NWedges[2]=12; NHalfLadders[2]=2; NWafers[2]=2;
  NLayers[3]=1; NWedges[3]=12; NHalfLadders[3]=3; NWafers[3]=2;
  NLayers[4]=1; NWedges[4]=12; NHalfLadders[4]=3; NWafers[4]=2;
  NLayers[5]=1; NWedges[5]=24; NHalfLadders[5]=2; NWafers[5]=3;
  NLayers[6]=1; NWedges[6]=28; NHalfLadders[6]=2; NWafers[6]=3;
  NLayers[7]=1; NWedges[7]=24; NHalfLadders[7]=2; NWafers[7]=3;
  NLayers[8]=1; NWedges[8]=36; NHalfLadders[8]=2; NWafers[8]=3;
  NLayers[9]=1; NWedges[9]=36; NHalfLadders[9]=2; NWafers[9]=3;
}