#include <fstream>

#include "radixcore/stringfunctions.hh"
#include "radixcore/system.hh"

#include "radixio/emitdb.hh"

namespace radix
{
EmitDb::EmitDb()
{
  // load_mpdkxgam(EmitDb::XGAMDATA4);
  // load_mpdkxgam(EmitDb::XGAMDATA3);
  // load_ensdfbeta(EmitDb::BETADATA);
}

EmitDb::EmitDb(const EmitDb& orig)
{
  mIsotope      = orig.mIsotope;
  mIsotopeTitle = orig.mIsotopeTitle;
}

void XGamDb::load(const std::string& file, EmitDb& database)
{
  std::string revStr = radix::split_string(".", radix::basename(file))[1];
  int revNum         = std::atoi(revStr.substr(revStr.size() - 1, 1).c_str());
  int indexThreshold = 70, indexIterator = 20;
  int linecount = 0;
  if (revNum == 3)
  {
    indexThreshold = 70;
    indexIterator  = 20;
  }
  else if (revNum == 4)
  {
    indexThreshold = 77;
    indexIterator  = 22;
  }
  std::ifstream xgamFile(file);
  std::string line, prev;
  std::vector<float> energies, intensities;
  int zaid          = -1;
  int totalLines    = 0;
  float totalEnergy = 0.f;
  auto& isotopes    = database.isotopes();
  while (std::getline(xgamFile, line))
  {
    linecount += 1;
    int thisZaid = std::atoi(line.substr(1, 6).c_str());
    if (thisZaid != 0)
    {
      if (zaid != -1 && energies.size() > 0)
      {
        EmitDBEntry emitEntry;
        emitEntry.z           = int(zaid / 10000);
        emitEntry.a           = int((zaid % 10000) / 10);
        emitEntry.m           = int(zaid % 10);
        emitEntry.energy      = totalEnergy;
        emitEntry.energies    = energies;
        emitEntry.intensities = intensities;
        isotopes.insert(std::make_pair(zaid, emitEntry));
        energies.clear();
        intensities.clear();
      }
      zaid = thisZaid;
      // totalLines  = std::atoi(line.substr(9, 12).c_str());
      totalEnergy = std::atof(line.substr(60, 10).c_str());
    }
    else
    {
      int index      = 3;
      int jumpLength = 10;
      if (revNum == 3)
      {
        index      = 10;
        jumpLength = 10;
      }
      else
      {
        index      = 10;
        jumpLength = 11;
      }
      while (index < indexThreshold && index < line.size())
      {
        float energy = std::atof(line.substr(index, 10).c_str());
        float intensity =
            std::atof(line.substr(index + jumpLength, 10).c_str());
        energies.push_back(energy);
        intensities.push_back(intensity);
        index += indexIterator;
      }
    }
    prev = line;
  }
  EmitDBEntry emitEntry;
  emitEntry.z           = int(zaid / 10000);
  emitEntry.a           = int((zaid % 10000) / 10);
  emitEntry.m           = int(zaid % 10);
  emitEntry.energy      = totalEnergy;
  emitEntry.energies    = energies;
  emitEntry.intensities = intensities;
  isotopes.insert(std::make_pair(zaid, emitEntry));
  energies.clear();
  intensities.clear();
}

void EnsdfBetaDb::load(const std::string& file, EmitDb& database)
{
  std::ifstream betaFile(file);
  std::string line, prev;
  int zaidCount = 0;
  int zaid      = -1;
  int linecount = 0;
  std::vector<float> energies, intensities;
  auto& isotopes = database.isotopes();
  while (std::getline(betaFile, line))
  {
    linecount += 1;
    if (line.substr(0, 2) == "  ")
    {
      if (line.size() > 10)
      {
        int zaidl = std::atoi(line.substr(2, 6).c_str());
        if (zaid != zaidl)
        {
          zaid = zaidl;
        }
        zaidCount++;
        float intensity = std::atof(line.substr(10, 8).c_str());
        float energy    = std::atof(line.substr(19, 9).c_str());
        energies.push_back(energy);
        intensities.push_back(intensity);
      }
      else
      {
        if (energies.size() > 0 && zaid != -1)
        {
          float totalEnergy = 0.0f;
          for (size_t i = 0; i < intensities.size(); ++i)
          {
            totalEnergy += (intensities[i] * energies[i]);
          }
          EmitDBEntry emitEntry;
          emitEntry.z           = int(zaid / 10000);
          emitEntry.a           = int((zaid % 10000) / 10);
          emitEntry.m           = int(zaid % 10);
          emitEntry.energy      = totalEnergy;
          emitEntry.energies    = energies;
          emitEntry.intensities = intensities;
          const auto& isOutside =
              isotopes.insert(std::make_pair(zaid, emitEntry));
          if (!isOutside.second)
          {
            isOutside.first->second.energy      = totalEnergy;
            isOutside.first->second.energies    = energies;
            isOutside.first->second.intensities = intensities;
          }
          zaidCount = 0;
          energies.clear();
          intensities.clear();
        }
      }
    }
    prev = line;
  }
  if (energies.size() > 0)
  {
    float totalEnergy = 0.0f;
    for (size_t i = 0; i < intensities.size(); ++i)
    {
      totalEnergy += (intensities[i] * energies[i]);
    }
    EmitDBEntry emitEntry;
    emitEntry.z           = int(zaid / 10000);
    emitEntry.a           = int((zaid % 10000) / 10);
    emitEntry.m           = int(zaid % 10);
    emitEntry.energy      = totalEnergy;
    emitEntry.energies    = energies;
    emitEntry.intensities = intensities;
    const auto& isOutside = isotopes.insert(std::make_pair(zaid, emitEntry));
    if (!isOutside.second)
    {
      isOutside.first->second.energy      = totalEnergy;
      isOutside.first->second.energies    = energies;
      isOutside.first->second.intensities = intensities;
    }
    energies.clear();
    intensities.clear();
  }
}

const std::string& EmitDb::isotope_title() const { return mIsotopeTitle; }
void EmitDb::set_isotope_title(const std::string& title)
{
  mIsotopeTitle = title;
}
const std::unordered_map<int, EmitDBEntry>& EmitDb::isotopes() const
{
  return mIsotope;
}
std::unordered_map<int, EmitDBEntry>& EmitDb::isotopes() { return mIsotope; }
const EmitDBEntry& EmitDb::emitter(int zaid) const
{
  const auto& it = mIsotope.find(zaid);
  return it->second;
}
std::vector<std::vector<float>> EmitDb::energy_intensities(const int zaid) const
{
  const auto& it                         = mIsotope.find(zaid);
  const std::vector<float>& energies     = it->second.energies;
  const std::vector<float>& intensities  = it->second.intensities;
  std::vector<std::vector<float>> paired = {energies, intensities};
  return paired;
}

void EmitDb::operator=(const EmitDb& orig)
{
  mIsotope      = orig.mIsotope;
  mIsotopeTitle = orig.mIsotopeTitle;
}

}  // namespace radix