#include <vector>

void constHisto(std::vector<double> &times, std::vector<double> &means, TH1F* hist, std::vector<double> &binEdges) {
    

    // Initialize vectors to store bin contents and counts
    std::vector<double> binContents(binEdges.size() - 1, 0.0);
    std::vector<int> binCounts(binEdges.size() - 1, 0);

    // Loop through data and fill the histogram
    for (size_t i = 0; i < times.size(); ++i) {
        double val = means[i];
        for (size_t j = 0; j < binEdges.size() - 1; ++j) {
            if (times[i] >= binEdges[j] && times[i] < binEdges[j + 1]) {
                binContents[j] += val;
                binCounts[j]++;
                break;
            }
        }
    }

    // Calculate the means for each bin and set the bin content
    for (size_t i = 0; i < binEdges.size() - 1; ++i) {
        double binMean = (binCounts[i] > 0) ? binContents[i] / binCounts[i] : 0;
        hist->SetBinContent(i + 1, binMean); // Set the bin content to the mean
    }
}

void QueueOccup() {
    // Define your bin edges
    gROOT->SetBatch(kTRUE);

    std::vector<double> binEdges;
    for (int i = 0; i <= 30; i++) {
        binEdges.push_back(i);
        if (i>=6) binEdges.push_back(i + 0.5);
    }

    //gROOT->SetBatch(kTRUE);
    auto f100 = "./queue_occup_1kmean_20ms_timeout50ms_100clients.csv";
    auto f100_df = ROOT::RDF::MakeCsvDataFrame(f100, true, ';');

    auto f200 = "./queue_occup_1kmean_20ms_timeout50ms_200clients.csv";
    auto f200_df = ROOT::RDF::MakeCsvDataFrame(f200, true, ';');

    auto f500 = "./queue_occup_1kmean_20ms_timeout50ms_500clients.csv";
    auto f500_df = ROOT::RDF::MakeCsvDataFrame(f500, true, ';');

    auto f1000 = "./queue_occup_1kmean_20ms_timeout50ms_1000clients.csv";
    auto f1000_df = ROOT::RDF::MakeCsvDataFrame(f1000, true, ';');

    //gStyle->SetOptTitle(kFALSE);
    gStyle->SetOptStat(0);


    auto canvas = new TCanvas("c", "c", 1400, 1000);
    //canvas->SetLogx();
    canvas->SetGrid();
    canvas->SetLogy();


    //filteredEvents.Histo1D({"invMass", "CMS Opendata: #mu#mu mass;#mu#mu mass [GeV];Events", 512, 2, 110}, "m");
    auto timesResult100 = f100_df.Take<double>("times");
    auto meansResult100 = f100_df.Take<double>("means");

    std::vector<double> times100 = timesResult100.GetValue();
    std::vector<double> means100 = meansResult100.GetValue();

    // Create a histogram with custom binning
    TH1F *h100 = new TH1F("h100","Custom Histogram", binEdges.size() - 1, &binEdges[0]);
    constHisto(times100, means100, h100, binEdges);

    h100->SetLineWidth(3);


    //filteredEvents.Histo1D({"invMass", "CMS Opendata: #mu#mu mass;#mu#mu mass [GeV];Events", 512, 2, 110}, "m");
    auto timesResult200 = f200_df.Take<double>("times");
    auto meansResult200 = f200_df.Take<double>("means");

    std::vector<double> times200 = timesResult200.GetValue();
    std::vector<double> means200 = meansResult200.GetValue();

    // Create a histogram with custom binning
    TH1F *h200 = new TH1F("h200","Custom Histogram", binEdges.size() - 1, &binEdges[0]);
    constHisto(times200, means200, h200, binEdges);

    h200->SetLineWidth(3);


    //filteredEvents.Histo1D({"invMass", "CMS Opendata: #mu#mu mass;#mu#mu mass [GeV];Events", 512, 2, 110}, "m");
    auto timesResult500 = f500_df.Take<double>("times");
    auto meansResult500 = f500_df.Take<double>("means");

    std::vector<double> times500 = timesResult500.GetValue();
    std::vector<double> means500 = meansResult500.GetValue();

    // Create a histogram with custom binning
    TH1F *h500 = new TH1F("h500", "", binEdges.size() - 1, &binEdges[0]);
    constHisto(times500, means500, h500, binEdges);

    h500->SetLineWidth(3);
    
    //filteredEvents.Histo1D({"invMass", "CMS Opendata: #mu#mu mass;#mu#mu mass [GeV];Events", 512, 2, 110}, "m");
    auto timesResult1000 = f1000_df.Take<double>("times");
    auto meansResult1000 = f1000_df.Take<double>("means");

    std::vector<double> times1000 = timesResult1000.GetValue();
    std::vector<double> means1000 = meansResult1000.GetValue();

    // Create a histogram with custom binning
    TH1F *h1000 = new TH1F("h1000", "Custom Histogram", binEdges.size() - 1, &binEdges[0]);
    constHisto(times1000, means1000, h1000, binEdges);

    h1000->SetLineWidth(3);
    h1000->GetYaxis()->SetRangeUser(2., 150000.);
    h1000->GetXaxis()->SetRangeUser(5., 30.);

    gStyle->SetPalette(1);

    h1000->SetTitle("Queue occupancy over time; Time [s];Queue Size [elements];");

    h1000->Draw("plc");
    h500->Draw("same plc");
    h200->Draw("same plc");
    h100->Draw("same plc");


    //gStyle->SetLegendTextSize(0.01);

    auto leg = new TLegend(0.64,0.62,0.9,0.77);
    leg->SetHeader("Num Clients", "c");
    leg->AddEntry("h100","100 Clients","lp");
    leg->AddEntry("h200","200 Clients","lp");
    leg->AddEntry("h500","500 Clients","lp");
    leg->AddEntry("h1000","1000 Clients","lp");
    leg->Draw();

    //canvas->BuildLegend(0.65,0.2,0.86,0.32, "Connection Method");

    canvas->Print("MeanQueueOccupation.png");

    gROOT->SetBatch(kFALSE);
    gApplication->Terminate(0);
}