#include "HDEAnaHistManager.h"
#include "HDEAnaUtils.h"

#include "TH1.h"
#include "TH2.h"
#include "TNamed.h"
#include "TGraph.h"
#include "TGraph2D.h"
#include "TProfile.h"
#include "TProfile2D.h"
#include "TFile.h"
#include "TDirectory.h"
#include "TKey.h"
#include "TClass.h"

#include <boost/regex.hpp>
#include <vector>
#include <map>
#include <string>
#include <cassert>
#include <iostream>
#include <algorithm>


class CompareTNamedMore:
   public std::binary_function<
   const TNamed*,
   const TNamed*,
   Bool_t>
{
public:
   Bool_t operator()(const TNamed* object1, const TNamed* object2) const {
      return string(object1->GetName()) > string(object2->GetName());
   }
};

HDEAnaHistManager::HDEAnaHistManager():
      fMap()
{

}

HDEAnaHistManager::~HDEAnaHistManager()
{

}

template<class T> vector<T> HDEAnaHistManager::ObjectVector(
         const string& pattern) const
{
  vector<T> objects;

  try {
	const boost::regex e(pattern);
	map<string, TNamed*>::const_iterator it;
	for (it = fMap.begin(); it != fMap.end(); it++) {
		if (boost::regex_match(it->first, e)){
			T ObjectPointer = dynamic_cast<T>(it->second);
			if (ObjectPointer != nullptr)
				objects.push_back(ObjectPointer);
		}

	}
  } catch (exception& ex) {
    cout << "Exception in HDEAnaHistManager::ObjectVector: " << ex.what() << endl;
  }

  sort(objects.begin(), objects.end(), CompareTNamedMore());
  return objects;
}

vector<TH1*> HDEAnaHistManager::H1Vector(
      const string& pattern) const
{
	return ObjectVector<TH1*>(pattern);
}

vector<TH2*> HDEAnaHistManager::H2Vector(
      const string& pattern) const
{
	return ObjectVector<TH2*>(pattern);
}

vector<TGraph*> HDEAnaHistManager::G1Vector(
      const string& pattern) const
{
	return ObjectVector<TGraph*>(pattern);
}

vector<TGraph2D*> HDEAnaHistManager::G2Vector(
      const string& pattern) const
{
	return ObjectVector<TGraph2D*>(pattern);
}

vector<TProfile*> HDEAnaHistManager::P1Vector(
      const string& pattern) const
{
   return ObjectVector<TProfile*>(pattern);
}

vector<TProfile2D*> HDEAnaHistManager::P2Vector(
      const string& pattern) const
{
   return ObjectVector<TProfile2D*>(pattern);
}

void HDEAnaHistManager::WriteToFile()
{
   map<string, TNamed*>::iterator it;
   for (it = fMap.begin(); it != fMap.end(); it++){
      it->second->Write();
   }
}

void HDEAnaHistManager::ReadFromFile(
      TFile* file)
{
   assert(file != NULL);
   cout << "HDEAnaHistManager::ReadFromFile" << endl;
   TDirectory* dir = gDirectory;
   TIter nextkey(dir->GetListOfKeys());
   TKey *key;
//   Int_t c = 0;
   while ((key = (TKey*) nextkey())) {
      TObject* obj = key->ReadObj();
      if (obj->IsA()->InheritsFrom (TH1::Class()) || obj->IsA()->InheritsFrom (TGraph::Class()) || obj->IsA()->InheritsFrom (TGraph2D::Class())) {
         TNamed* h = (TNamed*) obj;
         TNamed* h1 = (TNamed*)file->Get(h->GetName());
         Add(string(h->GetName()), h1);
      }
   }
}

void HDEAnaHistManager::Clear(Option_t*)
{
   map<string, TNamed*>::iterator it;
   for (it = fMap.begin(); it != fMap.end(); it++) {
      delete (*it).second;
   }
   fMap.clear();
}

