#include "TChain.h"
#include "TGraph.h"
#include "TAxis.h"
#include "TCanvas.h"
#include "TMath.h"
#include "Helpers.h"

using namespace std;

Float_t eventEnergy(const Float_t* detectorChannelArrayEnergy, const Int_t numChannelsInModule, const Int_t startIndex = 0);

void fillThresholdgraphFrom0To5(TGraph* graph, const Float_t eventEnergy);

void fillThresholdgraphFrom0To1(TGraph* graph, const Float_t eventEnergy);

void fillThresholdgraphFrom0To1dot5(TGraph* graph, const Float_t eventEnergy);

void thresholdPlots();

int main(){
    thresholdPlots();

    return 0;

}

void thresholdPlots(){
    const Int_t NUM_CUTS = 15;

    Double_t Pi0Pt[1];

    Double_t Pi0RecZ[1];

    Float_t DCV1Ene = 0;

    Float_t DCV2Ene = 0;

    Int_t DCVModuleNumber = 0;

    Float_t DCVModuleEne[32];

    Float_t signalBoxX[] = {3000.0, 4000.0, 4700.0, 4700.0, 3000.0, 3000.0};
    Float_t signalBoxY[] = {130.0, 130.0, 150.0, 250.0, 250.0, 130.0};

    Float_t xVals[NUM_CUTS] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5};
    Float_t yVals[NUM_CUTS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

    TCanvas* c = new TCanvas("c", "c", 600, 600);

    TChain* chain = new TChain("RecTree");

    TGraph* signalDCV1 = new TGraph(NUM_CUTS, xVals, yVals);

    TGraph* blindedDCV1 = new TGraph(NUM_CUTS, xVals, yVals);

    TGraph* lowerDCV1 = new TGraph(NUM_CUTS, xVals, yVals);

    TGraph* signalDCV2 = new TGraph(NUM_CUTS, xVals, yVals);

    TGraph* blindedDCV2 = new TGraph(NUM_CUTS, xVals, yVals);

    TGraph* lowerDCV2 = new TGraph(NUM_CUTS, xVals, yVals);

    chain->Add("~/Desktop/Work/DCVcuts/MCfiles/RUN82_KLpipipi0_g2ana_KinCuts_VetoCuts_NoDCV_NoBPCV_NoBHCV_NoCC06_NoCC05_NoCC04.root");

    chain->SetBranchAddress("DCVModuleNumber", &DCVModuleNumber);
    chain->SetBranchAddress("DCVModuleEne", DCVModuleEne);
    chain->SetBranchAddress("Pi0Pt", Pi0Pt);
    chain->SetBranchAddress("Pi0RecZ", Pi0RecZ);

    // Iterate through each entry
    for(Int_t i = 0; i < chain->GetEntries(); i++){
        chain->GetEntry(i);

        DCV1Ene = eventEnergy(DCVModuleEne, 16, 0);

        DCV2Ene = eventEnergy(DCVModuleEne, 16, 16);

        // Check if its in Lower Pt Region
        if(Pi0Pt[0] <= 120 && Pi0RecZ[0] > 2900 && Pi0RecZ[0] < 5100){
            fillThresholdgraphFrom0To1dot5(lowerDCV1, DCV1Ene);

            fillThresholdgraphFrom0To1dot5(lowerDCV2, DCV2Ene);
            
        }
        // Check if its in Blinded Region
        else if(Pi0Pt[0] > 120 && Pi0Pt[0] < 260 && Pi0RecZ[0] > 2900 && Pi0RecZ[0] < 5100){
            fillThresholdgraphFrom0To1dot5(blindedDCV1, DCV1Ene);

            fillThresholdgraphFrom0To1dot5(blindedDCV2, DCV2Ene);

            // Check if its in Signal Region
            if(TMath::IsInside(static_cast<Float_t>(Pi0Pt[0]), static_cast<Float_t>(Pi0RecZ[0]), 6, signalBoxX, signalBoxY) == 1){
                fillThresholdgraphFrom0To1dot5(signalDCV1, DCV1Ene);

                fillThresholdgraphFrom0To1dot5(signalDCV2, DCV2Ene);

            }
            
        }
    }

    c->Divide(3, 2);

    c->cd(1);

    lowerDCV1->SetTitle("DCV1 Lower P_{t} Threshold Count");

    lowerDCV1->GetXaxis()->SetTitle("Energy Threshold [MeV]");

    lowerDCV1->SetMarkerStyle(8);

    lowerDCV1->SetMarkerColorAlpha(1, 0.5);

    lowerDCV1->Draw("PA");

    c->cd(2);

    blindedDCV1->SetTitle("DCV1 Blinded Region Threshold Count");

    blindedDCV1->GetXaxis()->SetTitle("Energy Threshold [MeV]");

    blindedDCV1->SetMarkerStyle(8);

    blindedDCV1->SetMarkerColorAlpha(2, 0.5);

    blindedDCV1->Draw("PA");

    c->cd(3);

    signalDCV1->SetTitle("DCV1 Signal Region Threshold Count");

    signalDCV1->GetXaxis()->SetTitle("Energy Threshold [MeV]");

    signalDCV1->SetMarkerStyle(8);

    signalDCV1->SetMarkerColorAlpha(3, 0.5);

    signalDCV1->Draw("PA");

    c->cd(4);

    lowerDCV2->SetTitle("DCV2 Lower P_{t} Threshold Count");

    lowerDCV2->GetXaxis()->SetTitle("Energy Threshold [MeV]");

    lowerDCV2->SetMarkerStyle(8);

    lowerDCV2->SetMarkerColorAlpha(4, 0.5);

    lowerDCV2->Draw("PA");

    c->cd(5);

    blindedDCV2->SetTitle("DCV2 Blinded Region Threshold Count");

    blindedDCV2->GetXaxis()->SetTitle("Energy Threshold [MeV]");

    blindedDCV2->SetMarkerStyle(8);

    blindedDCV2->SetMarkerColorAlpha(95, 0.5);

    blindedDCV2->Draw("PA");

    c->cd(6);

    signalDCV2->SetFillColorAlpha(6, 0.5);

    signalDCV2->SetTitle("DCV2 Signal Region Threshold Count");

    signalDCV2->GetXaxis()->SetTitle("Energy Threshold [MeV]");

    signalDCV2->SetMarkerStyle(8);

    signalDCV2->SetMarkerColorAlpha(6, 0.5);

    signalDCV2->Draw("PA");

    c->Update();

    //c->Print("~/Desktop/Work/DCVcuts/plots/threshold-graph/DCV-threshold-graph.root");

}

