/***************************************************************************

  PRgeHandler.cpp

  Author: Andreas Suter
  e-mail: andreas.suter@psi.ch

***************************************************************************/

/***************************************************************************
 *   Copyright (C) 2007-2023 by Andreas Suter                              *
 *   andreas.suter@psi.ch                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <fstream>
#include <iostream>
#include <vector>
#include <string>

#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>

#include <TXMLAttr.h>
#include "PRgeHandler.h"

ClassImpQ(PXmlRgeHandler)

//--------------------------------------------------------------------------
// OnStartDocument
//--------------------------------------------------------------------------
/**
 * <p>Called on start of the XML file reading. Initializes all necessary variables.
 */
void PXmlRgeHandler::OnStartDocument()
{
  fKey = eEmpty;
}

//--------------------------------------------------------------------------
// OnEndDocument
//--------------------------------------------------------------------------
/**
 * <p>Called on end of XML file reading.
 */
void PXmlRgeHandler::OnEndDocument()
{
  if (!fIsValid)
    return;

  // check if anything was set
  if (fTrimSpDataPath.empty()) {
    std::string err = "<data_path> content is missing!";
    fIsValid = false;
    OnError(err.c_str());
  }
  if (fTrimSpFlnPre.empty()) {
    std::string err = "<rge_fln_pre> content is missing!";
    fIsValid = false;
    OnError(err.c_str());
  }
  if (fTrimSpDataEnergyList.size()==0) {
    std::string err = "no implantation energies present!";
    fIsValid = false;
    OnError(err.c_str());
  }
}

//--------------------------------------------------------------------------
// OnStartElement
//--------------------------------------------------------------------------
/**
 * <p>Called when a XML start element is found. Filters out the needed elements
 * and sets a proper key.
 *
 * \param str XML element name
 * \param attributes used only for energy_vect
 */
void PXmlRgeHandler::OnStartElement(const Char_t *str, const TList *attributes)
{
  if (!strcmp(str, "trim_sp")) {
    isTrimSp=true;
  } else if (!strcmp(str, "data_path") && isTrimSp) {
    fKey = eDataPath;
  } else if (!strcmp(str, "rge_fln_pre") && isTrimSp) {
    fKey = eFlnPre;
  } else if (!strcmp(str, "energy") && isTrimSp) {
    fKey = eEnergy;
  } else if (!strcmp(str, "energy_vect") && isTrimSp) {
    std::string msg("");
    if (attributes == nullptr) {
      fIsValid = false;
      msg = "Found energy_list without attributes";
      OnError(msg.c_str());
      return;
    }
    if (attributes->GetEntries() != 3) {
      fIsValid = false;
      msg = "energy_list: expect 3 attributes (start, stop, step), found " + std::to_string(attributes->GetEntries());
      OnError(msg.c_str());
      return;
    }

    TXMLAttr *attr;

    int start=-1, stop=-1, step=-1, ival;
    TIter next(attributes);
    while ((attr = (TXMLAttr*) next())) {
      char sval[256];
      strncpy(sval, attr->GetValue(), sizeof(sval));
      try {
        ival = std::stoi(sval);
      } catch(std::invalid_argument& e) {
        fIsValid = false;
        msg = "The found energy_list attribute '" + std::string(sval) + "' which is not a number";
        OnError(msg.c_str());
        return;
      } catch(std::out_of_range& e) {
        fIsValid = false;
        msg = "The found energy_list attribute '" + std::string(sval) + "' which is out-of-range.";
        OnError(msg.c_str());
        return;
      } catch(...) {
        fIsValid = false;
        msg = "The found energy_list attribute '" + std::string(sval) + "' which generates an error.";
        OnError(msg.c_str());
        return;
      }
      if (!strcmp(attr->GetName(), "start")) {
        start = ival;
      } else if (!strcmp(attr->GetName(), "stop")) {
        stop = ival;
      } else if (!strcmp(attr->GetName(), "step")) {
        step = ival;
      }
    }
    // make sure I do have start, stop, and step values set
    if ((start == -1) || (stop == -1) || (step == -1)) {
      fIsValid = false;
      msg = "Found energy_list with missing attributes. Needed start, stop and step.";
      OnError(msg.c_str());
      return;
    }
    // more checks: start < stop, and step > 0.
    if ((start > stop)) {
      fIsValid = false;
      msg = "Found energy_list with start > stop. Not allowed in the context.";
      OnError(msg.c_str());
      return;
    }
    if (step < 0) {
      fIsValid = false;
      msg = "Found energy_list with step < 0. Not allowed in the context.";
      OnError(msg.c_str());
      return;
    }
    // generate the fTrimSpDataEnergyList vector
    ival = start;
    do {
      fTrimSpDataEnergyList.push_back(ival);
      ival += step;
    } while (ival <= stop);
  }
}