void HDEAnaHistManager::ShrinkEmptyBinsH1(
      const string& histName)
{
   TH1* hist = H1(histName);
   Int_t nofBins = hist->GetNbinsX();
   Int_t minShrinkBin = std::numeric_limits<Int_t>::max();
   Int_t maxShrinkBin = std::numeric_limits<Int_t>::min();
   Bool_t isSet = false;
   for (Int_t iBin = 1; iBin <= nofBins; iBin++) {
      Double_t content = hist->GetBinContent(iBin);
      if (content != 0.) {
         minShrinkBin = std::min(iBin, minShrinkBin);
         maxShrinkBin = std::max(iBin, maxShrinkBin);
         isSet = true;
      }
   }
   if (isSet) {
      hist->GetXaxis()->SetRange(minShrinkBin, maxShrinkBin);
     // hist->GetYaxis()->SetRange(minShrinkBin, maxShrinkBin);
   }
}

void HDEAnaHistManager::ShrinkEmptyBinsH1ByPattern(
      const string& pattern)
{
	vector<TH1*> effHistos = H1Vector(pattern);
	Int_t nofEffHistos = effHistos.size();
	for (Int_t iHist = 0; iHist < nofEffHistos; iHist++) {
		ShrinkEmptyBinsH1(effHistos[iHist]->GetName());
	}
}

void HDEAnaHistManager::ShrinkEmptyBinsH2(
      const string& histName)
{
   TH1* hist = H2(histName);
   Int_t nofBinsX = hist->GetNbinsX();
   Int_t nofBinsY = hist->GetNbinsY();
   Int_t minShrinkBinX = std::numeric_limits<Int_t>::max();
   Int_t maxShrinkBinX = std::numeric_limits<Int_t>::min();
   Int_t minShrinkBinY = std::numeric_limits<Int_t>::max();
   Int_t maxShrinkBinY = std::numeric_limits<Int_t>::min();
   Bool_t isSet = false;
   for (Int_t iBinX = 1; iBinX <= nofBinsX; iBinX++) {
      for (Int_t iBinY = 1; iBinY <= nofBinsY; iBinY++) {
         Double_t content = hist->GetBinContent(iBinX, iBinY);
         if (content != 0.) {
            minShrinkBinX = std::min(iBinX, minShrinkBinX);
            maxShrinkBinX = std::max(iBinX, maxShrinkBinX);
            minShrinkBinY = std::min(iBinY, minShrinkBinY);
            maxShrinkBinY = std::max(iBinY, maxShrinkBinY);
            isSet = true;
         }
      }
   }
   if (isSet) {
      hist->GetXaxis()->SetRange(minShrinkBinX, maxShrinkBinX);
      hist->GetYaxis()->SetRange(minShrinkBinY, maxShrinkBinY);
   }
}

void HDEAnaHistManager::ShrinkEmptyBinsH2ByPattern(
      const string& pattern)
{
   vector<TH1*> effHistos = H1Vector(pattern);
   Int_t nofEffHistos = effHistos.size();
   for (Int_t iHist = 0; iHist < nofEffHistos; iHist++) {
      ShrinkEmptyBinsH2(effHistos[iHist]->GetName());
   }
}

void HDEAnaHistManager::Scale(
      const string& histName,
      Double_t scale)
{
	H1(histName)->Scale(scale);
}

void HDEAnaHistManager::Scale(
			      const std::vector<TH1*>& hVec,
			      Double_t scale)
{
    for (UInt_t i = 0; i < hVec.size(); i++) {
	hVec[i]->Scale(scale);
    }
}

void HDEAnaHistManager::ScaleByPattern(
      const string& pattern,
      Double_t scale)
{
	vector<TH1*> effHistos = H1Vector(pattern);
	Int_t nofEffHistos = effHistos.size();
	for (Int_t iHist = 0; iHist < nofEffHistos; iHist++) {
		Scale(effHistos[iHist]->GetName(), scale);
	}
}

void HDEAnaHistManager::NormalizeToIntegral(
      const string& histName)
{
   TH1* hist = H1(histName);
   hist->Scale(1. / hist->Integral());
}

void HDEAnaHistManager::NormalizeToIntegral(
					    const vector<TH1*>& hVec)
{
    for (UInt_t i = 0; i < hVec.size(); i++) {
	hVec[i]->Scale(1./hVec[i]->Integral());
    }
}

void HDEAnaHistManager::NormalizeToIntegralByPattern(
      const string& pattern)
{
   vector<TH1*> effHistos = H1Vector(pattern);
   Int_t nofEffHistos = effHistos.size();
   for (Int_t iHist = 0; iHist < nofEffHistos; iHist++) {
      NormalizeToIntegral(effHistos[iHist]->GetName());
   }
}

