// **************************************************************************
// This file is property of and copyright by the ALICE HLT Project          *
// ALICE Experiment at CERN, All rights reserved.                           *
//                                                                          *
// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
//                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
//                  for The ALICE HLT Project.                              *
//                                                                          *
// Developed by:   Igor Kulakov <I.Kulakov@gsi.de>                          *
//                 Maksym Zyzak <M.Zyzak@gsi.de>                            *
//                                                                          *
// Permission to use, copy, modify and distribute this software and its     *
// documentation strictly for non-commercial purposes is hereby granted     *
// without fee, provided that the above copyright notice appears in all     *
// copies and that both the copyright notice and this permission notice     *
// appear in the supporting documentation. The authors make no claims       *
// about the suitability of this software for any purpose. It is            *
// provided "as is" without express or implied warranty.                    *
//                                                                          *
//***************************************************************************

#include <AliHLTTPCCAGBTracker.h>
#include "KFParticleTopoReconstructor.h"

#include "KFParticle.h"
#include "KFParticleSIMD.h"
#include "KFPHistogram/KFPHistogram.h"

#ifdef MAIN_DRAW
#include "AliHLTTPCCADisplay.h"
#endif

#include <fstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstring>

using namespace std;

#ifndef NVALGRIND
#include <valgrind/callgrind.h>
#endif

#include <KFPInputData.h>

#ifndef HLTCA_STANDALONE
#include "TStopwatch.h"
typedef TStopwatch Stopwatch;
#else
#include "Stopwatch.h"
#endif

#include "pthread.h"
#include <errno.h>

static bool SAVE = false;
extern bool SINGLE_THREADED;
extern bool DRAW_EVERY_LINK;

static bool file_exists( const char *filename )
{
    FILE *f = 0;
    if ( ( f = std::fopen( filename, "r" ) ) != NULL ) {
        std::fclose( f );
        return true;
    }
    return false;
}

