#include <iostream.h>

#include "TFndStbMon.h"
#include "TDirectory.h"
#include "TFndHStb.h"
#include "TObjArray.h"

ClassImp(TFndStbMon);

 TFndStbMon::TFndStbMon(const char *fmode,Int_t stb_tdc_bins,Double_t stb_tdc_min,Double_t stb_tdc_max) {

  stb_mon_tdc = 0;
  stb_mon_pat = 0;

  const char *fhist = "_stb.root";
  const char *fonl = "onl";
  
  shmflg = 0;  
  if(!strcmp(fmode,fonl)) shmflg = 1;
  //cout << "Online flag is " << onlflg << endl;
  
  Int_t ilen = strlen(fmode)+strlen(fhist);
  Char_t *fstbnam = new Char_t[ilen];
  strcpy(fstbnam,fmode);
  fstbnam = strcat(fstbnam,fhist);
  
  fstb = new TFile(fstbnam,"RECREATE","Stb Histogram File");   
  
  if(shmflg) {
    const char *mfnstb = "stb.map";
    //TMapFile::SetMapAddress(0x4240f000);  
    mstb = TMapFile::Create(mfnstb,"RECREATE",2000000,"Stb memory mapped file with histograms");
    mstb->Print();
  }
  
  stbmult = new TH1F("stbmult","Stb multiplicity",50,-0.5,49.5);
  stbmaptdc = new TH2F("stbmaptdc","Stb TDC pattern (Crown vs Tube)",404,0.5,404.5,7,-0.5,6.5);   
  
  // Define Histogram Parameters
  
  char hname[20];
  char htitle[80];

  for (Int_t ll=0;ll<n_stb_crwn;ll++) {
    sprintf(hname,"stb_pattern_%d",ll+1);
    sprintf(htitle,"Hit Pattern for Crown: %d",ll+1);
    stb_pattern[ll] = new TH1F(hname,htitle,n_stb_hist,0.5,0.5+n_stb_hist);
    stb_pattern[ll]->SetFillColor(4); 
  }
  
  //   STB   TDC Crown 1
  
  if(shmflg) {
    const char *mfnstb1 = "stb_tdc_1.map";
    //TMapFile::SetMapAddress(0x425f8000);  
    stb_tdc_1 = TMapFile::Create(mfnstb1,"RECREATE",2000000,"Stb memory mapped file with TDC histograms (Crown 1)");
    stb_tdc_1->Print();
  }
  
  for (Int_t l=0;l<n_stb_hist;l++) {
    sprintf(hname,"stbtdc_1_%d",l+1);
    sprintf(htitle,"TDC  for Crown: 1 Tube: %d",l+1);
    stbtdc1[l] = new TH1F(hname,htitle,stb_tdc_bins,stb_tdc_min,stb_tdc_max);
    stbtdc1[l]->SetFillColor(6); 
  }
  
  //   STB   TDC Crown 2
  
  if(shmflg) {
    const char *mfnstb2 = "stb_tdc_2.map";
    //TMapFile::SetMapAddress(0x42abd000);  
    stb_tdc_2 = TMapFile::Create(mfnstb2,"RECREATE",2000000,"Stb memory mapped file with TDC histograms (Crown 2)");
    stb_tdc_2->Print();
  }
  
  for (Int_t k=0;k<n_stb_hist;k++) {
    sprintf(hname,"stbtdc_2_%d",k+1);
    sprintf(htitle,"TDC  for Crown: 2 Tube: %d",k+1);
    stbtdc2[k] = new TH1F(hname,htitle,stb_tdc_bins,stb_tdc_min,stb_tdc_max);
    stbtdc2[k]->SetFillColor(6); 
  }
  
  //   STB   TDC Crown 3
  
  if(shmflg) {
    const char *mfnstb3 = "stb_tdc_3.map";
    //TMapFile::SetMapAddress(0x42f82000);  
    stb_tdc_3 = TMapFile::Create(mfnstb3,"RECREATE",2000000,"Stb memory mapped file with TDC histograms (Crown 3)");
    stb_tdc_3->Print();
  }
  
  for (Int_t j=0;j<n_stb_hist;j++) {
    sprintf(hname,"stbtdc_3_%d",j+1);
    sprintf(htitle,"TDC  for Crown: 3 Tube: %d",j+1);
    stbtdc3[j] = new TH1F(hname,htitle,stb_tdc_bins,stb_tdc_min,stb_tdc_max);
    stbtdc3[j]->SetFillColor(6); 
  }
  
  //   STB   TDC Crown 4
  
  if(shmflg) {
    const char *mfnstb4 = "stb_tdc_4.map";
    //TMapFile::SetMapAddress(0x43447000);  
    stb_tdc_4 = TMapFile::Create(mfnstb4,"RECREATE",2000000,"Stb memory mapped file with TDC histograms (Crown 4)");
    stb_tdc_4->Print();
  }
  
  for (Int_t ik=0;ik<n_stb_hist;ik++) {
    sprintf(hname,"stbtdc_4_%d",ik+1);
    sprintf(htitle,"TDC  for Crown: 4 Tube: %d",ik+1);
    stbtdc4[ik] = new TH1F(hname,htitle,stb_tdc_bins,stb_tdc_min,stb_tdc_max);
    stbtdc4[ik]->SetFillColor(6); 
  }
  
  //   STB   TDC Crown 5
  
  if(shmflg) {
    const char *mfnstb5 = "stb_tdc_5.map";
    //TMapFile::SetMapAddress(0x4390c000);  
    stb_tdc_5 = TMapFile::Create(mfnstb5,"RECREATE",2000000,"Stb memory mapped file with TDC histograms (Crown 5)");
    stb_tdc_5->Print();
  }
  
  for (Int_t il=0;il<n_stb_hist;il++) {
    sprintf(hname,"stbtdc_5_%d",il+1);
    sprintf(htitle,"TDC  for Crown: 5 Tube: %d",il+1);
    stbtdc5[il] = new TH1F(hname,htitle,stb_tdc_bins,stb_tdc_min,stb_tdc_max);
    stbtdc5[il]->SetFillColor(6); 
  }
  
  //   STB   TDC Crown 6
  
  if(shmflg) {
    const char *mfnstb6 = "stb_tdc_6.map";
    //TMapFile::SetMapAddress(0x43dd1000);  
    stb_tdc_6 = TMapFile::Create(mfnstb6,"RECREATE",2000000,"Stb memory mapped file with TDC histograms (Crown 6)");
    stb_tdc_6->Print();
  }
  
  for (Int_t jl=0;jl<n_stb_hist;jl++) {
    sprintf(hname,"stbtdc_6_%d",jl+1);
    sprintf(htitle,"TDC  for Crown: 6 Tube: %d",jl+1);
    stbtdc6[jl] = new TH1F(hname,htitle,stb_tdc_bins,stb_tdc_min,stb_tdc_max);
    stbtdc6[jl]->SetFillColor(6); 
  }
  
  stb1d = 0;
  stb2d = 0;
}

 TFndStbMon::TFndStbMon() {

  fstb = 0;
  mstb = TMapFile::Create("stb.map","UPDATE");
  mstb->Print();
  stb_tdc_1 = TMapFile::Create("stb_tdc_1.map","UPDATE");
  stb_tdc_1->Print();
  stb_tdc_2 = TMapFile::Create("stb_tdc_2.map","UPDATE");
  stb_tdc_2->Print();
  stb_tdc_3 = TMapFile::Create("stb_tdc_3.map","UPDATE");
  stb_tdc_3->Print();
  stb_tdc_4 = TMapFile::Create("stb_tdc_4.map","UPDATE");
  stb_tdc_4->Print();
  stb_tdc_5 = TMapFile::Create("stb_tdc_5.map","UPDATE");
  stb_tdc_5->Print();
  stb_tdc_6 = TMapFile::Create("stb_tdc_6.map","UPDATE");
  stb_tdc_6->Print();
  stb_mon_tdc = new TCanvas("stb_mon_tdc","Stb TDCs",640,10,400,400);   
  stb_mon_pat = new TCanvas("stb_mon_pat","Stb Patterns",10,10,900,450);   
  stb1d = 0;
  stb2d = 0;
}

 TFndStbMon::~TFndStbMon() {
  if(fstb) fstb->Close();
  delete fstb;
  mstb->Close();
  delete mstb;
  stb_tdc_1->Close();
  delete stb_tdc_1;
  stb_tdc_2->Close();
  delete stb_tdc_2;
  stb_tdc_3->Close();
  delete stb_tdc_3;
  stb_tdc_4->Close();
  delete stb_tdc_4;
  stb_tdc_5->Close();
  delete stb_tdc_5;
  stb_tdc_6->Close();
  delete stb_tdc_6;

  delete stb_mon_tdc;
  delete stb_mon_pat;

  stb1d = 0;
  delete stb1d;
  stb2d = 0;
  delete stb2d;
}

 void TFndStbMon::Fill(TFndHdt *fndhdt) {

  Int_t nhstb = fndhdt->GetNHStb();
  stbmult->Fill((Float_t) nhstb);
  TObjArray *fHStb = fndhdt->GetStb();
  
  for (Int_t j=0; j<nhstb; j++) {
    TFndHStb *hstb = (TFndHStb*) fHStb->At(j);
    Int_t crown = hstb->GetCrown();
    Int_t tube =  hstb->GetTube();
    Float_t tdc = (Float_t) hstb->GetTdc();
    //Float_t ppan = (Float_t) hstb->GetPP();
    
    stbmaptdc->Fill((Float_t ) tube,(Float_t ) crown);
    if(crown == 1) stbtdc1[tube-1]->Fill(tdc);
    if(crown == 2) stbtdc2[tube-1]->Fill(tdc);
    if(crown == 3) stbtdc3[tube-1]->Fill(tdc);
    if(crown == 4) stbtdc4[tube-1]->Fill(tdc);
    if(crown == 5) stbtdc5[tube-1]->Fill(tdc);
    if(crown == 6) stbtdc6[tube-1]->Fill(tdc);
    stb_pattern[crown-1]->Fill((Float_t) tube);
  }
}

 void TFndStbMon::Update() {

  if(shmflg) {
    mstb->Update();
    stb_tdc_1->Update();
    stb_tdc_2->Update();
    stb_tdc_3->Update();
    stb_tdc_4->Update();
    stb_tdc_5->Update();
    stb_tdc_6->Update();
  }
}

 void TFndStbMon::DisplayTube(Int_t crown,Int_t tube) {

  if(crown < 1 || crown > 6) {
    cout << "WRONG crown number " << crown << endl;
    return;
  }
  if(tube < 1 || tube > 404) {
    cout << "WRONG tube number " << tube << endl;
    return;
  }

  Char_t ccrown[2];
  sprintf(ccrown,"%d",crown);
  Char_t ctube[4];
  sprintf(ctube,"%d",tube);
  
  stb_mon_tdc->Clear();

  TString *hname = new TString("stbtdc_");
  hname->Append(ccrown);
  hname->Append("_");
  hname->Append(ctube);
  
  if(crown == 1)  stb1d = (TH1F *) stb_tdc_1->Get(hname->Data());
  if(crown == 2)  stb1d = (TH1F *) stb_tdc_2->Get(hname->Data());
  if(crown == 3)  stb1d = (TH1F *) stb_tdc_3->Get(hname->Data());
  if(crown == 4)  stb1d = (TH1F *) stb_tdc_4->Get(hname->Data());
  if(crown == 5)  stb1d = (TH1F *) stb_tdc_5->Get(hname->Data());
  if(crown == 6)  stb1d = (TH1F *) stb_tdc_6->Get(hname->Data());
  
  stb1d->Draw();
  delete hname;
  
  stb_mon_tdc->Update();
  
}

 void TFndStbMon::DisplayPattern(Int_t crown) {

  if(crown < 1 || crown > 6) {
    cout << "WRONG crown number " << crown << endl;
    return;
  }

  stb_mon_pat->Clear();
  //  stb_mon_pat->Divide(2,3);

  Char_t ccrown[2];
  sprintf(ccrown,"%d",crown);
  TString *hname = new TString("stb_pattern_");
  hname->Append(ccrown);

  stb1d = (TH1F *) mstb->Get(hname->Data());
  
  stb1d->Draw();
  delete hname;
  
  stb_mon_pat->Update();
  
}

 void TFndStbMon::WriteToFile() {
  fstb->cd();
  stbmult->Write();
  stbmaptdc->Write();

  for(Int_t i=0; i<n_stb_crwn; i++) stb_pattern[i]->Write();
  for(Int_t j=0; j<n_stb_hist; j++) {
    stbtdc1[j]->Write();
    stbtdc2[j]->Write();
    stbtdc3[j]->Write();
    stbtdc4[j]->Write();
    stbtdc5[j]->Write();
    stbtdc6[j]->Write();
  }
}

 void TFndStbMon::Streamer(TBuffer &R__b) {}