#include "Stntuple/jet/TStnH1JetMaker.hh"
#include "Stntuple/obj/TStnEvent.hh"
#include "Stntuple/obj/TStnNode.hh"


ClassImp(TStnH1JetMaker)

//_____________________________________________________________________________
TStnH1JetMaker::TStnH1JetMaker() 
{
  fRun=0;
  fEvt=0;
  fOutJetBlock = 0;
  fPrintLevel = 0;

}
//_____________________________________________________________________________
TStnH1JetMaker::~TStnH1JetMaker() {
}


//_____________________________________________________________________________
Int_t TStnH1JetMaker::MakeJets(TStnJetBlock* inJetBlock, 
			       TStnJetBlock* outJetBlock, Int_t level) {

  int rc = 0;

  fJetBlock = inJetBlock;
  if(!fJetBlock) {
    printf("TStnH1JetMaker Error: no input jet block\n");
    return 1;
  }
  fEvent = inJetBlock->GetEvent();
  if(fPrintLevel>0) fJetBlock->Print();

  fOutJetBlock = outJetBlock;
  fOutJetBlock->Clear();
  if(!fOutJetBlock) {
    printf("TStnH1JetMaker Error: no output jet block\n");
    return 1;
  }

  if(level==0) {
    printf("TStnH1JetMaker Error: level==0, no jets requested\n");
    return 1;
  }

  rc = UnpackBlocks();
  if(rc!=0) {
    printf("TStnH1JetMaker Error: could not unpack event\n");
    return 1;
  }

  int r = fHeaderBlock->RunNumber();
  int e = fHeaderBlock->EventNumber();

  // allow several different jet collections to be analysed
  // but only load tracks and towers once
  if(r!=fRun || e!=fEvt) {
    fRun = r;
    fEvt = e;
    fNtpH1JetMaker.Clear();
    // copy Stntuple towers and tracks to Ntp classes
    rc = FillNtpCal();
    if(rc!=0) {
      printf("TStnH1JetMaker LoadJets Error: could not FillNtpCal\n");
      return 1;
    }
    rc = FillNtpTracks();
    if(rc!=0) {
      printf("TStnH1JetMaker LoadJets Error: could not FillNtpTrack\n");
      return 1;
    }
    rc = FillVertex();
    if(rc!=0) {
      printf("TStnH1JetMaker FillVertex Error: could not FillNtpTrack\n");
      return 1;
    }

    rc = fNtpH1JetMaker.InitEvent(fRun,fEvt,fZv,fNvtx);
    if(rc!=0) {
      printf("TStnH1JetMaker LoadJets Error: fNtpH1JetMaker.InitEvent() failed\n");
      return 1;
    }
  }

  // copy Stntuple jets to Ntp classes
  fNtpH1JetMaker.ClearJets();
  rc = FillNtpJets();
  if(rc!=0) {
    printf("TStnH1JetMaker LoadJets Error: could not FillNtpJets\n");
    return 1;
  }

  fLevel = level;

  fMc = fHeaderBlock->McFlag();
  fNtpH1JetMaker.SetMc(fMc);

  // compte H1 jets for each level requested
  for(int i=0; i<=7; i++) {
    if(fLevel & (1<<i)) {
      fNtpH1JetMaker.Compute(i);
    }
  }

  // copy result back into output jet block
  FillStnJets();

  if(fPrintLevel>0) fOutJetBlock->Print();

  return 0;
}

//_____________________________________________________________________________
Int_t TStnH1JetMaker::FillStnJets() {

  if(fPrintLevel>=5) printf("TStnH1JetMaker::FillStnJets: N new jets %d\n",
			    fNtpH1JetMaker.NH1Jets());
  for(int i=0; i<fNtpH1JetMaker.NH1Jets(); i++) {
    TNtpJet* rj = fNtpH1JetMaker.H1Jet(i);
    TStnJet* sj0= fJetBlock->Jet(i);
    TStnJet* sj = fOutJetBlock->NewJet();
    sj->Clear();
    sj->SetMomentum(*(rj->MomentumRaw()));    
    sj->SetDetEta(sj0->DetEta());
    for(int j=0; j<7; j++) {
      if(j<rj->Cor().GetSize()) sj->SetCorr(rj->Cor()[j],j);
      else sj->SetCorr(-999.0,j);
    }
    if(fPrintLevel>=5) printf("TStnH1JetMaker::FillStnJets: %7.4f\n",
			      rj->MomentumRaw()->Pt());
  }


  return 0;
}



