//

//  Copyright (c) 2015-2020 Greg Landrum

//

//   @@ All Rights Reserved @@

//  This file is part of the RDKit.

//  The contents are covered by the terms of the BSD license

//  which is included in the file license.txt, found at the root

//  of the RDKit source tree.

//

#include <GraphMol/GraphMol.h>

#include <GraphMol/QueryAtom.h>

#include <GraphMol/QueryBond.h>

#include <GraphMol/MolOps.h>

#include <GraphMol/QueryOps.h>

#include <GraphMol/AtomIterators.h>

#include <GraphMol/BondIterators.h>

#include <RDGeneral/BoostStartInclude.h>

#include <boost/property_tree/ptree.hpp>

#include <boost/property_tree/json_parser.hpp>

#include <boost/algorithm/string.hpp>

#include <boost/tokenizer.hpp>

#include <RDGeneral/BoostEndInclude.h>

#include <vector>

#include <algorithm>

namespace RDKit {

namespace {

bool isMapped(const Atom *atom) {

  return atom->hasProp(common_properties::molAtomMapNumber);

}

}  // namespace

namespace MolOps {

namespace {

typedef boost::tokenizer<boost::char_separator<char>> tokenizer;

unsigned int parseWhichString(const std::string &txt) {

  unsigned int res = MolOps::ADJUST_IGNORENONE;

  boost::char_separator<char> sep("|");

  tokenizer tokens(txt, sep);

  for (const auto &token : tokens) {

    if (token == "IGNORENONE") {

      res |= MolOps::ADJUST_IGNORENONE;

    } else if (token == "IGNORERINGS") {

      res |= MolOps::ADJUST_IGNORERINGS;

    } else if (token == "IGNORECHAINS") {

      res |= MolOps::ADJUST_IGNORECHAINS;

    } else if (token == "IGNOREDUMMIES") {

      res |= MolOps::ADJUST_IGNOREDUMMIES;

    } else if (token == "IGNORENONDUMMIES") {

      res |= MolOps::ADJUST_IGNORENONDUMMIES;

    } else if (token == "IGNOREALL") {

      res |= MolOps::ADJUST_IGNOREALL;

    } else {

      std::string msg = "Unknown flag value: '" + token + "'. Flags ignored.";

      throw ValueErrorException(msg);

    }

  }

  return res;

}

constexpr const char *conjugatedOrAromatic = "_conjugatedOrAromatic";

void adjustConjugatedFiveRings(RWMol &mol) {

  /*

   The idea here is to allow conjugated five-rings to match either aromatic or

   aliphatic rings

   five-rings which contain at least 3 conjugated bonds have all of their

   non-query bonds replaced with a SINGLE|DOUBLE|AROMATIC query.

   */

  std::vector<Bond::BondType> bondTypesToModify = {

      Bond::BondType::SINGLE, Bond::BondType::DOUBLE, Bond::BondType::AROMATIC};

  if (!mol.getRingInfo()->isSymmSssr()) {

    MolOps::symmetrizeSSSR(mol);

  }

  for (auto ring : mol.getRingInfo()->bondRings()) {

    // only consider 5-rings with at least 3 conjugated bonds

    if (ring.size() != 5) {

      continue;

    }

    unsigned int nconj = 0;

    for (auto bi : ring) {

      const auto bond = mol.getBondWithIdx(bi);

      if (bond->getIsConjugated()) {

        ++nconj;

        if (nconj >= 3) {

          break;

        }

      }

    }

    if (nconj < 3) {

      continue;

    }

    // now make the adjustments

    QueryBond qb;

    qb.setQuery(makeSingleOrDoubleOrAromaticBondQuery());

    for (auto bi : ring) {

      const auto bond = mol.getBondWithIdx(bi);

      bond->getBeginAtom()->setProp(conjugatedOrAromatic, 1, true);

      bond->getEndAtom()->setProp(conjugatedOrAromatic, 1, true);

      if (std::find(bondTypesToModify.begin(), bondTypesToModify.end(),

                    bond->getBondType()) != bondTypesToModify.end()) {

        if (bond->hasQuery()) {

          BOOST_LOG(rdWarningLog)

              << "adjustConjugatedFiveRings: replacing a bond "

                 "that already has a query"

              << std::endl;

        }

        mol.replaceBond(bi, &qb);

      }

    }

  }

}

bool isAromaticOrConjugated(const Atom &atom) {

  return atom.getIsAromatic() || atom.hasProp(conjugatedOrAromatic);

}

void adjustSingleBondsFromAromaticAtoms(RWMol &mol, bool toDegreeOneNeighbors,

                                        bool betweenAromaticAtoms) {

  /*

  The idea here is to allow single bonds coming from aromatic atoms to match

  aromatic bonds under particular circumstances. The conditions are:

  1. toDegreeOneNeighbors: [D1]-[a] -> [D1]-,:[a]

  2. betweenAromaticAtoms: [a]-[a] -> [a]-,:[a]

  */

  if (!toDegreeOneNeighbors && !betweenAromaticAtoms) {

    return;

  }

  QueryBond qb;

  qb.setQuery(makeSingleOrAromaticBondQuery());

  if (!mol.getRingInfo()->isSymmSssr()) {

    MolOps::symmetrizeSSSR(mol);

  }

  for (auto bond : mol.bonds()) {

    const auto bAt = bond->getBeginAtom();

    const auto eAt = bond->getEndAtom();

    if (!bond->hasQuery() && bond->getBondType() == Bond::BondType::SINGLE) {

      auto bAtIsAromatic = isAromaticOrConjugated(*bAt);

      auto eAtIsAromatic = isAromaticOrConjugated(*eAt);

      if (toDegreeOneNeighbors && (bAtIsAromatic ^ eAtIsAromatic)) {

        if ((bAtIsAromatic && eAt->getDegree() == 1) ||

            (eAtIsAromatic && bAt->getDegree() == 1)) {

          mol.replaceBond(bond->getIdx(), &qb);

        }

      } else if (betweenAromaticAtoms && bAtIsAromatic && eAtIsAromatic) {

        mol.replaceBond(bond->getIdx(), &qb);

      }

    }

  }

}

void setMDLAromaticity(RWMol &mol) {

  /*

  The idea here is to make aromatic 5-rings that contain an "A" atom in the CTAB

  match both aromatic and aliphatic rings.

  Schematically, this converts the ring from:

     ["A"]1:c:c:c:c:1

  to:

     ["A"]1-,:c=,:c-,:c=,:c-,:1

  Note that "A" is an A atom from a CTAB, not a SMARTS aliphatic query

  */

  // it would be simpler to use the substructure matcher for this, but we can't

  // use SubstructMatch in the core GraphMol lib

  if (!mol.getRingInfo()->isSymmSssr()) {

    MolOps::symmetrizeSSSR(mol);

  }

  for (auto ring : mol.getRingInfo()->atomRings()) {

    if (ring.size() != 5) {

      continue;

    }

    bool keepIt = true;

    size_t dummy = ring.size() + 1;

    for (size_t i = 0; i < ring.size(); ++i) {

      auto ai = ring[i];

      const auto atom = mol.getAtomWithIdx(ai);

      if (!atom->getIsAromatic()) {

        // we only do fully aromatic rings:

        keepIt = false;

        break;

      } else if (atom->getAtomicNum() == 0 && atom->hasQuery() &&

                 atom->getQuery()->getTypeLabel() == "A") {

        if (dummy >= ring.size()) {

          dummy = i;

        } else {

          // second dummy encountered, we won't do this ring.

          keepIt = false;

          break;

        }

      } else if (atom->getAtomicNum() != 6) {

        // we only do rings consisting solely of C and *

        keepIt = false;

        break;

      }

      // we can't handle rings that have query bonds already:

      auto oidx = ring[4];

      if (i > 0) {

        oidx = ring[i - 1];

      }

      auto bond = mol.getBondBetweenAtoms(ring[i], oidx);

      ASSERT_INVARIANT(bond, "expected bond not found");

      if (bond->hasQuery()) {

        keepIt = false;

        break;

      }

    }

    if (keepIt && dummy < ring.size()) {

      // we think about the 5-ring in three layers:

      //   layer 0: the dummy

      //   layer 1: the two atoms connected to the dummy

      //   layer 2: the two atoms not connected to the dummy

      auto l0 = ring[dummy];

      std::vector<int> l1;

      std::vector<int> l2;

      for (auto ai : ring) {

        if (ai == l0) {

          continue;

        } else if (mol.getBondBetweenAtoms(ai, l0)) {

          l1.push_back(ai);

        } else {

          l2.push_back(ai);

        }

      }

      ASSERT_INVARIANT(l1.size() == 2, "bad layer 1 size");

      ASSERT_INVARIANT(l2.size() == 2, "bad layer 2 size");

      QueryBond qbSingleAromatic;

      {

        BOND_OR_QUERY *q = new BOND_OR_QUERY;

        q->addChild(QueryBond::QUERYBOND_QUERY::CHILD_TYPE(

            makeBondOrderEqualsQuery(Bond::SINGLE)));

        q->addChild(QueryBond::QUERYBOND_QUERY::CHILD_TYPE(

            makeBondOrderEqualsQuery(Bond::AROMATIC)));

        q->setDescription("BondOr");

        qbSingleAromatic.setQuery(q);

      }

      QueryBond qbDoubleAromatic;

      {

        BOND_OR_QUERY *q = new BOND_OR_QUERY;

        q->addChild(QueryBond::QUERYBOND_QUERY::CHILD_TYPE(

            makeBondOrderEqualsQuery(Bond::DOUBLE)));

        q->addChild(QueryBond::QUERYBOND_QUERY::CHILD_TYPE(

            makeBondOrderEqualsQuery(Bond::AROMATIC)));

        q->setDescription("BondOr");

        qbDoubleAromatic.setQuery(q);

      }

      for (auto ai : l1) {

        // l0 - l1 bonds:

        auto bond = mol.getBondBetweenAtoms(ai, l0);

        ASSERT_INVARIANT(bond, "expected l0-l1 bond not found");

        mol.replaceBond(bond->getIdx(), &qbSingleAromatic);

        // l1 - l2 bonds:

        bond = mol.getBondBetweenAtoms(ai, l2[0]);

        if (!bond) {

          bond = mol.getBondBetweenAtoms(ai, l2[1]);

        }

        ASSERT_INVARIANT(bond, "expected l1-l2 bond not found");

        mol.replaceBond(bond->getIdx(), &qbDoubleAromatic);

      }

      // l2 - l2 bond:

      auto bond = mol.getBondBetweenAtoms(l2[0], l2[1]);

      ASSERT_INVARIANT(bond, "expected l2-l2 bond not found");

      mol.replaceBond(bond->getIdx(), &qbSingleAromatic);

    }

  }

}

}  // namespace

void parseAdjustQueryParametersFromJSON(MolOps::AdjustQueryParameters &p,

                                        const std::string &json) {

  PRECONDITION(!json.empty(), "empty JSON provided");

  std::istringstream ss;

  ss.str(json);

  boost::property_tree::ptree pt;

  boost::property_tree::read_json(ss, pt);

  p.adjustDegree = pt.get("adjustDegree", p.adjustDegree);

  p.adjustRingCount = pt.get("adjustRingCount", p.adjustRingCount);

  p.makeDummiesQueries = pt.get("makeDummiesQueries", p.makeDummiesQueries);

  p.aromatizeIfPossible = pt.get("aromatizeIfPossible", p.aromatizeIfPossible);

  p.makeBondsGeneric = pt.get("makeBondsGeneric", p.makeBondsGeneric);

  p.makeAtomsGeneric = pt.get("makeAtomsGeneric", p.makeAtomsGeneric);

  p.adjustHeavyDegree = pt.get("adjustHeavyDegree", p.adjustHeavyDegree);

  p.adjustRingChain = pt.get("adjustRingChain", p.adjustRingChain);

  p.useStereoCareForBonds =

      pt.get("useStereoCareForBonds", p.useStereoCareForBonds);

  p.adjustConjugatedFiveRings =

      pt.get("adjustConjugatedFiveRings", p.adjustConjugatedFiveRings);

  p.setMDLFiveRingAromaticity =

      pt.get("setMDLFiveRingAromaticity", p.setMDLFiveRingAromaticity);

  p.adjustSingleBondsToDegreeOneNeighbors =

      pt.get("adjustSingleBondsToDegreeOneNeighbors",

             p.adjustSingleBondsToDegreeOneNeighbors);

  p.adjustSingleBondsBetweenAromaticAtoms =

      pt.get("adjustSingleBondsBetweenAromaticAtoms",

             p.adjustSingleBondsBetweenAromaticAtoms);

  std::string which;

  which = boost::to_upper_copy<std::string>(pt.get("adjustDegreeFlags", ""));

  if (!which.empty()) {

    p.adjustDegreeFlags = parseWhichString(which);

  }

  which =

      boost::to_upper_copy<std::string>(pt.get("adjustHeavyDegreeFlags", ""));

  if (!which.empty()) {

    p.adjustHeavyDegreeFlags = parseWhichString(which);

  }

  which = boost::to_upper_copy<std::string>(pt.get("adjustRingCountFlags", ""));

  if (!which.empty()) {

    p.adjustRingCountFlags = parseWhichString(which);

  }

  which =

      boost::to_upper_copy<std::string>(pt.get("makeBondsGenericFlags", ""));

  if (!which.empty()) {

    p.makeBondsGenericFlags = parseWhichString(which);

  }

  which =

      boost::to_upper_copy<std::string>(pt.get("makeAtomsGenericFlags", ""));

  if (!which.empty()) {

    p.makeAtomsGenericFlags = parseWhichString(which);

  }

  which = boost::to_upper_copy<std::string>(pt.get("adjustRingChainFlags", ""));

  if (!which.empty()) {

    p.adjustRingChainFlags = parseWhichString(which);

  }

}  // namespace MolOps

ROMol *adjustQueryProperties(const ROMol &mol,

                             const AdjustQueryParameters *params) {

  auto *res = new RWMol(mol);

  try {

    adjustQueryProperties(*res, params);

  } catch (MolSanitizeException &se) {

    delete res;

    throw se;

  }

  return static_cast<ROMol *>(res);

}

void adjustQueryProperties(RWMol &mol, const AdjustQueryParameters *inParams) {

  AdjustQueryParameters params;

  if (inParams) {

    params = *inParams;

  }

  const auto ringInfo = mol.getRingInfo();

  if (params.aromatizeIfPossible) {

    unsigned int failed;

    sanitizeMol(mol, failed, SANITIZE_SYMMRINGS | SANITIZE_SETAROMATICITY);

  } else {

    if (!ringInfo->isSymmSssr()) {

      MolOps::symmetrizeSSSR(mol);

    }

  }

  QueryAtom qaTmpl;

  QueryBond qbTmpl;

  std::vector<int> origAtomicNums;

  origAtomicNums.reserve(mol.getNumAtoms());

  for (const auto atom : mol.atoms()) {

    origAtomicNums.push_back(atom->getAtomicNum());

  }

  if (params.makeAtomsGeneric) {

    for (unsigned int i = 0; i < mol.getNumAtoms(); ++i) {

      if (!((params.makeAtomsGenericFlags & ADJUST_IGNORECHAINS) &&

            !ringInfo->numAtomRings(i)) &&

          !((params.makeAtomsGenericFlags & ADJUST_IGNORERINGS) &&

            ringInfo->numAtomRings(i)) &&

          !((params.makeAtomsGenericFlags & ADJUST_IGNOREMAPPED) &&

            isMapped(mol.getAtomWithIdx(i)))) {

        qaTmpl.setQuery(makeAtomNullQuery());

        constexpr bool updateLabel = false;

        constexpr bool preserveProps = true;

        mol.replaceAtom(i, &qaTmpl, updateLabel, preserveProps);

      }

    }

  }  // end of makeAtomsGeneric

  if (params.makeBondsGeneric) {

    for (unsigned int i = 0; i < mol.getNumBonds(); ++i) {

      if (!((params.makeBondsGenericFlags & ADJUST_IGNORECHAINS) &&

            !ringInfo->numBondRings(i)) &&

          !((params.makeBondsGenericFlags & ADJUST_IGNORERINGS) &&

            ringInfo->numBondRings(i))) {

        qbTmpl.setQuery(makeBondNullQuery());

        constexpr bool preserveProps = true;

        mol.replaceBond(i, &qbTmpl, preserveProps);

      }

    }

  }  // end of makeBondsGeneric

  for (unsigned int i = 0; i < mol.getNumAtoms(); ++i) {

    auto *at = mol.getAtomWithIdx(i);

    // pull properties we need from the atom here, once we

    // create a query atom they may no longer be valid.

    auto nRings = ringInfo->numAtomRings(i);

    auto atomicNum = origAtomicNums[i];

    if (params.makeDummiesQueries && atomicNum == 0 && !at->hasQuery() &&

        !at->getIsotope()) {

      qaTmpl.setQuery(makeAtomNullQuery());

      constexpr bool updateLabel = false;

      constexpr bool preserveProps = true;

      mol.replaceAtom(i, &qaTmpl, updateLabel, preserveProps);

      at = mol.getAtomWithIdx(i);

    }  // end of makeDummiesQueries

    if (params.adjustDegree &&

        !((params.adjustDegreeFlags & ADJUST_IGNORECHAINS) && !nRings) &&

        !((params.adjustDegreeFlags & ADJUST_IGNORERINGS) && nRings) &&

        !((params.adjustDegreeFlags & ADJUST_IGNOREDUMMIES) && !atomicNum) &&

        !((params.adjustDegreeFlags & ADJUST_IGNORENONDUMMIES) && atomicNum) &&

        !((params.adjustDegreeFlags & ADJUST_IGNOREMAPPED) && isMapped(at))) {

      QueryAtom *qa;

      if (!at->hasQuery()) {

        QueryAtom atQueryAtom(*at);

        constexpr bool updateLabel = false;

        constexpr bool preserveProps = true;

        mol.replaceAtom(i, &atQueryAtom, updateLabel, preserveProps);

        qa = static_cast<QueryAtom *>(mol.getAtomWithIdx(i));

        at = static_cast<Atom *>(qa);

      } else {

        qa = static_cast<QueryAtom *>(at);

      }

      qa->expandQuery(makeAtomExplicitDegreeQuery(qa->getDegree()));

    }  // end of adjust degree

    if (params.adjustHeavyDegree &&

        !((params.adjustHeavyDegreeFlags & ADJUST_IGNORECHAINS) && !nRings) &&

        !((params.adjustHeavyDegreeFlags & ADJUST_IGNORERINGS) && nRings) &&

        !((params.adjustHeavyDegreeFlags & ADJUST_IGNOREDUMMIES) &&

          !atomicNum) &&

        !((params.adjustHeavyDegreeFlags & ADJUST_IGNORENONDUMMIES) &&

          atomicNum) &&

        !((params.adjustHeavyDegreeFlags & ADJUST_IGNOREMAPPED) &&

          isMapped(at))) {

      QueryAtom *qa;

      if (!at->hasQuery()) {

        QueryAtom atQueryAtom(*at);

        constexpr bool updateLabel = false;

        constexpr bool preserveProps = true;

        mol.replaceAtom(i, &atQueryAtom, updateLabel, preserveProps);

        qa = static_cast<QueryAtom *>(mol.getAtomWithIdx(i));

        at = static_cast<Atom *>(qa);

      } else {

        qa = static_cast<QueryAtom *>(at);

      }

      qa->expandQuery(makeAtomHeavyAtomDegreeQuery(qa->getTotalDegree() -

                                                   qa->getTotalNumHs(true)));

    }  // end of adjust heavy degree

    if (params.adjustRingCount &&

        !((params.adjustRingCountFlags & ADJUST_IGNORECHAINS) && !nRings) &&

        !((params.adjustRingCountFlags & ADJUST_IGNORERINGS) && nRings) &&

        !((params.adjustRingCountFlags & ADJUST_IGNOREDUMMIES) && !atomicNum) &&

        !((params.adjustRingCountFlags & ADJUST_IGNORENONDUMMIES) &&

          atomicNum) &&

        !((params.adjustRingCountFlags & ADJUST_IGNOREMAPPED) &&

          isMapped(at))) {

      QueryAtom *qa;

      if (!at->hasQuery()) {

        QueryAtom atQueryAtom(*at);

        constexpr bool updateLabel = false;

        constexpr bool preserveProps = true;

        mol.replaceAtom(i, &atQueryAtom, updateLabel, preserveProps);

        qa = static_cast<QueryAtom *>(mol.getAtomWithIdx(i));

        at = static_cast<Atom *>(qa);

      } else {

        qa = static_cast<QueryAtom *>(at);

      }

      qa->expandQuery(makeAtomInNRingsQuery(nRings));

    }  // end of adjust ring count

    if (params.adjustRingChain &&

        !((params.adjustRingChainFlags & ADJUST_IGNORECHAINS) && !nRings) &&

        !((params.adjustRingChainFlags & ADJUST_IGNORERINGS) && nRings) &&

        !((params.adjustRingChainFlags & ADJUST_IGNOREDUMMIES) && !atomicNum) &&

        !((params.adjustRingChainFlags & ADJUST_IGNORENONDUMMIES) &&

          atomicNum) &&

        !((params.adjustRingChainFlags & ADJUST_IGNOREMAPPED) &&

          isMapped(at))) {

      QueryAtom *qa;

      if (!at->hasQuery()) {

        QueryAtom atQueryAtom(*at);

        constexpr bool updateLabel = false;

        constexpr bool preserveProps = true;

        mol.replaceAtom(i, &atQueryAtom, updateLabel, preserveProps);

        qa = static_cast<QueryAtom *>(mol.getAtomWithIdx(i));

        at = static_cast<Atom *>(qa);

      } else {

        qa = static_cast<QueryAtom *>(at);

      }

      ATOM_EQUALS_QUERY *nq = makeAtomInRingQuery();

      if (!nRings) {

        nq->setNegation(true);

      }

      qa->expandQuery(nq);

    }  // end of adjust ring chain

  }  // end of loop over atoms

  if (params.useStereoCareForBonds) {

    for (auto bnd : mol.bonds()) {

      if (bnd->getBondType() == Bond::BondType::DOUBLE) {

        if (bnd->getStereo() > Bond::BondStereo::STEREOANY) {

          bool preserve = false;

          int val = 0;

          // is stereoCare set on the bond or both atoms?

          if (bnd->getPropIfPresent(common_properties::molStereoCare, val) &&

              val) {

            preserve = true;

          }

          if (!preserve) {

            bnd->setStereo(Bond::BondStereo::STEREONONE);

          }

        }

      }

    }

  }

  if (params.setMDLFiveRingAromaticity) {

    setMDLAromaticity(mol);

  }

  if (params.adjustConjugatedFiveRings) {

    adjustConjugatedFiveRings(mol);

  }

  if (params.adjustSingleBondsToDegreeOneNeighbors ||

      params.adjustSingleBondsBetweenAromaticAtoms) {

    adjustSingleBondsFromAromaticAtoms(

        mol, params.adjustSingleBondsToDegreeOneNeighbors,

        params.adjustSingleBondsBetweenAromaticAtoms);

  }

  if (params.setMDLFiveRingAromaticity) {

    for (auto atom : mol.atoms()) {

      atom->clearProp(conjugatedOrAromatic);

    }

  }

}

}  // namespace MolOps

}  // namespace RDKit