//--------------------------------------------------------------------------
// OnEndElement
//--------------------------------------------------------------------------
/**
 * <p>Called when a XML end element is found. Resets the handler key.
 *
 * \param str not used
 */
void PXmlRgeHandler::OnEndElement(const Char_t *str)
{
  if (!strcmp(str, "trim_sp")) {
    isTrimSp=false;
  }

  fKey = eEmpty;
}

//--------------------------------------------------------------------------
// OnCharacters
//--------------------------------------------------------------------------
/**
 * <p>Content of a given XML element. Filters out the data and feeds them to
 * the internal variables.
 *
 * \param str XML element string
 */
void PXmlRgeHandler::OnCharacters(const Char_t *str)
{
  int ival;
  std::string msg(""), sstr(str);
  size_t pos;

  switch(fKey) {
    case eDataPath:
      fTrimSpDataPath=str;
      break;
    case eFlnPre:
      fTrimSpFlnPre=str;
      break;
    case eEnergy:
      try {
        ival = std::stoi(str, &pos);
      } catch(std::invalid_argument& e) {
        fIsValid = false;
        msg = "The found energy '" + sstr + "' which is not a number";
        OnError(msg.c_str());
      } catch(std::out_of_range& e) {
        fIsValid = false;
        msg = "The found energy '" + sstr + "' which is out-of-range.";
        OnError(msg.c_str());
      } catch(...) {
        fIsValid = false;
        msg = "The found energy '" + sstr + "' which generates an error.";
        OnError(msg.c_str());
      }
      if (pos != sstr.length()) {
        fIsValid = false;
        msg = "The found energy '" + sstr + "' which is not an integer";
        OnError(msg.c_str());
      }
      fTrimSpDataEnergyList.push_back(ival);
      break;
    default:
      break;
  }
}

//--------------------------------------------------------------------------
// OnComment
//--------------------------------------------------------------------------
/**
 * <p>Called when a XML comment is found. Not used.
 *
 * \param str not used.
 */
void PXmlRgeHandler::OnComment(const Char_t *str)
{
  // nothing to be done for now
}

//--------------------------------------------------------------------------
// OnWarning
//--------------------------------------------------------------------------
/**
 * <p>Called when the XML parser emits a warning.
 *
 * \param str warning string
 */
void PXmlRgeHandler::OnWarning(const Char_t *str)
{
  std::cerr << std::endl << "PXmlRgeHandler **WARNING** " << str;
  std::cerr << std::endl;
}

//--------------------------------------------------------------------------
// OnError
//--------------------------------------------------------------------------
/**
 * <p>Called when the XML parser emits an error.
 *
 * \param str error string
 */
void PXmlRgeHandler::OnError(const Char_t *str)
{
  std::cerr << std::endl << "PXmlRgeHandler **ERROR** " << str;
  std::cerr << std::endl;
}

//--------------------------------------------------------------------------
// OnFatalError
//--------------------------------------------------------------------------
/**
 * <p>Called when the XML parser emits a fatal error.
 *
 * \param str fatal error string
 */
void PXmlRgeHandler::OnFatalError(const Char_t *str)
{
  std::cerr << std::endl << "PXmlRgeHandler **FATAL ERROR** " << str;
  std::cerr << std::endl;
}

//--------------------------------------------------------------------------
// OnCdataBlock
//--------------------------------------------------------------------------
/**
 * <p>Not used.
 *
 * \param str not used
 * \param len not used
 */