Float_t eventEnergy(const Float_t *detectorChannelArrayEnergy, const Int_t numChannelsInModule, const Int_t startIndex){
    Float_t sum = 0;

    for(Int_t i = startIndex; i < numChannelsInModule + startIndex; i++){
        sum += detectorChannelArrayEnergy[i];

    }

    return sum;

}

void fillThresholdgraphFrom0To5(TGraph *graph, const Float_t eventEnergy){
    Double_t yVal = 0;

    Double_t xVal = 0;

    if(eventEnergy < 0.5){
        graph->GetPoint(0, xVal, yVal);

        yVal++;

        graph->SetPoint(0, xVal, yVal);

    }
    if(eventEnergy < 1.0){
        graph->GetPoint(1, xVal, yVal);

        yVal++;

        graph->SetPoint(1, xVal, yVal);
        
    }
    if(eventEnergy < 1.5){
        graph->GetPoint(2, xVal, yVal);

        yVal++;

        graph->SetPoint(2, xVal, yVal);
        
    }
    if(eventEnergy < 2.0){
        graph->GetPoint(3, xVal, yVal);

        yVal++;

        graph->SetPoint(3, xVal, yVal);
        
    }
    if(eventEnergy < 2.5){
        graph->GetPoint(4, xVal, yVal);

        yVal++;

        graph->SetPoint(4, xVal, yVal);
        
    }
    if(eventEnergy < 3.0){
        graph->GetPoint(5, xVal, yVal);

        yVal++;

        graph->SetPoint(5, xVal, yVal);
        
    }
    if(eventEnergy < 3.5){
        graph->GetPoint(6, xVal, yVal);

        yVal++;

        graph->SetPoint(6, xVal, yVal);
        
    }
    if(eventEnergy < 4.0){
        graph->GetPoint(7, xVal, yVal);

        yVal++;

        graph->SetPoint(7, xVal, yVal);
    
    }
    if(eventEnergy < 4.5){
        graph->GetPoint(8, xVal, yVal);

        yVal++;

        graph->SetPoint(8, xVal, yVal);

    }
    if(eventEnergy < 5.0){
        graph->GetPoint(9, xVal, yVal);

        yVal++;

        graph->SetPoint(9, xVal, yVal);

    }

}

