/** @file CbmGeoSetupProvider.cxx
 ** @author Evgeny Lavrik <e.lavrik@gsi.de>
 ** @since 01.10.2019
 **/

#include "geosetup/CbmGeoSetupProvider.h"

#include "FairLogger.h"
#include "FairRunSim.h"
#include "FairModule.h"

#include "CbmDefs.h"
#include "CbmCave.h"
#include "CbmMagnet.h"
#include "CbmPipe.h"
#include "CbmTarget.h"
#include "CbmMvd.h"
#include "CbmStsMC.h"
#include "CbmRich.h"
#include "CbmMuch.h"
#include "CbmTrd.h"
#include "CbmTof.h"
#include "CbmEcal.h"
#include "CbmPsdMC.h"
#include "CbmShield.h"
#include "CbmPlatform.h"

#include <boost/algorithm/string.hpp>

ClassImp(CbmGeoSetupProvider);

namespace { // anonymous namespace
  /// Module loading order is important for proper geometry initialization
  /// While detector modules might share the same level of hierarchy,
  /// cave should be the parent for all; beam pipe - for MVD
  std::vector<Int_t> GetModuleLoadingOrder() {
    return { kCave, kMagnet, kPipe, kTarget,
      kMvd, kSts, kRich, kMuch, kTrd, kTof, kEcal, kPsd,
      kHodo, kShield, kPlatform };
  }
} // end anonymous namespace


void CbmGeoSetupProvider::SetModuleTag(Int_t moduleId, std::string tag, Bool_t active) {
  CbmGeoSetupModule module = GetModuleByTag(moduleId, tag);
  module.SetActive(active);
  fSetup.GetModuleMap()[moduleId] = module;
}

void CbmGeoSetupProvider::RemoveModule(Int_t moduleId) {
  fSetup.GetModuleMap().erase(moduleId);
}

void CbmGeoSetupProvider::SetFieldTag(std::string tag) {
  CbmGeoSetupField field = GetFieldByTag(tag);

  // copy over the scale and position of the field previously set
  field.SetScale(fSetup.GetField().GetScale());
  field.SetMatrix(fSetup.GetField().GetMatrix());
  fSetup.SetField(field);
}

void CbmGeoSetupProvider::RegisterSetup() {
  if (!fSetup.GetModuleMap().size()) {
    LOG(error) << "-E- RegisterSetup: setup " << fSetup.GetName() << " is empty!";
    return;
  }

  // --- Get the FairRunSim instance
  FairRunSim* run = FairRunSim::Instance();
  if (!run) {
    LOG(error) << "-E- RegisterSetup: No FairRunSim instance!";
    return;
  }

  // register media
  run->SetMaterials(fSetup.GetMedia().GetFilePath().c_str());

  for (Int_t moduleId : GetModuleLoadingOrder()) {
    auto& moduleMap = fSetup.GetModuleMap();
    if (moduleMap.find(moduleId) == moduleMap.end())
      continue;

    auto& geoModule = fSetup.GetModuleMap()[moduleId];
    std::string fileName = geoModule.GetFilePath();

    Bool_t isActive = geoModule.GetActive();
    std::string geoTag = geoModule.GetTag();
    std::string modulName = geoModule.GetName();

    std::vector<std::string> _geom;
    std::vector<std::string> _tag;
    boost::split(_geom, fileName, [](char c){return c == ':';});
    boost::split(_tag, geoTag, [](char c){return c == ':';});
    int counter{0};
    for (auto& string: _geom) {

      LOG(info) << "-I- RegisterSetup: Registering "
                << modulName
                << " " << _tag[counter]
                << ((moduleId >=kMvd && moduleId <= kPsd) ?
                    ( isActive ? " -ACTIVE- " : " - INACTIVE- " ) :
                    ""
                    )
                << " using " << string;

      FairModule* fairModule = NULL;
      switch (moduleId) {
        case kCave:     fairModule = new CbmCave("CAVE"); break;
        case kMagnet:   fairModule = new CbmMagnet("MAGNET"); break;
        case kPipe:
          {
          std::string volname{"PIPE"};
          volname += std::to_string(counter);
          fairModule = new CbmPipe(volname.c_str());
          break;
          }
        case kTarget:   fairModule = new CbmTarget(); break;
        case kMvd:      fairModule = new CbmMvd("MVD", isActive); break;
        case kSts:      fairModule = new CbmStsMC(isActive); break;
        case kRich:     fairModule = new CbmRich("RICH", isActive); break;
        case kMuch:     fairModule = new CbmMuch("MUCH", isActive); break;
        case kTrd:      fairModule = new CbmTrd("TRD", isActive); break;
        case kTof:      fairModule = new CbmTof("TOF", isActive); break;
        case kEcal:     fairModule = new CbmEcal("Ecal", isActive); break;
        case kPsd:      fairModule = new CbmPsdMC(isActive); break;
        case kShield:   fairModule = new CbmShield("SHIELD"); break;
        case kPlatform: fairModule = new CbmPlatform("PLATFORM"); break;
        case kHodo:     fairModule = new CbmStsMC(isActive); break;
        default:
          LOG(error) << "-E- RegisterSetup: Unknown fairModule ID " << moduleId;
          break;
      }
          counter++;

      if ( fairModule ) {
        if (moduleId == kMvd) fairModule->SetMotherVolume("pipevac1");
        fairModule->SetGeometryFileName(string.c_str());
        run->AddModule(fairModule);
      }
    }
  }
}

void CbmGeoSetupProvider::Reset() {
  fSetup = CbmGeoSetup();
}

CbmGeoSetupModule CbmGeoSetupProvider::GetDefaultCaveModule() {
  std::string geoFilePath = std::string(gSystem->Getenv("VMCWORKDIR")) + "/geometry/cave.geo";

  CbmGeoSetupModule module;
  module.SetName("CAVE");
  module.SetFilePath("cave.geo");
  module.SetTag("default");
  module.SetModuleId(kCave);

  return module;
}