void PXmlRgeHandler::OnCdataBlock(const Char_t *str, Int_t len)
{
  // nothing to be done for now
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

ClassImp(PRgeHandler)

//--------------------------------------------------------------------------
// Ctor
//--------------------------------------------------------------------------
/**
 * @brief PRgeHandler::PRgeHandler
 * @param fln
 */
PRgeHandler::PRgeHandler(const std::string fln)
{
  // make sure there is an xml-startup file name
  if (fln.empty()) { // fln not given
    std::cerr << std::endl;
    std::cerr << "**ERROR** NO xml file name provided." << std::endl;
    std::cerr << std::endl;
    fValid=false;
    return;
  }

  // read the startup xml-file to extract the necessary rge infos.
  if (!boost::filesystem::exists(fln)) {
    std::cerr << std::endl;
    std::cerr << "**ERROR** xml file named: " << fln << " does not exist." << std::endl;
    std::cerr << std::endl;
    fValid=false;
    return;
  }

  // create the rge xml handler
  PXmlRgeHandler *xmlRge = new PXmlRgeHandler();
  if (xmlRge == nullptr) {
    std::cerr << std::endl;
    std::cerr << "**ERROR** couldn't invoke PXmlRgeHandler." << std::endl;
    std::cerr << std::endl;
    fValid=false;
    return;
  }

  // create the SAX parser
  TSAXParser *saxParser = new TSAXParser();
  if (saxParser == nullptr) {
    std::cerr << std::endl;
    std::cerr << "**ERROR** couldn't invoke TSAXParser." << std::endl;
    std::cerr << std::endl;
    fValid=false;
    return;
  }
  saxParser->SetStopOnError();

  // connect SAX parser and rge handler
  saxParser->ConnectToHandler("PXmlRgeHandler", xmlRge);
  int status = saxParser->ParseFile(fln.c_str());
  if (status != 0) {
    std::cerr << std::endl;
    std::cerr << "**ERROR** parsing the xml-file: " << fln << "." << std::endl;
    std::cerr << std::endl;
    fValid=false;
    return;
  }
  if (xmlRge->IsValid())
    fValid = true;
  else
    fValid = false;

  // read the rge-file(s) content if everything went fine so far
  std::string rgeFln;
  PRgeData dataSet;
  if (fValid) {
    const PIntVector energy = xmlRge->GetTrimSpDataVectorList();
    for (int i=0; i<energy.size(); i++) {
      // construct the file name
      rgeFln = xmlRge->GetTrimSpDataPath();
      if (rgeFln[rgeFln.size()-1] != '/')
        rgeFln += "/";
      rgeFln += xmlRge->GetTrimSpFlnPre();
      rgeFln += std::to_string(energy[i]);
      rgeFln += ".rge";
      if (!boost::filesystem::exists(rgeFln)) {
        fValid = false;
        std::cerr << std::endl;
        std::cerr << "**ERROR** rge-file: " << rgeFln << " not found." << std::endl;
        std::cerr << std::endl;
        break;
      }
      // init data set
      dataSet.energy = energy[i];
      dataSet.depth.clear();
      dataSet.amplitude.clear();
      if (!ReadRgeFile(rgeFln, dataSet)) {
        fValid = false;
        std::cerr << std::endl;
        std::cerr << "**ERROR** read error in rge-file: " << rgeFln << " not found." << std::endl;
        std::cerr << std::endl;
        break;
      }

      // get the total number of particles
      double tot=0.0;
      for (int j=0; j<dataSet.amplitude.size(); j++)
        tot += dataSet.amplitude[j];
      dataSet.noOfParticles = tot;

      // sum_j nn dzz == 1, (dzz_j = depth[j]-depth[j-1])
      dataSet.nn.resize(dataSet.amplitude.size());
      tot = 0.0;
      double zz=0.0; // "previous" zz (since depth[j]-depth[j-1] != const) it needs to be done this way.
      for (int j=0; j<dataSet.nn.size(); j++) {
        tot += dataSet.amplitude[j] * (dataSet.depth[j] - zz);
        zz = dataSet.depth[j];
      }
      for (int j=0; j<dataSet.nn.size(); j++) {
        dataSet.nn[j] = dataSet.amplitude[j] / tot;
      }

      fData.push_back(dataSet);
    }
  }

  delete saxParser;
  delete xmlRge;
}

//--------------------------------------------------------------------------
// ReadRgeFile
//--------------------------------------------------------------------------
/**
 * <p>Read the content of a rge-file.
 *
 * @param fln file name of the rge-file
 * @return true on success.
 */
bool PRgeHandler::ReadRgeFile(const std::string fln, PRgeData &data)
{
  std::ifstream fin(fln);
  if (!fin.is_open())
    return false;

  std::string line, msg;
  std::vector<std::string> tok;
  Double_t zz, nn;
  size_t pos;
  int lineNo=0;

  while (fin.good() && fValid) {
    std::getline(fin, line);
    lineNo++;
    boost::algorithm::trim(line);
    if (line.empty())
      continue;
    if (!std::isdigit(line[0]))
      continue;
    tok.clear();
    boost::algorithm::split(tok, line, boost::algorithm::is_any_of(" \t"), boost::algorithm::token_compress_on);
    if (tok.size() != 2) {
      std::cerr << std::endl;
      std::cerr << "**ERROR** in rge-file: " << fln << ", unexpected number of tokens (" << tok.size() << ")." << std::endl;
      std::cerr << std::endl;
      fin.close();
      return false;
    }
    // check distance
    try {
      zz = std::stod(tok[0], &pos);
    } catch(std::invalid_argument& e) {
      fValid = false;
      msg = "The found depth '" + tok[0] + "' which is not a number";
      std::cerr << std::endl;
      std::cerr << "**ERROR** in rge-file: " << fln << ": lineNo: " << lineNo << std::endl;
      std::cerr << "   " << msg << std::endl;
      std::cerr << std::endl;
    } catch(std::out_of_range& e) {
      fValid = false;
      msg = "The found depth '" + tok[0] + "' which is out-of-range.";
      std::cerr << std::endl;
      std::cerr << "**ERROR** in rge-file: " << fln << ": lineNo: " << lineNo << std::endl;
      std::cerr << "   " << msg << std::endl;
      std::cerr << std::endl;
    } catch(...) {
      fValid = false;
      msg = "The found depth '" + tok[0] + "' which generates an error.";
      std::cerr << std::endl;
      std::cerr << "**ERROR** in rge-file: " << fln << ": lineNo: " << lineNo << std::endl;
      std::cerr << "   " << msg << std::endl;
      std::cerr << std::endl;
    }
    if (pos != tok[0].length()) {
      fValid = false;
      msg = "The found depth '" + tok[0] + "' which is not an number.";
      std::cerr << std::endl;
      std::cerr << "**ERROR** in rge-file: " << fln << ": lineNo: " << lineNo << std::endl;
      std::cerr << "   " << msg << std::endl;
      std::cerr << std::endl;
    }
    // check number of implanted particles
    try {
      nn = std::stod(tok[1], &pos);
    } catch(std::invalid_argument& e) {
      fValid = false;
      msg = "The found #particles '" + tok[1] + "' which is not a number";
      std::cerr << std::endl;
      std::cerr << "**ERROR** in rge-file: " << fln << ": lineNo: " << lineNo << std::endl;
      std::cerr << "   " << msg << std::endl;
      std::cerr << std::endl;
    } catch(std::out_of_range& e) {
      fValid = false;
      msg = "The found #particles '" + tok[1] + "' which is out-of-range.";
      std::cerr << std::endl;
      std::cerr << "**ERROR** in rge-file: " << fln << ": lineNo: " << lineNo << std::endl;
      std::cerr << "   " << msg << std::endl;
      std::cerr << std::endl;
    } catch(...) {
      fValid = false;
      msg = "The found #particles '" + tok[1] + "' which generates an error.";
      std::cerr << std::endl;
      std::cerr << "**ERROR** in rge-file: " << fln << ": lineNo: " << lineNo << std::endl;
      std::cerr << "   " << msg << std::endl;
      std::cerr << std::endl;
    }
    if (pos != tok[1].length()) {
      fValid = false;
      msg = "The found #particles '" + tok[1] + "' which is not an integer.";
      std::cerr << std::endl;
      std::cerr << "**ERROR** in rge-file: " << fln << ": lineNo: " << lineNo << std::endl;
      std::cerr << "   " << msg << std::endl;
      std::cerr << std::endl;
    }
    data.depth.push_back(zz/10.0); // distance in nm
    data.amplitude.push_back(nn);
  }

  fin.close();

  return true;
}

//--------------------------------------------------------------------------
// GetZmax via energy
//--------------------------------------------------------------------------
/**
 * <p>Get maximal depth for a given energy.
 *
 * @param energy energy in (eV)
 * @return zMax if energy is found, -1 otherwise.
 */
Double_t PRgeHandler::GetZmax(const Double_t energy)
{
  int idx=-1;
  for (int i=0; i<fData.size(); i++) {
    if (fabs(fData[i].energy-energy)*0.001 < 0.9){
      idx = i;
      break;
    }
  }
  
  if (idx != -1)
      return GetZmax(idx);

  return -1;
}

//--------------------------------------------------------------------------
// GetZmax via index
//--------------------------------------------------------------------------
/**
 * <p>Get maximal depth for a given index.
 *
 * @param idx index for which zMax is requested.
 * @return zMax if idx is in range, -1 otherwise.
 */
Double_t PRgeHandler::GetZmax(const Int_t idx)
{
  if ((idx < 0) || (idx >= fData.size()))
    return -1.0;

  return fData[idx].depth[fData[idx].depth.size()-1];
}

//--------------------------------------------------------------------------
// Get_n via energy
//--------------------------------------------------------------------------
/**
 * <p>Get the normalized n(E,z) value.
 *
 * @param energy (eV)
 * @param z (nm)
 * @return n(E,z) if energy and z are in proper range, -1.0 otherwise.
 */
Double_t PRgeHandler::Get_n(const Double_t energy, const Double_t z)
{
  int idx=-1;
  for (int i=0; i<fData.size(); i++) {
    if (fabs(fData[i].energy-energy)*0.001 < 0.90) {
      idx = i;
      break;
    }
  }
  if (idx == -1)
    return 0.0;

  return Get_n(idx, z);
}

//--------------------------------------------------------------------------
// Get_n via index
//--------------------------------------------------------------------------
/**
 * <p>Get the normalized n(idx,z) value.
 *
 * @param idx index of the rge-dataset
 * @param z (nm)
 * @return n(idx,z) if idx and z are in proper range, -1.0 otherwise.
 */
Double_t PRgeHandler::Get_n(const Int_t idx, const Double_t z)
{
  if ((idx < 0) || (idx >= fData.size()))
    return 0.0;

  if ((z < 0.0) || (z > GetZmax(idx)))
    return 0.0;

  int pos=0;
  for (int i=0; i<fData[idx].depth.size(); i++) {
    if (z <= fData[idx].depth[i]) {
      pos = i-1;
      break;
    }
  }

  Double_t nn=0.0;
  if (pos < 0) {
    nn = fData[idx].nn[0] * z/(fData[idx].depth[1]-fData[idx].depth[0]);
  } else { // linear interpolation
    nn = fData[idx].nn[pos] +
         (fData[idx].nn[pos+1] - fData[idx].nn[pos]) *
         (z-fData[idx].depth[pos])/(fData[idx].depth[pos+1]-fData[idx].depth[pos]);
  }

  return nn;
}

//--------------------------------------------------------------------------
// GetEnergyIndex
//--------------------------------------------------------------------------
/**
 * <p>Get the energy index by providing an energy in (eV).
 *
 * @param energy in (eV).
 * @return energy index if energy was found, -1 otherwise.
 */
Int_t PRgeHandler::GetEnergyIndex(const Double_t energy)
{
  int idx=-1;
  for (int i=0; i<fData.size(); i++) {
    if (fabs(fData[i].energy-energy)*0.001 < 0.90) {
      idx = i;
      break;
    }
  }

  return idx;
}