void HDEAnaHistManager::Rebin(
      const string& histName,
      Int_t ngroup)
{
	TH1* hist = H1(histName);
	if (ngroup > 1) {
		hist->Rebin(ngroup);
		hist->Scale(1. / (Double_t)ngroup);
	}
}

void HDEAnaHistManager::RebinByPattern(
      const string& pattern,
      Int_t ngroup)
{
	vector<TH1*> effHistos = H1Vector(pattern);
	Int_t nofEffHistos = effHistos.size();
	for (Int_t iHist = 0; iHist < nofEffHistos; iHist++) {
		Rebin(effHistos[iHist]->GetName(), ngroup);
	}
}

string HDEAnaHistManager::ToString() const
{
	string str = "HDEAnaHistManager list of histograms:\n";
	map<string, TNamed*>::const_iterator it;
	for (it = fMap.begin(); it != fMap.end(); it++){
		str += it->first + "\n";
	}
	return str;
}

TCanvas* HDEAnaHistManager::CreateCanvas(
		const std::string& name,
		const std::string& title,
		Int_t width,
		Int_t height)
{
	TCanvas* c = new TCanvas(name.c_str(), title.c_str(), width, height);
	fCanvases.push_back(c);
	return c;
}

void HDEAnaHistManager::SaveCanvasToImage(
		const std::string& outputDir,
		const std::string& options)
{
	for (unsigned int i = 0; i < fCanvases.size(); i++) {
		HDEAna::SaveCanvasAsImage(fCanvases[i], outputDir, options);
	}
}
std::vector<TH1*> HDEAnaHistManager::GetH1ByNames(
						 const std::string& hName1,
						 const std::string& hName2)
{
    std::vector<TH1*> h;
    h.push_back(this->H1(hName1));
    h.push_back(this->H1(hName2));
    return h;
}


std::vector<TH1*> HDEAnaHistManager::GetH1ByNames(
						  const std::string& hName1,
						  const std::string& hName2,
						  const std::string& hName3)
{
    std::vector<TH1*> h;
    h.push_back(this->H1(hName1));
    h.push_back(this->H1(hName2));
    h.push_back(this->H1(hName3));
    return h;
}

std::vector<TH1*> HDEAnaHistManager::GetH1ByNames(
						  const std::string& hName1,
						  const std::string& hName2,
						  const std::string& hName3,
						  const std::string& hName4)
{
    std::vector<TH1*> h;
    h.push_back(this->H1(hName1));
    h.push_back(this->H1(hName2));
    h.push_back(this->H1(hName3));
    h.push_back(this->H1(hName4));
    return h;
}

std::vector<TH1*> HDEAnaHistManager::GetH1ByNames(
						  const std::string& hName1,
						  const std::string& hName2,
						  const std::string& hName3,
						  const std::string& hName4,
						  const std::string& hName5)
{
    std::vector<TH1*> h;
    h.push_back(this->H1(hName1));
    h.push_back(this->H1(hName2));
    h.push_back(this->H1(hName3));
    h.push_back(this->H1(hName4));
    h.push_back(this->H1(hName5));
    return h;
}

std::vector<TH1*> HDEAnaHistManager::GetH1ByNames(
						  const std::string& hName1,
						  const std::string& hName2,
						  const std::string& hName3,
						  const std::string& hName4,
						  const std::string& hName5,
						  const std::string& hName6)
{
    std::vector<TH1*> h;
    h.push_back(this->H1(hName1));
    h.push_back(this->H1(hName2));
    h.push_back(this->H1(hName3));
    h.push_back(this->H1(hName4));
    h.push_back(this->H1(hName5));
    h.push_back(this->H1(hName6));
    return h;
}

std::vector<TH2*> HDEAnaHistManager::GetH2ByNames(
						  const std::string& hName1,
						  const std::string& hName2)
{
    std::vector<TH2*> h;
    h.push_back(this->H2(hName1));
    h.push_back(this->H2(hName2));
    return h;
}

std::vector<TH2*> HDEAnaHistManager::GetH2ByNames(
						  const std::string& hName1,
						  const std::string& hName2,
						  const std::string& hName3)
{
    std::vector<TH2*> h;
    h.push_back(this->H2(hName1));
    h.push_back(this->H2(hName2));
    h.push_back(this->H2(hName3));
    return h;
}