int main(int argc, char **argv)
{
  bool fullTiming = false;
  int firstEvent = 0;
  int lastEvent = 1000000;
  int nThreads = 1;
  int Step=1;
  int nRuns=1;
  int repetitions = 1;
  string filePrefix = "./Events/"; 
  for( int i=1; i < argc; i++ ){
    if ( !std::strcmp( argv[i], "-h" ) || !std::strcmp( argv[i], "--help" ) || !std::strcmp( argv[i], "-help" ) ) {
      std::cout << "Please look in readme.txt" << std::endl;
      return 0;
    } else if ( !std::strcmp( argv[i], "-time" ) ) {
      fullTiming = true;
    } else if ( !std::strcmp( argv[i], "-dir" ) && ++i < argc ) {
      filePrefix = argv[i];
    } else if ( !std::strcmp( argv[i], "-nThreads" ) && ++i < argc ) {
      nThreads = atoi( argv[i] );
    } else if ( !std::strcmp( argv[i], "-Step" ) && ++i < argc ) {
      Step = atoi( argv[i] );
    } else if ( !std::strcmp( argv[i], "-nRuns" ) && ++i < argc ) {
      nRuns = atoi( argv[i] );
    } else if ( !std::strcmp( argv[i], "-ev" ) && ++i < argc ) {
      firstEvent = atoi( argv[i] );
      if (++i < argc){
        lastEvent = atoi( argv[i] );
//        std::cout << "Only process events " << firstEvent << ",..," << lastEvent << std::endl;
      }
      else{
        lastEvent = firstEvent;
//        std::cout << "Only process event " << lastEvent << std::endl;
      }
    } else {
      firstEvent = atoi( argv[i] );
      lastEvent = firstEvent;
//      std::cout << "Only process event " << lastEvent << std::endl;
    }
  }

  const int NEventsPerThread = lastEvent - firstEvent + 1;
  fstream OutTime;
  OutTime.open( "outtime.dat", ios::out );

  KFPInputDataArray InputDataPerThread;
  {
    std::string LocalfilePrefix = filePrefix;
    LocalfilePrefix += "/";
    const int NEvLocal = NEventsPerThread;

    InputDataPerThread.fInput = new KFPInputData[NEvLocal];

    for ( int kEvents = firstEvent; kEvents <= lastEvent; kEvents++ ) {
      char buf[6];
      sprintf( buf, "%d", kEvents );
      const std::string fileName = LocalfilePrefix + "event" + std::string(buf) + "_KFPTracks.data";

      if (!InputDataPerThread.fInput[kEvents - firstEvent].ReadDataFromFile(fileName)) {
        cout << "Data for Event " << kEvents << " can't be read." << std::endl;
        break;
      }
    }
  }

  std::cout << nThreads << "  " << Step << "  " << 1/*nRuns*/ << "  " << NEventsPerThread << std::endl;
  std::cout << std::endl << std::endl;
  std::cout << " --- tbb  ---"<<std::endl;
  
#ifdef FORMIC
  int threadNumberToCpuMap[240];
  
  for (int i=1; i<240; i++){
    threadNumberToCpuMap[i-1] = i;
  }
  threadNumberToCpuMap[239] = 0;
  
//   threadNumberToCpuMap[0] = 1;
//   for(int iCo=1; iCo<60; iCo++)
//     threadNumberToCpuMap[iCo] = threadNumberToCpuMap[iCo-1] + 4;
  
//   threadNumberToCpuMap[0] = 1;
//   threadNumberToCpuMap[1] = 2;
//   for(int iCo=1; iCo<60; iCo++)
//   {
//     threadNumberToCpuMap[2*iCo] = threadNumberToCpuMap[2*iCo-2] + 4;
//     threadNumberToCpuMap[2*iCo+1] = threadNumberToCpuMap[2*iCo] + 1;
//   }

//   threadNumberToCpuMap[0] = 1;
//   threadNumberToCpuMap[1] = 2;
//   threadNumberToCpuMap[2] = 3;
//   for(int iCo=1; iCo<60; iCo++)
//   {
//     threadNumberToCpuMap[3*iCo] = threadNumberToCpuMap[3*iCo-3] + 4;
//     threadNumberToCpuMap[3*iCo+1] = threadNumberToCpuMap[3*iCo] + 1;
//     threadNumberToCpuMap[3*iCo+2] = threadNumberToCpuMap[3*iCo] + 2;
//   }
  
//   threadNumberToCpuMap[0] = 1;
//   for(int iCo=1; iCo<60; iCo++)
//     threadNumberToCpuMap[iCo] = threadNumberToCpuMap[iCo-1] + 4;
//   for(int iCo=60; iCo<120; iCo++)
//     threadNumberToCpuMap[iCo] = threadNumberToCpuMap[iCo-60] + 1;
//   for(int iCo=120; iCo<180; iCo++)
//     threadNumberToCpuMap[iCo] = threadNumberToCpuMap[iCo-60] + 1;
//   for(int iCo=180; iCo<240; iCo++)
//     threadNumberToCpuMap[iCo] = threadNumberToCpuMap[iCo-60] + 1;  
//   threadNumberToCpuMap[239] = 0;
  
#else
//   int threadNumberToCpuMap[32];
//   for (int i=0; i<16; i++){
//     threadNumberToCpuMap[2*i+0] = i;
//     threadNumberToCpuMap[2*i+1] = i+16;
//   }
  
  int threadNumberToCpuMap[40];
  for (int i=0; i<20; i++){
    threadNumberToCpuMap[2*i+0] = i;
    threadNumberToCpuMap[2*i+1] = i+20;
  }

#endif
    
  #define handle_error_en(en, msg) do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)
  AliHLTTPCCAGBTracker Tracker;

#if 0
  {
    int iThreads = nThreads;
    KFPInputDataArray *InputDataParallel = new KFPInputDataArray[iThreads];

    #pragma omp parallel for num_threads(iThreads)
    for(int i = 0; i < iThreads; ++i){
      int s;
      cpu_set_t cpuset;
      int cpuId = threadNumberToCpuMap[i];
      pthread_t thread  = pthread_self();
      CPU_ZERO(&cpuset);
      CPU_SET(cpuId, &cpuset);
      s = pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
      if (s != 0){ cout << " pthread_setaffinity_np " << endl; handle_error_en(s, "pthread_setaffinity_np");}

      InputDataParallel[i].fInput = new KFPInputData[NEventsPerThread];
      for ( int iE = firstEvent; iE <= lastEvent; iE++ ) {
        InputDataParallel[i].fInput[iE] = InputDataPerThread.fInput[iE];
      }
    }

    #pragma omp parallel for num_threads(iThreads)
    for(int i = 0; i < iThreads; ++i){
      for ( int iE = firstEvent; iE <= lastEvent; iE++ ) {
        KFParticleTopoReconstructor topoReconstructor; // TODO don't recreate with each event
        topoReconstructor.Init(&InputDataParallel[i].fInput[iE].GetTracks(),
                               InputDataParallel[i].fInput[iE].GetPV(),
                               InputDataParallel[i].fInput[iE].GetCluster(),
                               InputDataParallel[i].fInput[iE].GetPDG(),
                               InputDataParallel[i].fInput[iE].GetBz()
                              );

        topoReconstructor.SetNThreads(1);
        topoReconstructor.ReconstructParticles();
        topoReconstructor.DeInit();
      }
    }
  }
#endif

  KFPInputDataArray *InputDataParallel = new KFPInputDataArray[nThreads];
  Stopwatch timer;

  #pragma omp parallel for num_threads(nThreads)
  for(int i = 0; i < nThreads; ++i){
    int s;
    cpu_set_t cpuset;
    int cpuId = threadNumberToCpuMap[i];
    pthread_t thread  = pthread_self();
    CPU_ZERO(&cpuset);
    CPU_SET(cpuId, &cpuset);
    s = pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
    if (s != 0){ cout << " pthread_setaffinity_np " << endl; handle_error_en(s, "pthread_setaffinity_np");}

    InputDataParallel[i].fInput = new KFPInputData[NEventsPerThread];
    for ( int iE = 0; iE < NEventsPerThread; iE++ ) {
      InputDataParallel[i].fInput[iE] = InputDataPerThread.fInput[iE];
    }
  }
  
  KFParticle::SetField( InputDataParallel[0].fInput[0].GetBz() ); // to understand -1 see SetField
  KFParticleSIMD::SetField( InputDataParallel[0].fInput[0].GetBz() ); // to understand -1 see SetField
  
  for(int iThreads=Step; iThreads <= nThreads; iThreads+=Step)
  {
    Stopwatch timerLocal;
    vector<double> fitSpeedCPU(iThreads);
    vector<double> fitSpeedReal(iThreads);
  
    {
      timer.Start();
      for(int iTimes = 0; iTimes<nRuns; iTimes++)
      {
        #pragma omp parallel for num_threads(iThreads) firstprivate(timerLocal)
        for(int i = 0; i < iThreads; ++i)
        {
          KFPHistogram histograms;
          string histoFileName = "KFPHistogram";
          histoFileName += std::to_string(i);
          histoFileName += ".txt";
          histograms.SetOutFileName(histoFileName);
          timerLocal.Start();
          
          int s;
          cpu_set_t cpuset;
          int cpuId = threadNumberToCpuMap[i];
          pthread_t thread  = pthread_self();
          CPU_ZERO(&cpuset);
          CPU_SET(cpuId, &cpuset);
          s = pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
          if (s != 0){ cout << " pthread_setaffinity_np " << endl; handle_error_en(s, "pthread_setaffinity_np");}

          for ( int iE = 0; iE < NEventsPerThread; iE++ ) {
            KFParticleTopoReconstructor topoReconstructor; // TODO don't recreate with each event
            topoReconstructor.Init(InputDataParallel[i].fInput[iE].GetTracks(),
                                   InputDataParallel[i].fInput[iE].GetPV()
                                  );

            topoReconstructor.SetNThreads(1);
  
            topoReconstructor.ReconstructParticles();
            histograms.Fill(topoReconstructor);
            topoReconstructor.DeInit();
            
          }
          
          timerLocal.Stop();
          double cpuTimeLocal = timerLocal.CpuTime();
          double realTimeLocal = timerLocal.RealTime();
          
          fitSpeedCPU[i] = (lastEvent-firstEvent+1)/cpuTimeLocal;
          fitSpeedReal[i] = (lastEvent-firstEvent+1)/realTimeLocal;
          
          histograms.Save();
        }
      }
      timer.Stop();
    }
    
    double realSpeedTotal = 0.;
    double cpuSpeedTotal = 0.;
  
    for(int iT=0; iT<iThreads; iT++)
    {
      realSpeedTotal += fitSpeedReal[iT];
      cpuSpeedTotal += fitSpeedCPU[iT];
    }
  
    double rtime = 1./realSpeedTotal;//timer.RealTime();
    double ctime = 1./cpuSpeedTotal;//timer.CpuTime();
    cout << iThreads << ":" << endl;
    cout << " Estimated CATime = " << timer.RealTime()/nRuns << " Estimated CATime/nEvents = " << (rtime/nRuns) << endl;
  }
  if(InputDataParallel) delete [] InputDataParallel;

  OutTime.close();
std::cout << "Size  " << float_v::Size << std::endl;
  return 0;
}