// **************************************************************************
// This file is property of and copyright by the CBM   HLT Project          *
// CBM Experiment at FAIR, All rights reserved.                             *
//                                                                          *
//                                                                          *
// Primary Authors: Igor Kulakov <I.Kulakov@gsi.de>                         *
//                  Maksym Zyzak <M.Zyzak@gsi.de>                           *
//                  Ivan Kisel <kisel@kip.uni-heidelberg.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 <iostream>
#include <iomanip>
#include <cstdio>
#include <cstring>

using namespace std;

//#include "L1AlgoInter.h"
#include "Performance.h"

#include "multithread.h"
#include "parallel_for_simpleEqNThr.h"
#include "TStopwatch.h"

static void usage(const char *execName)
{
  std::cout << "Usage: " << execName << " [OPTION] [event number]\n"
     "Reconstruct slice tracks and merge them from cluster data read from the Events directory.\n\n"
     "  -h, --help print this message\n"
            << endl;
}

int main(int argc, char **argv)
{
  int iVerbose = 0;
  int firstEvent = 0;
  int lastEvent = 0;
  int nThreads = 1;
  int Step=1;
  int nRuns=1;
  int iSocket = 0;
  int StartTime = -1;
  bool fullTiming = 0;
  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" ) ) {
      usage(argv[0]);
      return 0;
    } else if ( !std::strcmp( argv[i], "-perf" ) ) {
      iVerbose=1;
    } else if ( !std::strcmp( argv[i], "-VerboseLevel" ) && ++i < argc ) {
      iVerbose = atoi( argv[i] );
    }
    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], "-iSocket" ) && ++i < argc ) {
      iSocket = atoi( argv[i] );
    } else if ( !std::strcmp( argv[i], "-StartTime" ) && ++i < argc ) {
      StartTime = 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;

  InputDataArray InputDataPerThread;
  InputMCDataArray InputMCDataPerThread;
    {
    std::string LocalfilePrefix = filePrefix;
    LocalfilePrefix += "/";
    const int NEventsToRead = lastEvent+1;

    InputDataPerThread.fInput = new L1AlgoInputData[NEventsToRead];
    InputDataPerThread.fSettings = new L1AlgoInputSettings;
    InputMCDataPerThread.fMCInput = new L1AlgoInputMCData[NEventsToRead];

    if(!InputDataPerThread.fSettings->ReadSettingsFromFile(LocalfilePrefix.data(), iVerbose)) {
      std::cout << "Setting can not be read" << std::endl;
    }

    for ( int kEvents = 0; kEvents <= lastEvent; kEvents++ ) {

      if (!InputDataPerThread.fInput[kEvents].ReadHitsFromFile(LocalfilePrefix.data(), NEventsToRead, iVerbose)) {
        cout << "Hits Data for Event " << kEvents << " can't be read." << std::endl;
        break;
      }

      if(iVerbose>0) {
        if (!InputMCDataPerThread.fMCInput[kEvents].ReadMCDataFromFile(LocalfilePrefix.data(), NEventsToRead, iVerbose)) {
          cout << "MC Data for Event " << kEvents << " can't be read." << std::endl;
          break;
        }
      }
    }
  }


//  L1AlgoInter* algoInter = new L1AlgoInter();
//  algoInter->Init(filePrefix.data(), iVerbose, nThreads, NEventsPerThread);

//  std::cout << nThreads << "  " << Step << "  " << 1/*nRuns*/ << "  " << NEventsPerThread << std::endl;
//  std::cout << std::endl << std::endl;
//  std::cout << " --- tbb  ---"<<std::endl;

  //algoInter->RunEv();

//  if( iVerbose >= 1 ) perf->Init(filePrefix.data(), algoInter);
//  if( iVerbose >= 1 ) perf->RunEv();

  const int NSockets = 4;
  const int NCoresPerSocket = 20;
  int mThreadNumberToCpuMap[NSockets][NCoresPerSocket];

  for(int iProc=0; iProc<NSockets; iProc++)
  {
    for(int i=0; i<8; i++){ 
      mThreadNumberToCpuMap[iProc][2*i+0 ] = NSockets*i + iProc; 
      mThreadNumberToCpuMap[iProc][2*i+1 ] = NSockets*i + 32 + iProc;
    }
    for(int i=0; i<2; i++){
      mThreadNumberToCpuMap[iProc][2*i+0 + 16] = NSockets*i + iProc + 64; 
      mThreadNumberToCpuMap[iProc][2*i+1 + 16] = NSockets*i + 8 + iProc + 64;
    }
  }

//   for(int iProc=0; iProc<NSockets; iProc++)
//   {
//     std::cout << iProc <<":  ";
//     for(int i=0; i<NCoresPerSocket; i++) std::cout << mThreadNumberToCpuMap[iProc][i] <<" ";
//     std::cout << std::endl;
//   }

  for(int iThreads=Step; iThreads <= nThreads; iThreads+=Step)
  {
    InputDataArray *InputDataParallel = new InputDataArray[iThreads];

    task_scheduler_init init(iThreads);
//     TMyObserver obs;
//     obs.FInit();    // set cpu-threads correspondence
//     obs.observe(0); // Turn on observer. It's turn off by default.
    TStopwatch timer;

    parallel_for_simpleEqNThr(1,iThreads,ApplyMem(InputDataPerThread,InputDataParallel,NEventsPerThread,mThreadNumberToCpuMap[iSocket]));

    if(StartTime>-1)
      while(time(NULL) < StartTime) {}

    if(iVerbose == 0)
    {
      timer.Start();
      for(int iTimes = 0; iTimes<nRuns; iTimes++)
      {
//        obs.InitThreadsCounter();
        parallel_for_simpleEqNThr(1,iThreads,ApplyReco(InputDataParallel, NEventsPerThread,mThreadNumberToCpuMap[iSocket]));
      }
      timer.Stop();
    }
//     else // Performance TODO
//     {
//       Performance *Perf = new Performance[iThreads];
//       InputMCDataArray *InputMCDataParallel = new InputMCDataArray[iThreads];
//       parallel_for_simpleEqNThr(1,iThreads,ApplyMemMCData(InputMCDataPerThread,InputMCDataParallel, Perf, NEventsPerThread));

//       timer.Start();
//       for(int iTimes = 0; iTimes<nRuns; iTimes++)
//       {
// //        obs.InitThreadsCounter();
//         parallel_for_simpleEqNThr(1,iThreads,ApplyRecoWithPerf(InputDataParallel, InputMCDataParallel, Perf, NEventsPerThread, iVerbose));
//       }
//       timer.Stop();

//       for(int iTh=0; iTh<iThreads; iTh++)
//       {
//         cout << endl;
//         cout << "L1 ACCUMULATED STAT    : " << Perf[iTh].L1_NEVENTS << " EVENTS "               << endl << endl;
//         Perf[iTh].L1_NTRA.PrintEff();
//         cout << "MC tracks/event found  : " <<
//           int(double(Perf[iTh].L1_NTRA.reco.counters[Perf[iTh].L1_NTRA.indices["total"]])/double(Perf[iTh].L1_NEVENTS)) << endl;
//         cout<<endl;
//         cout<<"CA Track Finder: " << Perf[iTh].L1_CATIME/Perf[iTh].L1_NEVENTS << " s/ev" << endl << endl;
//       }

//       if(InputMCDataParallel) delete [] InputMCDataParallel;
//       if(Perf) delete [] Perf;
//     }

    double rtime = timer.RealTime();
//    double ctime = timer.CpuTime();
//    cout << iThreads << ":" << endl;
    cout << " Estimated CATime = " << rtime/nRuns << " Estimated CATime/nEvents = " << (rtime/iThreads/nRuns/NEventsPerThread) << endl;

    if(InputDataParallel) delete [] InputDataParallel;
  }

  return 0;
}