//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
// G4TScoreNtupleWriter inline methods
//
// Author: Ivana Hrivnacova, 30/10/2018
// --------------------------------------------------------------------

#include "G4TScoreNtupleWriterMessenger.hh"
#include "G4THitsMap.hh"
#include "G4Threading.hh"

//_____________________________________________________________________________
//
// ctor, dtor
//

//_____________________________________________________________________________
template <typename T>
G4TScoreNtupleWriter<T>::G4TScoreNtupleWriter()
  : G4VScoreNtupleWriter()
  , fMessenger(nullptr)
  , fHCIds()
  , fAnalysisManager(nullptr)
  , fDefaultFileType("root")
  , fFileName("scoring")
  , fVerboseLevel(1)
  , fMergeNtuples(false)
  , fHasAnalysisFile(false)
  , fIsBooked(false)
  , fIsInitialized(false)
  , fFirstNtupleId(0)
{
  if(G4Threading::IsMasterThread())
  {
    fMessenger = new G4TScoreNtupleWriterMessenger<T>(this);
  }
}

//_____________________________________________________________________________
template <typename T>
G4TScoreNtupleWriter<T>::~G4TScoreNtupleWriter()
{
  delete fMessenger;
}

//
// private methods
//

//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::CreateAnalysisManager()
{
  if(fAnalysisManager) {
    return;
  }

  // create/get analysis manager
  fAnalysisManager = T::Instance();

  fAnalysisManager->SetDefaultFileType(fDefaultFileType);
  fAnalysisManager->SetVerboseLevel(fVerboseLevel);
  fAnalysisManager->SetNtupleMerging(fMergeNtuples);
}

//
// protected methods
//

//_____________________________________________________________________________
template <typename T>
G4VScoreNtupleWriter* G4TScoreNtupleWriter<T>::CreateInstance() const
{
  auto instance = new G4TScoreNtupleWriter();
  instance->SetFileName(fFileName);
  instance->SetVerboseLevel(fVerboseLevel);
  instance->SetNtupleMerging(fMergeNtuples);
  instance->fHasAnalysisFile = fHasAnalysisFile;

  return instance;
}

//
// public methods
//

//_____________________________________________________________________________
template <typename T>
G4bool G4TScoreNtupleWriter<T>::Book(G4HCofThisEvent* hce)
{
#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- G4TScoreNtupleWriter<T>::Book" << G4endl;
  }
#endif
  if(!hce)
    return false;

  // book collection ID if DoubleHitsMap
  if(fHCIds.size() == 0)
  {
#ifdef G4VERBOSE
    if(fVerboseLevel > 1)
    {
      G4cout << "--- going to fill fHCIds " << G4endl;
    }
#endif
    for(G4int i = 0; i < hce->GetNumberOfCollections(); ++i)
    {
      auto hitsMap = dynamic_cast<G4THitsMap<G4double>*>(hce->GetHC(i));

      if(hitsMap)
      {
#ifdef G4VERBOSE
        if(fVerboseLevel > 1)
        {
          G4cout << "--- adding hcID = " << i << G4endl;
        }
#endif
        fHCIds.push_back(i);
      }
    }
  }

  // Create analysis manager
  if(fHCIds.size())
  {
    CreateAnalysisManager();
  }

  // Create ntuples (only once)
  if(!fIsInitialized)
  {
#ifdef G4VERBOSE
    if(fVerboseLevel > 1)
    {
      G4cout << "-- going to create ntuples " << G4endl;
    }
#endif
    auto first = true;
    for(auto id : fHCIds)
    {
      auto hitsMap = static_cast<G4THitsMap<G4double>*>(hce->GetHC(id));

      // Create ntuple for this primitive
      G4String ntupleName(hitsMap->GetSDname());
      ntupleName.append("_");
      ntupleName.append(hitsMap->GetName());

      G4int ntupleId = fAnalysisManager->CreateNtuple(ntupleName, ntupleName);
      if(first)
      {
        fFirstNtupleId = ntupleId;
#ifdef G4VERBOSE
        if(fVerboseLevel > 1)
        {
          G4cout << "-- set first ntuple Id " << fFirstNtupleId << G4endl;
        }
#endif
        first = false;
      }

      G4String colName(ntupleName);
      colName.append("_eventId");
      fAnalysisManager->CreateNtupleIColumn(colName);
      colName = ntupleName;
      colName.append("_cell");
      fAnalysisManager->CreateNtupleIColumn(colName);
      colName = ntupleName;
      colName.append("_score");
      fAnalysisManager->CreateNtupleDColumn(colName);
      fAnalysisManager->FinishNtuple();
      fIsBooked = true;
    }
    fIsInitialized = true;
  }

  return fIsBooked;
}

