/// Class to hold TPC MM spark count for
/// a range of times, and  spark rate. 
/// Uses ITPCMMSpark to read the values at 
/// a particular time.
///
/// Blair Jamieson (C) 2010

#include "ITPCSparkCounter.hxx"


/// Initialize TPC MM HV spark counter object using unix time and time interval
ITPCSparkCounter::ITPCSparkCounter( long autimemin,  long autimemax, int adt, bool verbose, bool makeplots){
  fStart = autimemin;
  fEnd   = autimemax;
  fDT    = adt;
  fVerbose   = verbose;
  fMakePlots = makeplots;
  Init();
}

/// Initialize TPC MM status object using year, month(0-11),
/// day(1-31),...
ITPCSparkCounter::ITPCSparkCounter( int ayearmin, int amonthmin, int adaymin, int ahourmin, int aminmin, int asecmin,
				    int ayearmax, int amonthmax, int adaymax, int ahourmax, int aminmax, int asecmax,
				    int adt, bool verbose, bool makeplots ){
  tm mt;  
  fVerbose   = verbose;
  fMakePlots = makeplots;
  fDT        = adt;
  // use time structure from time.h
  // to build unix time from year,month, etc.
  mt.tm_year = ayearmin - 1900;
  mt.tm_mon  = amonthmin-1;
  mt.tm_mday = adaymin;
  mt.tm_hour = ahourmin;
  mt.tm_min  = aminmin;
  mt.tm_sec  = asecmin;
  mt.tm_isdst = -1;
  fStart = (long)mktime(&mt);
  
  mt.tm_year = ayearmax - 1900;
  mt.tm_mon  = amonthmax-1;
  mt.tm_mday = adaymax;
  mt.tm_hour = ahourmax;
  mt.tm_min  = aminmax;
  mt.tm_sec  = asecmax;
  mt.tm_isdst = -1;
  fEnd = (long)mktime(&mt);
  
  Init();
}


/// Save graph values
void ITPCSparkCounter::SaveGraphValues( ITPCMMSpark &spark, bool lastflag ){

  // see if we have a good reading
  if ( spark.GetSpark(0,0,0) < 0 ){
    // handle bad reading
    // bad reading... what to do? leave last count and time as is
    
  } else {
    // yes it is good.
    // check if count reset?
    bool countreset = false;
    for (int itpc=0; itpc<3; itpc++){
      for (int irp=0; irp<2; irp++ ){
	for (int imm=0; imm<12; imm++){    
	  if ( fLastCount[itpc][irp][imm] > spark.GetSpark(itpc,irp,imm) )
	    countreset = true;
	}
      }
    }


    if ( countreset == true ){
      // good reading, but reset!  so no measurement from last time
      // update lastcount and lasttime, but not count and timesum  
      for (int itpc=0; itpc<3; itpc++){
	for (int irp=0; irp<2; irp++ ){
	  for (int imm=0; imm<12; imm++){
	    fLastCount[itpc][irp][imm] = spark.GetSpark(itpc,irp,imm);
	  }
	}
      }
      fLastTime = spark.GetTime();  

    } else {
      // update counters
      for (int itpc=0; itpc<3; itpc++){
	for (int irp=0; irp<2; irp++ ){
	  for (int imm=0; imm<12; imm++){
	  fCount[itpc][irp][imm] += ( spark.GetSpark(itpc,irp,imm) - fLastCount[itpc][irp][imm] );
	  fLastCount[itpc][irp][imm] = spark.GetSpark(itpc,irp,imm);
	  }
	}
      }
      fTimeSum += ( spark.GetTime() - fLastTime );
      fLastTime = spark.GetTime();
    }
  }
   
  // see if this is last call, or if timesum is > time interval?
  if ( lastflag==true || fTimeSum >= fDT ){
    int asum=0;
    for (int itpc=0; itpc<3; itpc++){
      int atpcsum = 0;
      for (int irp=0; irp<2; irp++ ){
	int arpsum = 0;
	for (int imm=0; imm<12; imm++){
	  fSparkCount[itpc][irp][imm].Add( spark.GetTime(), fCount[itpc][irp][imm], lastflag );
	  fSparkFreq[itpc][irp][imm].Add( spark.GetTime(),
					  double( fCount[itpc][irp][imm] ) /
					  ( double( fTimeSum )/24./3600. ), lastflag );
	  fSparkCnt.Add( spark.GetTime(), fCount[itpc][irp][imm], lastflag );
	  fSparkFrq.Add( spark.GetTime(),
			 double( fCount[itpc][irp][imm] ) /
			 ( double( fTimeSum )/24./3600. ), lastflag );
	  // reset counters
	  asum += fCount[itpc][irp][imm];
	  arpsum += fCount[itpc][irp][imm];
	  atpcsum += fCount[itpc][irp][imm];
	  fCount[itpc][irp][imm] = 0;
	}
	fSparkCountEP[itpc][irp].Add( spark.GetTime(), double(arpsum), lastflag );
	fSparkFreqEP[itpc][irp].Add( spark.GetTime(), double(arpsum)/(double(fTimeSum)/24./3600.), lastflag );
      }
      fSparkCountTPC[itpc].Add( spark.GetTime(), double(atpcsum), lastflag );
      fSparkFreqTPC[itpc].Add( spark.GetTime(), double(atpcsum)/(double(fTimeSum)/24./3600.), lastflag );

    }
    // sum plot
    fSparkCntAll.Add( spark.GetTime(), double(asum), lastflag );
    fSparkFrqAll.Add( spark.GetTime(), double(asum)/(double(fTimeSum)/24./3600.), lastflag );

    fTimeSum = 0;
  }
  return;
}


