#include "RDMolImpl.h"
#include <GraphMol/RDKitBase.h>
#include <GraphMol/SmilesParse/SmilesParse.h>
#include <GraphMol/SmilesParse/SmilesWrite.h>
#include <GraphMol/FileParsers/Fileparsers.h>
#include <GraphMol/Substruct/SubstructMatch.h>
#include <GraphMol/Descriptors/MolDescriptors.h>
#include <GraphMol/DistGeomHelpers/Embedder.h>
#include <ForceField/ForceField.h>
#include <GraphMol/ForceFieldHelpers/UFF/Builder.h>
#include <string>
#include <vector>
#include <nsMemory.h>

NS_IMPL_ISUPPORTS1(RDMolecule, IRDMolecule)

RDMolecule::~RDMolecule() {
  if (this->dp_mol) {
    delete dp_mol;
    dp_mol = 0;
  }
}

/* double GetMW (); */
NS_IMETHODIMP RDMolecule::GetMW(double *_retval) {
  if (!dp_mol) return NS_ERROR_NOT_INITIALIZED;
  RDKit::PeriodicTable *pt = RDKit::PeriodicTable::getTable();
  *_retval = 0.0;
  for (RDKit::ROMol::AtomIterator atIt = dp_mol->beginAtoms();
       atIt != dp_mol->endAtoms(); atIt++) {
    *_retval += (*atIt)->getMass() +
                (*atIt)->getNumImplicitHs() * pt->getAtomicWeight(1);
  }
  return NS_OK;
}

/* string GetSmiles (); */
NS_IMETHODIMP RDMolecule::GetSmiles(char **_retval) {
  if (!dp_mol) return NS_ERROR_NOT_INITIALIZED;
  std::string smi = RDKit::MolToSmiles(*dp_mol);
  *_retval =
      (char *)nsMemory::Clone(smi.c_str(), sizeof(char) * (smi.size() + 1));
  return *_retval ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}

/* unsigned long GetSmartsMatchCount (in string smarts); */
NS_IMETHODIMP RDMolecule::GetSmartsMatchCount(const char *smarts,
                                              PRUint32 *_retval) {
  if (!dp_mol) return NS_ERROR_NOT_INITIALIZED;
  RDKit::ROMol *patt = RDKit::SmartsToMol(std::string(smarts));
  if (!patt) return NS_ERROR_FAILURE;

  std::vector<RDKit::MatchVectType> matches;
  int res = RDKit::SubstructMatch(dp_mol, patt, matches);
  *_retval = res;
  return NS_OK;
}

/* double LogP (); */
NS_IMETHODIMP RDMolecule::LogP(double *_retval) {
  if (!dp_mol) return NS_ERROR_NOT_INITIALIZED;
  double logp;
  if (dp_mol->hasProp(common_properties::_CrippenLogP)) {
    dp_mol->getProp(common_properties::_CrippenLogP, logp);
  } else {
    double mr;
    RDKit::Descriptors::CalcCrippenDescriptors(dp_mol, logp, mr);
    dp_mol->setProp(common_properties::_CrippenLogP, logp, true);
    dp_mol->setProp(common_properties::_CrippenMR, mr, true);
  }
  *_retval = logp;
  return NS_OK;
}

/* double MR (); */
NS_IMETHODIMP RDMolecule::MR(double *_retval) {
  if (!dp_mol) return NS_ERROR_NOT_INITIALIZED;
  double mr;
  if (dp_mol->hasProp(common_properties::_CrippenMR)) {
    dp_mol->getProp(common_properties::_CrippenMR, mr);
  } else {
    double logp;
    RDKit::Descriptors::CalcCrippenDescriptors(dp_mol, logp, mr);
    dp_mol->setProp(common_properties::_CrippenLogP, logp, true);
    dp_mol->setProp(common_properties::_CrippenMR, mr, true);
  }
  *_retval = mr;
  return NS_OK;
}

/* string GetMolBlock (); */
NS_IMETHODIMP RDMolecule::GetMolBlock(char **_retval) {
  if (!dp_mol) return NS_ERROR_NOT_INITIALIZED;
  std::string molB = RDKit::MolToMolBlock(dp_mol);
  *_retval =
      (char *)nsMemory::Clone(molB.c_str(), sizeof(char) * (molB.size() + 1));
  return *_retval ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}

/* void Generate3DCoords (); */
NS_IMETHODIMP RDMolecule::Generate3DCoords() {
  if (!dp_mol) return NS_ERROR_NOT_INITIALIZED;
  bool embedded = RDKit::DGeomHelpers::EmbedMolecule(*dp_mol);
  if (!embedded) return NS_ERROR_FAILURE;

  ForceFields::ForceField *ff = RDKit::UFF::constructForceField(dp_mol);
  if (!ff) return NS_ERROR_FAILURE;
  ff->initialize();
  int needsMore = ff->minimize();
  delete ff;
  if (needsMore) return NS_ERROR_FAILURE;
  return NS_OK;
}