//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::OpenFile()
{
#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- G4TScoreNtupleWriter<T>::OpenFile" << G4endl;
  }
#endif

  if(fAnalysisManager->IsOpenFile())
    return;

#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- G4TScoreNtupleWriter<T>::OpenFile executing" << G4endl;
  }
#endif

  if(fAnalysisManager->GetFileName() == "")
  {
    fAnalysisManager->SetFileName(fFileName);
  }
  fAnalysisManager->OpenFile();

#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- G4TScoreNtupleWriter<T>::OpenFile isOpenFile: "
           << fAnalysisManager->IsOpenFile() << G4endl;
  }
#endif

  fHasAnalysisFile = fHasAnalysisFile || fAnalysisManager->IsOpenFile();
    // Do not overwrite file ownership
    // if merging is activated and file is not open on workers
}

//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::Fill(G4HCofThisEvent* hce, G4int eventNumber)
{
#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- start G4TScoreNtupleWriter<T>::Fill" << G4endl;
  }
#endif

  auto counter = 0;
  for(auto id : fHCIds)
  {
#ifdef G4VERBOSE
    if(fVerboseLevel > 1)
    {
      G4cout << "in loop over fHCIds, counter " << counter << G4endl;
    }
#endif
    auto hitsMap = static_cast<G4THitsMap<G4double>*>(hce->GetHC(id));

    // G4cout << eventNumber << ".. go to fill ntuple " << counter +
    // fFirstNtupleId << G4endl;

    // fill hits in ntuple
    std::map<G4int, G4double*>::iterator it;
    for(it = hitsMap->GetMap()->begin(); it != hitsMap->GetMap()->end(); it++)
    {
      fAnalysisManager->FillNtupleIColumn(counter + fFirstNtupleId, 0,
                                          eventNumber);
      fAnalysisManager->FillNtupleIColumn(counter + fFirstNtupleId, 1,
                                          it->first);
      fAnalysisManager->FillNtupleDColumn(counter + fFirstNtupleId, 2,
                                          *(it->second));
      fAnalysisManager->AddNtupleRow(counter + fFirstNtupleId);
    }
    counter++;
  }

#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- done G4TScoreNtupleWriter<T>::Fill" << G4endl;
  }
#endif
}

//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::Write()
{
#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- start G4TScoreNtupleWriter<T>::Write" << G4endl;
  }
#endif

  if(fHasAnalysisFile)
  {
#ifdef G4VERBOSE
    if(fVerboseLevel > 1)
    {
      G4cout << "--- G4TScoreNtupleWriter<T>::Write - has file" << G4endl;
    }
#endif
    fAnalysisManager->Write();
    fAnalysisManager->CloseFile();
    fAnalysisManager->SetFileName("");
  }

#ifdef G4VERBOSE
  if(fVerboseLevel > 1)
  {
    G4cout << "--- done G4TScoreNtupleWriter<T>::Write" << G4endl;
  }
#endif
}

//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::SetDefaultFileType(const G4String& value)
{
  fDefaultFileType = value;
  if(fAnalysisManager)
  {
    fAnalysisManager->SetDefaultFileType(value);
  }
}

//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::SetFileName(const G4String& fileName)
{
  fFileName = fileName;
}

//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::SetVerboseLevel(G4int value)
{
  fVerboseLevel = value;
  if(fAnalysisManager)
  {
    fAnalysisManager->SetVerboseLevel(value);
  }
}

//_____________________________________________________________________________
template <typename T>
void G4TScoreNtupleWriter<T>::SetNtupleMerging(G4bool value)
{
  fMergeNtuples = value;
  if(fAnalysisManager)
  {
    fAnalysisManager->SetNtupleMerging(value);
  }
}