std::vector<TH2*> HDEAnaHistManager::GetH2ByNames(
						  const std::string& hName1,
						  const std::string& hName2,
						  const std::string& hName3,
						  const std::string& hName4)
{
    std::vector<TH2*> h;
    h.push_back(this->H2(hName1));
    h.push_back(this->H2(hName2));
    h.push_back(this->H2(hName3));
    h.push_back(this->H2(hName4));
    return h;
}

std::vector<TH2*> HDEAnaHistManager::GetH2ByNames(
						  const std::string& hName1,
						  const std::string& hName2,
						  const std::string& hName3,
						  const std::string& hName4,
						  const std::string& hName5)
{
    std::vector<TH2*> h;
    h.push_back(this->H2(hName1));
    h.push_back(this->H2(hName2));
    h.push_back(this->H2(hName3));
    h.push_back(this->H2(hName4));
    h.push_back(this->H2(hName5));
    return h;
}

std::vector<TH2*> HDEAnaHistManager::GetH2ByNames(
						  const std::string& hName1,
						  const std::string& hName2,
						  const std::string& hName3,
						  const std::string& hName4,
						  const std::string& hName5,
						  const std::string& hName6)
{
    std::vector<TH2*> h;
    h.push_back(this->H2(hName1));
    h.push_back(this->H2(hName2));
    h.push_back(this->H2(hName3));
    h.push_back(this->H2(hName4));
    h.push_back(this->H2(hName5));
    h.push_back(this->H2(hName6));
    return h;
}

std::vector<TH1*> HDEAnaHistManager::GetH2ProjectionYByNames(
							     const std::string& hName1,
							     const std::string& hName2)
{
    std::vector<TH1*> h;
    h.push_back(this->H2(hName1)->ProjectionY());
    h.push_back(this->H2(hName2)->ProjectionY());
    return h;
}

std::vector<TH1*> HDEAnaHistManager::GetH2ProjectionYByNames(
							     const std::string& hName1,
							     const std::string& hName2,
							     const std::string& hName3)
{
    std::vector<TH1*> h;
    h.push_back(this->H2(hName1)->ProjectionY());
    h.push_back(this->H2(hName2)->ProjectionY());
    h.push_back(this->H2(hName3)->ProjectionY());
    return h;
}

std::vector<TH1*> HDEAnaHistManager::GetH2ProjectionYByNames(
							     const std::string& hName1,
							     const std::string& hName2,
							     const std::string& hName3,
							     const std::string& hName4)
{
    std::vector<TH1*> h;
    h.push_back(this->H2(hName1)->ProjectionY());
    h.push_back(this->H2(hName2)->ProjectionY());
    h.push_back(this->H2(hName3)->ProjectionY());
    h.push_back(this->H2(hName4)->ProjectionY());
    return h;
}

std::vector<TH1*> HDEAnaHistManager::GetH2ProjectionYByNames(
							     const std::string& hName1,
							     const std::string& hName2,
							     const std::string& hName3,
							     const std::string& hName4,
							     const std::string& hName5)
{
    std::vector<TH1*> h;
    h.push_back(this->H2(hName1)->ProjectionY());
    h.push_back(this->H2(hName2)->ProjectionY());
    h.push_back(this->H2(hName3)->ProjectionY());
    h.push_back(this->H2(hName4)->ProjectionY());
    h.push_back(this->H2(hName5)->ProjectionY());
    return h;
}

std::vector<TH1*> HDEAnaHistManager::GetH2ProjectionYByNames(
							     const std::string& hName1,
							     const std::string& hName2,
							     const std::string& hName3,
							     const std::string& hName4,
							     const std::string& hName5,
							     const std::string& hName6)
{
    std::vector<TH1*> h;
    h.push_back(this->H2(hName1)->ProjectionY());
    h.push_back(this->H2(hName2)->ProjectionY());
    h.push_back(this->H2(hName3)->ProjectionY());
    h.push_back(this->H2(hName4)->ProjectionY());
    h.push_back(this->H2(hName5)->ProjectionY());
    h.push_back(this->H2(hName6)->ProjectionY());
    return h;
}

ClassImp(HDEAnaHistManager)