//_____________________________________________________________________________
Int_t TStnH1JetMaker::FillNtpJets() {

  TStnLinkBlock* lnk = fJetBlock->TowerLinkList();

  for(int i=0; i<fJetBlock->NJets(); i++) {
    TStnJet* sj = fJetBlock->Jet(i);
    TNtpJet* rj = fNtpH1JetMaker.NewJet(i);
    rj->Clear();
    rj->SetMomentumRaw(*(sj->Momentum()));
    rj->SetDetEta(sj->DetEta());
    TNtpArrayI& ll = rj->TowerIndexList();
    ll.Set(lnk->NLinks(i));
    for(int j=0; j<lnk->NLinks(i); j++) {
      int key = lnk->Index(i,j);
      int ie = ((key>>8)&0xFF);
      int ip = (key&0xFF);
      TCalTower* ctemp = fCalDataBlock->Tower(ie,ip);
      int ind = -1;
      for(int k=0; k<fCalDataBlock->NTowers(); k++) {
	if(fCalDataBlock->Tower(k)==ctemp) {
	  ind=k; 
	  break;
	}
      }
      if(fPrintLevel>7) printf("Jet %d link %d is tow num %d\n",i,j,ind);
      if(ind<0 || ind>=fCalDataBlock->NTowers()) {
	printf("TStnH1JetMaker::FillNtpJets Error: tower index out of range\n");
	return 1;
      }
      ll[j] = ind;
    }
  }


  float rcone = fJetBlock->ConeSize();
  fCone = -1;
  if(fabs(rcone-0.4)<0.01) fCone = 0;
  if(fabs(rcone-0.7)<0.01) fCone = 1;
  if(fabs(rcone-1.0)<0.01) fCone = 2;
  if(fCone<0) {
    printf("TStnH1JetMaker::FillNtpJets Error: could not find cone size");
    return 1;
  }

  fJetType = -1;
  const char* jetName = fJetBlock->GetNode()->GetName();
  if(strstr(jetName,"JetClu") || strstr(jetName,"JetBlock")) {
    fJetType = fCone;
  } else if(strstr(jetName,"MidPoint")) {
    if(fCone==0) fJetType = 3;
    if(fCone==1) fJetType = 4;
  } else if(strstr(jetName,"KtClus")) {
    if(fCone==1) fJetType = 5;
  } else {
    printf("TStnH1JetMaker::FillNtpJets Error: could not parse jet algorithm");
    return 1;
  }
  if(fPrintLevel>0) {
    printf("TStnH1JetMaker::FillNtpJets Set fCone=%d fJetType=%d for %s\n",
	   fCone,fJetType,jetName);
  }

  fNtpH1JetMaker.SetCone(fCone);
  fNtpH1JetMaker.SetJetType(fJetType);

  return 0;
}

//_____________________________________________________________________________
Int_t TStnH1JetMaker::FillNtpTracks() {

  for(int i=0; i<fTrackBlock->NTracks(); i++) {
    TStnTrack* st = fTrackBlock->Track(i);
    TNtpTrack* rt = fNtpH1JetMaker.NewTrack(i);
    rt->Clear();
    rt->SetMomentum(*(st->Momentum()));
    rt->SetCott(st->Lam0());
    rt->SetC(st->C0());
    rt->SetZ(st->Z0());
    rt->SetD(st->D0());
    rt->SetPhi(st->Phi0());
    rt->SetPt(st->Pt());
    rt->SetP(st->Momentum()->P());
    rt->SetFlag(0);
    rt->SetNCotHits(st->NCotHitsTot());
    rt->SetNSvxHits(st->NSvxHits());
  }
  return 0;
}

//_____________________________________________________________________________
Int_t TStnH1JetMaker::FillNtpCal() {

  if(fPrintLevel>0) 
    printf("TStnH1JetMaker::FillNtpCal: filling %d towers\n",
	   fCalDataBlock->NTowers());

  for(int i=0; i<fCalDataBlock->NTowers(); i++) {
    TCalTower* st = fCalDataBlock->Tower(i);
    TNtpTower* rt = fNtpH1JetMaker.NewTower(i);
    rt->Clear();
    //rt->SetMomentum(st->());
    rt->SetDetTheta(st->Theta()*TMath::Pi()/180.0);
    rt->SetDetSinth(sin(st->Theta()));
    rt->SetDetEta(st->Eta());
    rt->SetTheta(-999.0);
    rt->SetSinth(-999.0);
    rt->SetEta(-999.0);
    rt->SetPhi(st->Phi());
    rt->SetEtaInd(st->IEta());
    rt->SetPhiInd(st->IPhi());
    rt->SetEmE(st->EmEnergy());
    rt->SetHadE(st->HadEnergy());
    rt->SetE(st->Energy());
  }
  return 0;
}

//_____________________________________________________________________________
Int_t TStnH1JetMaker::FillVertex(){

  fNvtx = 0;
  fZv = 0;
  float maxpt=0;
  for(Int_t ivtx=0; ivtx<fZVertexBlock->NVertices(); ivtx++) {
    TStnVertex &vert = *(fZVertexBlock->Vertex(ivtx));
    if (vert.VClass()>=12) {
      fNvtx++;
      if (vert.SumPt()>maxpt) {
        maxpt=vert.SumPt();
        fZv=vert.Z();
      }
    }
  }
  if (fNvtx<1) fNvtx=1;

  return 0;
}


//_____________________________________________________________________________
Int_t  TStnH1JetMaker::UnpackBlocks() {

  int ientry = fEvent->GetCurrentTreeEntry();

  fHeaderBlock = (TStnHeaderBlock*) fEvent->GetDataBlock("HeaderBlock");

  fCalDataBlock = (TCalDataBlock*) fEvent->GetDataBlock("CalDataBlock");
  if(!fCalDataBlock) {
    printf("TStnH1JetMaker: Error CalDataBlock not registered\n");
    return 1;
  }
  fCalDataBlock->GetEntry(ientry);

  fTrackBlock = (TStnTrackBlock*) fEvent->GetDataBlock("TrackBlock");
  if(!fTrackBlock) {
    printf("TStnH1JetMaker: Error TrackBlock not registered\n");
    return 1;
  }
  fTrackBlock->GetEntry(ientry);

  fZVertexBlock = (TStnVertexBlock*) fEvent->GetDataBlock("ZVertexBlock");
  if(!fZVertexBlock) {
    printf("TStnH1JetMaker Error: ZVertexBlock not registered\n");
    return 1;
  }
  fZVertexBlock->GetEntry(ientry);

  fJetBlock->GetEntry(ientry);

  return 0;
}

//_____________________________________________________________________________
void  TStnH1JetMaker::Print(const Option_t*) const {

}