/// Initialize livetime and status objects
void ITPCSparkCounter::Init(){
  /// Setup count histogram to be integer style
  fTimeSum = 0;
  for ( int itpc = 0 ; itpc < 3 ; itpc++ ){
    for ( int irp = 0 ; irp < 2; irp++ ){
      for ( int imm = 0 ; imm < 12 ; imm++ ){
	fSparkCount[itpc][irp][imm].fIsInteger=true;
	fCount[itpc][irp][imm] = 0;
      }
    }
  }
  fSparkCnt.fIsInteger=true;
  fSparkCntAll.fIsInteger=true;

  
  // Build initial MM HV Spark reader at start-time
  ITPCMMSpark mmspark( fStart, fEnd );
  long atime= mmspark.GetTime();
  fLastTime = atime;
  // store intial spark count
  for ( int itpc = 0 ; itpc < 3 ; itpc++ ){
    for ( int irp = 0 ; irp < 2; irp++ ){
      for ( int imm = 0 ; imm < 12 ; imm++ ){
	fLastCount[itpc][irp][imm] = mmspark.GetSpark(itpc,irp,imm);
      }
    }
  }
  long astart_time;
  long aend_time;
  mmspark.GetTimeInterval( astart_time, aend_time );
  // Update counters, and fill plots if have reached time interval until
  // we reach end of times requested.
  // also count queries
  int nquery = 0;
  do {
    if( fVerbose==true && nquery%50 == 0 ){
      std::cout<<"DB Query "<<nquery
	       <<" time = "<<mmspark.GetTimeStamp();
    }

    SaveGraphValues( mmspark, false );
    mmspark.ReadNext(); 
    atime= mmspark.GetTime();
    mmspark.GetTimeInterval( astart_time, aend_time );
    nquery++;
  } while ( aend_time < fEnd );
  
  // Add the final point
  SaveGraphValues( mmspark, true );
  
  // Save plots to a root file
  SavePlotsToFile();
  
}