void fillThresholdgraphFrom0To1(TGraph* graph, const Float_t eventEnergy){
    Double_t yVal = 0;

    Double_t xVal = 0;

    if(eventEnergy < 0.1){
        graph->GetPoint(0, xVal, yVal);

        yVal++;

        graph->SetPoint(0, xVal, yVal);

    }
    if(eventEnergy < 0.2){
        graph->GetPoint(1, xVal, yVal);

        yVal++;

        graph->SetPoint(1, xVal, yVal);
        
    }
    if(eventEnergy < 0.3){
        graph->GetPoint(2, xVal, yVal);

        yVal++;

        graph->SetPoint(2, xVal, yVal);
        
    }
    if(eventEnergy < 0.4){
        graph->GetPoint(3, xVal, yVal);

        yVal++;

        graph->SetPoint(3, xVal, yVal);
        
    }
    if(eventEnergy < 0.5){
        graph->GetPoint(4, xVal, yVal);

        yVal++;

        graph->SetPoint(4, xVal, yVal);
        
    }
    if(eventEnergy < 0.6){
        graph->GetPoint(5, xVal, yVal);

        yVal++;

        graph->SetPoint(5, xVal, yVal);
        
    }
    if(eventEnergy < 0.7){
        graph->GetPoint(6, xVal, yVal);

        yVal++;

        graph->SetPoint(6, xVal, yVal);
        
    }
    if(eventEnergy < 0.8){
        graph->GetPoint(7, xVal, yVal);

        yVal++;

        graph->SetPoint(7, xVal, yVal);
    
    }
    if(eventEnergy < 0.9){
        graph->GetPoint(8, xVal, yVal);

        yVal++;

        graph->SetPoint(8, xVal, yVal);

    }
    if(eventEnergy < 1.0){
        graph->GetPoint(9, xVal, yVal);

        yVal++;

        graph->SetPoint(9, xVal, yVal);

    }
}
void fillThresholdgraphFrom0To1dot5(TGraph* graph, const Float_t eventEnergy){
    Double_t yVal = 0;

    Double_t xVal = 0;

    if(eventEnergy < 0.1){
        graph->GetPoint(0, xVal, yVal);

        yVal++;

        graph->SetPoint(0, xVal, yVal);

    }
    if(eventEnergy < 0.2){
        graph->GetPoint(1, xVal, yVal);

        yVal++;

        graph->SetPoint(1, xVal, yVal);
        
    }
    if(eventEnergy < 0.3){
        graph->GetPoint(2, xVal, yVal);

        yVal++;

        graph->SetPoint(2, xVal, yVal);
        
    }
    if(eventEnergy < 0.4){
        graph->GetPoint(3, xVal, yVal);

        yVal++;

        graph->SetPoint(3, xVal, yVal);
        
    }
    if(eventEnergy < 0.5){
        graph->GetPoint(4, xVal, yVal);

        yVal++;

        graph->SetPoint(4, xVal, yVal);
        
    }
    if(eventEnergy < 0.6){
        graph->GetPoint(5, xVal, yVal);

        yVal++;

        graph->SetPoint(5, xVal, yVal);
        
    }
    if(eventEnergy < 0.7){
        graph->GetPoint(6, xVal, yVal);

        yVal++;

        graph->SetPoint(6, xVal, yVal);
        
    }
    if(eventEnergy < 0.8){
        graph->GetPoint(7, xVal, yVal);

        yVal++;

        graph->SetPoint(7, xVal, yVal);
    
    }
    if(eventEnergy < 0.9){
        graph->GetPoint(8, xVal, yVal);

        yVal++;

        graph->SetPoint(8, xVal, yVal);

    }
    if(eventEnergy < 1.0){
        graph->GetPoint(9, xVal, yVal);

        yVal++;

        graph->SetPoint(9, xVal, yVal);

    }
    if(eventEnergy < 1.1){
        graph->GetPoint(10, xVal, yVal);

        yVal++;

        graph->SetPoint(10, xVal, yVal);

    }
    if(eventEnergy < 1.2){
        graph->GetPoint(11, xVal, yVal);

        yVal++;

        graph->SetPoint(11, xVal, yVal);

    }
    if(eventEnergy < 1.3){
        graph->GetPoint(12, xVal, yVal);

        yVal++;

        graph->SetPoint(12, xVal, yVal);
}
    if(eventEnergy < 1.4){
        graph->GetPoint(13, xVal, yVal);

        yVal++;

        graph->SetPoint(13, xVal, yVal);

    }
    if(eventEnergy < 1.5){
        graph->GetPoint(14, xVal, yVal);

        yVal++;

        graph->SetPoint(14, xVal, yVal);

    }
}