// ROC efficiency differences compared to the mean of  the containing
//    - module       -o                                                                     |
//    - sector         \                                                                    |
//    - side            o---- Barrel                                                        |
//    - halfshell      /                                                                    |
//    - quarter      -o                                                                     |


// Filtering helper, creates predicates about the placements of the ROCs
std::mutex stupidLock;
auto transformToROCPredicate = [&layersROCIndexToPlacementMaps, layerIndex, &stupidLock] (const std::function<bool(const ROCPlacement&)>& pred)
{
   return [&layersROCIndexToPlacementMaps, layerIndex, &pred, &stupidLock] (auto e)
   {
      int otherROCIndex;
      const char* histogramName = e -> GetName();
      {
         std::lock_guard<std::mutex> stupidLockGuard(stupidLock);
         otherROCIndex = getROCIndexByName(histogramName);
      }
      ROCPlacement otherROCPlacement = layersROCIndexToPlacementMaps[layerIndex][otherROCIndex];
      return pred(otherROCPlacement);
   };
};
// Comparison helper
std::mutex writeLock;
auto writeComparisonPlots = [&, layerIndex]
   (const std::string& histogramName, const std::string& histogramTitle, std::initializer_list<const char*> directoryPath, const std::function<bool(const ROCPlacement&)>& pred)
{
   assert(directoryPath.size());
   std::vector<TH1F*> passedROCFiltering = filter(efficiencyVsDelayHistogramsToFit[layerIndex], transformToROCPredicate(pred));
   TH1F* rocEfficiencyDifferencesModuleAvg = getROCefficiencyDifferencesPlot(rocEfficiencyHistogram, passedROCFiltering, histogramName.c_str(), histogramTitle.c_str());
   std::lock_guard<std::mutex> writeLockGuard(writeLock);
   outputFile -> cd(*directoryPath.begin());
   std::for_each(directoryPath.begin() + 1, directoryPath.end(), [] (const char* e)
   {
      gDirectory -> cd(e);
   });
   rocEfficiencyDifferencesModuleAvg -> Write();
};
// Module
auto sameModule = [module, ladder] (const ROCPlacement& rp) { return rp.module == module && rp.ladder == ladder; };
std::future<void> moduleComparisonThread = std::async(std::launch::async, [&] { writeComparisonPlots("ROC:" + std::to_string(rocIndex) + "_module_comparison", "ROC: " + std::to_string(rocIndex) + " - module comparison",
{
   "ROC_efficiency_module_level_comparison", layerDirName, moduleLadderDirname
}, sameModule); });
// Sector
auto sameSector = [side, module, sec] (const ROCPlacement& rp) { return rp.side == side && std::signbit(rp.module) == std::signbit(module) && rp.sec == sec; };
std::future<void> sectorComparisonThread = std::async(std::launch::async, [&] { writeComparisonPlots("ROC:" + std::to_string(rocIndex) + "_sector_comparison", "ROC: " + std::to_string(rocIndex) + " - sector comparison",
{
   "ROC_efficiency_sector_level_comparison", layerDirName, sideDirName, halfshellDirName, sectorDirName
}, sameSector); });
// Side
auto sameSide = [side] (const ROCPlacement& rp) { return rp.side == side; };
std::future<void> sideComparisonThread = std::async(std::launch::async, [&] { writeComparisonPlots("ROC:" + std::to_string(rocIndex) + "_side_comparison", "ROC: " + std::to_string(rocIndex) + " - side comparison",
{
   "ROC_efficiency_side_level_comparison", layerDirName, sideDirName
}, sameSide); });
// Halfshell
auto sameHalfshell = [module] (const ROCPlacement& rp) { return std::signbit(rp.module) == std::signbit(module); };
std::future<void> halfshellComparisonThread = std::async(std::launch::async, [&] { writeComparisonPlots("ROC:" + std::to_string(rocIndex) + "_halfshell_comparison", "ROC: " + std::to_string(rocIndex) + " - halfshell comparison",
{
   "ROC_efficiency_halfshell_level_comparison", layerDirName, halfshellDirName
}, sameHalfshell); });
// Quarter
auto sameQuarter = [side, module] (const ROCPlacement& rp) { return rp.side == side && std::signbit(rp.module) == std::signbit(module); };
// The last thread should be run synchronously
std::async(std::launch::async, [&] { writeComparisonPlots("ROC:" + std::to_string(rocIndex) + "_quarter_comparison", "ROC: " + std::to_string(rocIndex) + " - quarter comparison",
{
   "ROC_efficiency_quarter_level_comparison", layerDirName, sideDirName, halfshellDirName
}, sameQuarter); });
moduleComparisonThread.get();
sectorComparisonThread.get();
sideComparisonThread.get();
halfshellComparisonThread.get();