#include <iostream>
#include <thread>
#include <sstream>
#include <random>

#include "TCanvas.h"
#include "TPad.h"
#include "TFrame.h"
#include "TGraph.h"
#include "TH1.h"
#include "TThread.h"

void DoStuff(size_t);

const size_t dim1 = 500;
const size_t dim2 = 1000;

const size_t total = dim1 * dim2;

const size_t nThreads = 10;

double **x, * *y, * *z;

int main()
{
   TH1::AddDirectory(kFALSE);
   //Fill some arrays with random numbers
   std::default_random_engine Generator;
   std::normal_distribution<double> NormalDistribution(0.5, 0.1);

   x = new double*[dim1];
   y = new double*[dim1];
   z = new double*[dim1];

   for (size_t k = 0; k < dim1; k++) {
      x[k] = new double[dim2];
      y[k] = new double[dim2];
      z[k] = new double[dim2];
   }

   for (size_t k = 0; k < dim1; k++) {

      for (size_t l = 0; l < dim2; l++) {
         x[k][l] = NormalDistribution(Generator);
         y[k][l] = NormalDistribution(Generator);
         z[k][l] = NormalDistribution(Generator);
      }
   }

   //make some threads and plot the data in the above arrays.
   TThread::Initialize();
   size_t RunThreads = nThreads;
   std::thread Threads[nThreads];

   for (size_t m = 0; m < dim1; m += nThreads) {
      if ((dim1 - m) < nThreads) {
         RunThreads = dim1 - m;
      }

      for (size_t k = 0; k < RunThreads; k++) {
         Threads[k] = std::thread(DoStuff, k + m);
      }

      for (size_t k = 0; k < RunThreads; k++) {
         Threads[k].join();
      }
   }

   for (size_t k = 0; k < dim1; k++) {
      delete x[k];
      delete y[k];
      delete z[k];
   }
   delete[] x;
   delete[] y;
   delete[] z;

   return 0;
}


void DoStuff(size_t n)
{
   TThread thr(n); // Not needed starting from ROOT 6.07

   const unsigned int xres = 1024;
   const unsigned int yres = 768;
   const double xMaximum = 1;
   const double yMaximum = 1;

   std::stringstream Pad1Name;
   std::stringstream cvname;
   std::stringstream OutputFileName;
   cvname << "canvas_" << n;
   Pad1Name << "pad1_" << n;
   OutputFileName << n << ".png";

//With no lock the following will crash
   TCanvas *cv;
   TPad *Pad1;
   TH1F *Frame1;
   {
      R__LOCKGUARD(gInterpreterMutex);
      cv = new TCanvas(cvname.str().c_str(), "A random title", 0, 0, xres, yres);
      cv->cd();
      Pad1 = new TPad(Pad1Name.str().c_str(), "A random title", 0, 0, 1, 1);
      Pad1->Draw();
      Pad1->cd();
      Frame1 = Pad1->DrawFrame(0, 0, xMaximum, yMaximum);
   }
   Frame1->GetXaxis()->SetLabelOffset(0.035);
   Frame1->GetXaxis()->SetTitleOffset(1.5);
   Frame1->SetXTitle("x");
   Frame1->SetYTitle("y");
   Frame1->Draw("AXIS");
   Pad1->cd();
   TGraph *xy = new TGraph(dim2, x[n], y[n]);
   xy->SetMarkerColor(kRed);
   xy->SetMarkerStyle(2);


   TGraph *xz = new TGraph(dim2, x[n], z[n]);
   xz->SetMarkerColor(kGreen);
   xz->SetMarkerStyle(2);


   {
      R__LOCKGUARD(gInterpreterMutex);
      xy->Draw("P");
      xz->Draw("P");
      cv->Print(OutputFileName.str().c_str(), "png");
      delete Pad1;
      delete xy;
      delete xz;
      delete cv;
   }


}

void Threads_fineGrained()
{
   main();
}