/// Collect all of the TGraphs, and save them to file.
void ITPCSparkCounter::SavePlotsToFile(){

  char aname[256];
  sprintf(aname,"ttpcsparkcounter_%ld_to_%ld.root",fStart,fEnd);
  TFile fout(aname,"recreate");

  TCanvas*tcchbyep = new TCanvas("tcchbyep","",1200,800);
  tcchbyep->Divide(3,2);
  TCanvas*tccgbyep = new TCanvas("tccgbyep","",1200,800);
  tccgbyep->Divide(3,2);
  TCanvas*tcfhbyep = new TCanvas("tcfhbyep","",1200,800);
  tcfhbyep->Divide(3,2);
  TCanvas*tcfgbyep = new TCanvas("tcfgbyep","",1200,800);
  tcfgbyep->Divide(3,2);

  // save spark count plots 
  for (int itpc=0; itpc<3; itpc++){
    sprintf(aname,"tcchtpc%d",itpc);
    TCanvas * tcchtpc = new TCanvas(aname,"",600,800);
    sprintf(aname,"tccgtpc%d",itpc);
    TCanvas * tccgtpc = new TCanvas(aname,"",600,800);
    sprintf(aname,"tcfhtpc%d",itpc);
    TCanvas * tcfhtpc = new TCanvas(aname,"",600,800);
    sprintf(aname,"tcfgtpc%d",itpc);
    TCanvas * tcfgtpc = new TCanvas(aname,"",600,800);
    for (int irp=0; irp<2; irp++ ){
      sprintf(aname,"tccg%d%d",itpc,irp);
      TCanvas* tccg = new TCanvas(aname,"",1200,800);
      sprintf(aname,"tcch%d%d",itpc,irp);
      TCanvas* tcch = new TCanvas(aname,"",1200,800);
      sprintf(aname,"tcfg%d%d",itpc,irp);
      TCanvas* tcfg = new TCanvas(aname,"",1200,800);
      sprintf(aname,"tcfh%d%d",itpc,irp);
      TCanvas* tcfh = new TCanvas(aname,"",1200,800);
      tccg->Divide(3,4);
      tcfg->Divide(3,4);
      tcch->Divide(3,4);
      tcfh->Divide(3,4);

      // First by mm plots
      for (int imm=0; imm<12; imm++){	
	sprintf(aname,"Sparks in %4.1fd TPC%d RP%d MM%02d",float(fDT)/24./3600.,itpc+1,irp,imm);
	fSparkCount[itpc][irp][imm].Print(aname,fVerbose);
	sprintf(aname,"sparks_tpc%d_rp%d_mm%02d",itpc+1,irp,imm);
	fSparkCount[itpc][irp][imm].MakePlot(aname,false);
	fSparkCount[itpc][irp][imm].fGraph->Write();
	fSparkCount[itpc][irp][imm].fHist->Write();
	tccg->cd(imm+1);
	fSparkCount[itpc][irp][imm].fGraph->Draw("AP");
	tcch->cd(imm+1);
	fSparkCount[itpc][irp][imm].fHist->Draw();
	
	sprintf(aname,"Sparks [/day] in %4.1fd TPC%d RP%d MM%02d",float(fDT)/24./3600.,itpc+1,irp,imm);
	fSparkFreq[itpc][irp][imm].Print(aname,fVerbose);
	sprintf(aname,"sparkf_tpc%d_rp%d_mm%02d",itpc+1,irp,imm);
	fSparkFreq[itpc][irp][imm].MakePlot(aname,false);
	fSparkFreq[itpc][irp][imm].fGraph->Write();
	fSparkFreq[itpc][irp][imm].fHist->Write();

	tcfg->cd(imm+1);
	fSparkFreq[itpc][irp][imm].fGraph->Draw("AP");
	tcfh->cd(imm+1);
	fSparkFreq[itpc][irp][imm].fHist->Draw();
      }
      if ( fMakePlots == true ){
	sprintf(aname,"sparkcnt_graph_tpc%d_rp%d.png",itpc+1,irp);
	tccg->Print(aname);
	sprintf(aname,"sparkcnt_hist_tpc%d_rp%d.png",itpc+1,irp);
	tcch->Print(aname);
	sprintf(aname,"sparkfrq_graph_tpc%d_rp%d.png",itpc+1,irp);
	tcfg->Print(aname);
	sprintf(aname,"sparkfrq_hist_tpc%d_rp%d.png",itpc+1,irp);
	tcfh->Print(aname);
      }
    
      // Second, plots by endplate
      sprintf(aname,"Sparks in %4.1fd TPC%d RP%d",float(fDT)/24./3600.,itpc+1,irp);
      fSparkCountEP[itpc][irp].Print(aname,fVerbose);
      sprintf(aname,"EP%d_sparks_tpc%d",irp,itpc+1);
      fSparkCountEP[itpc][irp].MakePlot(aname,false);
      fSparkCountEP[itpc][irp].fGraph->Write();
      fSparkCountEP[itpc][irp].fHist->Write();
      tccgbyep->cd( irp*3 + itpc + 1);
      fSparkCountEP[itpc][irp].fGraph->Draw("AP");
      tcchbyep->cd( irp*3 + itpc + 1);
      fSparkCountEP[itpc][irp].fHist->Draw();
	
      sprintf(aname,"Sparks [/day] in %4.1fd TPC%d RP%d",float(fDT)/24./3600.,itpc+1,irp);
      fSparkFreqEP[itpc][irp].Print(aname,fVerbose);
      sprintf(aname,"EP%d_sparkf_tpc%d",irp,itpc+1);
      fSparkFreqEP[itpc][irp].MakePlot(aname,false);
      fSparkFreqEP[itpc][irp].fGraph->Write();
      fSparkFreqEP[itpc][irp].fHist->Write();

      tcfgbyep->cd( irp*3 + itpc + 1);
      fSparkFreqEP[itpc][irp].fGraph->Draw("AP");
      tcfhbyep->cd( irp*3 + itpc + 1);
      fSparkFreqEP[itpc][irp].fHist->Draw();
    }

    // Third, plots by TPC
    sprintf(aname,"Sparks in %4.1fd TPC%d",float(fDT)/24./3600.,itpc+1);
    fSparkCountTPC[itpc].Print(aname,fVerbose);
    sprintf(aname,"TPC%d_sparks",itpc+1);
    fSparkCountTPC[itpc].MakePlot(aname,false);
    fSparkCountTPC[itpc].fGraph->Write();
    fSparkCountTPC[itpc].fHist->Write();
    tccgtpc->cd();
    fSparkCountTPC[itpc].fGraph->Draw("AP");
    tcchtpc->cd();
    fSparkCountTPC[itpc].fHist->Draw();
	
    sprintf(aname,"Sparks [/day] in %4.1fd TPC%d",float(fDT)/24./3600.,itpc+1);
    fSparkFreqTPC[itpc].Print(aname,fVerbose);
    sprintf(aname,"TPC%d_sparkf",itpc+1);
    fSparkFreqTPC[itpc].MakePlot(aname,false);
    fSparkFreqTPC[itpc].fGraph->Write();
    fSparkFreqTPC[itpc].fHist->Write();
    
    tcfgtpc->cd();
    fSparkFreqTPC[itpc].fGraph->Draw("AP");
    tcfhtpc->cd();
    fSparkFreqTPC[itpc].fHist->Draw();
    
    if ( fMakePlots==true ){
      sprintf(aname,"TPC%d_sparkcnt_graph.png",itpc+1);
      tccgtpc->Print(aname);
      sprintf(aname,"TPC%d_sparkcnt_hist.png",itpc+1);
      tcchtpc->Print(aname);
      sprintf(aname,"TPC%d_sparkfrq_graph.png",itpc+1);
      tcfgtpc->Print(aname);
      sprintf(aname,"TPC%d_sparkfrq_hist.png",itpc+1);
      tcfhtpc->Print(aname);
    }
  }


  if ( fMakePlots==true ){
    tccgbyep->Print("EP_sparkcnt_graph.png");
    tcchbyep->Print("EP_sparkcnt_hist.png");
    tcfgbyep->Print("EP_sparkfrq_graph.png");
    tcfhbyep->Print("EPsparkfrq_hist.png");
  }
  
  TCanvas *c=new TCanvas("allsp","",1200,800);
  c->Divide(2,2);
  sprintf(aname,"All Sparks in %4.1fd",float(fDT)/24./3600.);
  fSparkCntAll.Print(aname,fVerbose);
  sprintf(aname,"allsparks");
  fSparkCntAll.MakePlot(aname,false);
  fSparkCntAll.fGraph->Write();
  fSparkCntAll.fHist->Write();
  c->cd(1);
  fSparkCntAll.fGraph->Draw("AP");
  c->cd(3);
  fSparkCntAll.fHist->Draw();

  sprintf(aname,"All Sparks [/day] in %4.1fd",float(fDT)/24./3600.);
  fSparkFrqAll.Print(aname,fVerbose);
  sprintf(aname,"allsparkf");
  fSparkFrqAll.MakePlot(aname,false);
  fSparkFrqAll.fGraph->Write();
  fSparkFrqAll.fHist->Write();
  c->cd(2);
  fSparkFrqAll.fGraph->Draw("AP");
  c->cd(4);
  fSparkFrqAll.fHist->Draw();

  if ( fMakePlots==true ) {
    c->Print("allsparks.png");
  }


  sprintf(aname,"Sparks/MM in %4.1fd",float(fDT)/24./3600.);
  fSparkCnt.Print(aname,fVerbose);
  sprintf(aname,"sparks");
  fSparkCnt.MakePlot(aname,false);
  fSparkCnt.fGraph->Write();
  fSparkCnt.fHist->Write();
  c->cd(1);
  fSparkCnt.fGraph->Draw("AP");
  c->cd(3);
  fSparkCnt.fHist->Draw();

  sprintf(aname,"Sparks/MM [/day] in %4.1fd",float(fDT)/24./3600.);
  fSparkFrq.Print(aname,fVerbose);
  sprintf(aname,"sparkf");
  fSparkFrq.MakePlot(aname,false);
  fSparkFrq.fGraph->Write();
  fSparkFrq.fHist->Write();
  c->cd(2);
  fSparkFrq.fGraph->Draw("AP");
  c->cd(4);
  fSparkFrq.fHist->Draw();
  if ( fMakePlots==true ) {
    c->Print("sparks.png");
  }
  
  //fout.Write();
  fout.Close();
  return;
}