// ******************************************************************************
   //
   // Title:       Force Field X.
   // Description: Force Field X - Software for Molecular Biophysics.
   // Copyright:   Copyright (c) Michael J. Schnieders 2001-2023.
   //
   // This file is part of Force Field X.
   //
   // Force Field X is free software; you can redistribute it and/or modify it
  // under the terms of the GNU General Public License version 3 as published by
  // the Free Software Foundation.
  //
  // Force Field X 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
  // Force Field X; if not, write to the Free Software Foundation, Inc., 59 Temple
  // Place, Suite 330, Boston, MA 02111-1307 USA
  //
  // Linking this library statically or dynamically with other modules is making a
  // combined work based on this library. Thus, the terms and conditions of the
  // GNU General Public License cover the whole combination.
  //
  // As a special exception, the copyright holders of this library give you
  // permission to link this library with independent modules to produce an
  // executable, regardless of the license terms of these independent modules, and
  // to copy and distribute the resulting executable under terms of your choice,
  // provided that you also meet, for each linked independent module, the terms
  // and conditions of the license of that module. An independent module is a
  // module which is not derived from or based on this library. If you modify this
  // library, you may extend this exception to your version of the library, but
  // you are not obligated to do so. If you do not wish to do so, delete this
  // exception statement from your version.
  //
  // ******************************************************************************
  package ffx.potential.parameters;
  
  import static ffx.potential.parameters.ForceField.ForceFieldType.ATOM;
  import static ffx.utilities.KeywordGroup.PotentialFunctionParameter;
  import static java.lang.Double.parseDouble;
  import static java.lang.Integer.parseInt;
  import static java.lang.String.format;
  import static org.apache.commons.math3.util.FastMath.abs;
  
  import ffx.utilities.FFXKeyword;
  import java.util.Comparator;
  import java.util.Objects;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  /**
   * The AtomType class represents one molecular mechanics atom type.
   *
   * @author Michael J. Schnieders
   * @since 1.0
   */
  @FFXKeyword(name = "atom", clazz = String.class, keywordGroup = PotentialFunctionParameter, description =
      "[2 integers, name, quoted string, integer, real and integer] "
          + "Provides the values needed to define a single force field atom type. "
          + "The first two integer modifiers denote the atom type and class numbers. "
          + "If the type and class are identical, only a single integer value is required. "
          + "The next modifier is a three-character atom name, followed by an 24-character or less atom description contained in single quotes. "
          + "The next two modifiers are the atomic number and atomic mass. "
          + "The final integer modifier is the \"valence\" of the atom, defined as the expected number of attached or bonded atoms.")
  public final class AtomType extends BaseType implements Comparator<String> {
  
    /** A Logger for the AngleType class. */
    private static final Logger logger = Logger.getLogger(AtomType.class.getName());
    /** Short name (ie CH3/CH2 etc). */
    public final String name;
    /** Description of the atom's bonding environment. */
    public final String environment;
    /** Atomic Number. */
    public final int atomicNumber;
    /**
     * Atomic weight. "An atomic weight (relative atomic weight) of an element from a specified source
     * is the ratio of the average atomicWeight per atom of the element to 1/12 of the atomicWeight of
     * an atom of 12C"
     */
    public final double atomicWeight;
    /** Valence number for this type. */
    public final int valence;
    /** Atom type. */
    public int type;
    /** Atom class. */
    public int atomClass;
  
    /**
     * AtomType Constructor.
     *
     * @param type int
     * @param atomClass int
     * @param name String
     * @param environment String
     * @param atomicNumber int
     * @param atomicWeight double
     * @param valence int
    */
   public AtomType(int type, int atomClass, String name, String environment, int atomicNumber,
       double atomicWeight, int valence) {
     super(ATOM, Integer.toString(type));
     this.type = type;
     this.atomClass = atomClass;
     this.name = name;
     this.environment = environment;
     this.atomicNumber = atomicNumber;
     this.atomicWeight = atomicWeight;
     this.valence = valence;
   }
 
   /**
    * Construct an AtomType from an input string.
    *
    * @param input The overall input String.
    * @param tokens The input String tokenized.
    * @return an AtomType instance.
    */
   public static AtomType parse(String input, String[] tokens) {
     if (tokens.length < 7) {
       logger.log(Level.WARNING, "Invalid ATOM type:\n{0}", input);
     } else {
       try {
         int index = 1;
         // Atom Type
         int type = parseInt(tokens[index++]);
         // Atom Class
         int atomClass;
         // The following try/catch checks for one of the following two cases:
         //
         // NUMBER TYPE CLASS IDENTIFIER ... (example is OPLS-AA)
         // vs.
         // NUMBER TYPE IDENTIFIER ... (example is OPLS-UA)
         //
         // If there is no atom class, the exception will be caught
         // and the atomClass field will remain equal to null.
         try {
           atomClass = parseInt(tokens[index]);
           // If the parseInt succeeds, this force field has atom classes.
           index++;
         } catch (NumberFormatException e) {
           // Some force fields do not use atom classes.
           atomClass = -1;
         }
         // Name
         String name = tokens[index].intern();
         // The "environment" string may contain spaces,
         // and is therefore surrounded in quotes located at "first" and
         // "last".
         int first = input.indexOf("\"");
         int last = input.lastIndexOf("\"");
         if (first >= last) {
           logger.log(Level.WARNING, "Invalid ATOM type:\n{0}", input);
           return null;
         }
         // Environment
         String environment = input.substring(first, last + 1).intern();
         // Shrink the tokens array to only include entries
         // after the environment field.
         tokens = input.substring(last + 1).trim().split(" +");
         index = 0;
         // Atomic Number
         int atomicNumber = parseInt(tokens[index++]);
         // Atomic Mass
         double mass = parseDouble(tokens[index++]);
         // Hybridization
         int hybridization = parseInt(tokens[index]);
 
         AtomType atomType = new AtomType(type, atomClass, name, environment, atomicNumber, mass,
             hybridization);
         if (!checkAtomicNumberAndMass(atomicNumber, mass)) {
           // Ignore united atom (UA) entries.
           if (!environment.toUpperCase().contains("UA")) {
             logger.warning(" Atomic number and weight do not agree:\n" + atomType);
           }
         }
         return atomType;
       } catch (NumberFormatException e) {
         String message = "Exception parsing AtomType:\n" + input + "\n";
         logger.log(Level.SEVERE, message, e);
       }
     }
     return null;
   }
 
   /** {@inheritDoc} */
   @Override
   public int compare(String s1, String s2) {
     int t1 = parseInt(s1);
     int t2 = parseInt(s2);
     return Integer.compare(t1, t2);
   }
 
   /** {@inheritDoc} */
   @Override
   public boolean equals(Object o) {
     if (this == o) {
       return true;
     }
     if (o == null || getClass() != o.getClass()) {
       return false;
     }
     AtomType atomType = (AtomType) o;
     return atomType.type == this.type;
   }
 
   /** {@inheritDoc} */
   @Override
   public int hashCode() {
     return Objects.hash(type);
   }
 
   /**
    * {@inheritDoc}
    *
    * <p>Nicely formatted atom type string.
    */
   @Override
   public String toString() {
     String s;
     if (atomClass >= 0) {
       s = format("atom  %5d  %5d  %-4s  %-25s  %3d  %8.4f  %d", type, atomClass, name, environment,
           atomicNumber, atomicWeight, valence);
     } else {
       s = format("atom  %5d  %-4s  %-25s  %3d  %8.4f  %d", type, name, environment, atomicNumber,
           atomicWeight, valence);
     }
     return s;
   }
 
   /**
    * incrementClassAndType
    *
    * @param classIncrement The value to increment the atom class by.
    * @param typeIncrement The value to increment the atom type by.
    */
   void incrementClassAndType(int classIncrement, int typeIncrement) {
     atomClass += classIncrement;
     type += typeIncrement;
     setKey(Integer.toString(type));
   }
 
   /**
    * Check if the supplied atomic mass is within 0.1 AMU of the IUPAC value for the given atomic
    * number.
    * <p>
    * For atomic numbers outside the range 1 to 118, true always is returned.
    *
    * @param atomicNumber The atomic number.
    * @param mass The atomic mass.
    * @return True if the given mass is within the given tolerance of the IUPAC value for the atomic
    *     number.
    */
   public static boolean checkAtomicNumberAndMass(int atomicNumber, double mass) {
     return checkAtomicNumberAndMass(atomicNumber, mass, 0.1);
   }
 
   /**
    * Check if the supplied atomic mass is within the supplied tolerance (in AMU) of the IUPAC value
    * for the given atomic number.
    * <p>
    * For atomic numbers outside the range 1 to 118, true always is returned.
    *
    * @param atomicNumber The atomic number.
    * @param mass The atomic mass.
    * @param tolerance The error tolerance in AMU.
    * @return True if the given mass is within the given tolerance of the IUPAC value for the atomic
    *     number.
    */
   public static boolean checkAtomicNumberAndMass(int atomicNumber, double mass, double tolerance) {
     // Ignore atomic numbers outside the range 1 to 118.
     if (atomicNumber == 0 || atomicNumber >= atomicMass.length) {
       return true;
     }
 
     double expected = atomicMass[atomicNumber - 1];
     return abs(expected - mass) < tolerance;
   }
 
   /**
    * <a href="https://iupac.qmul.ac.uk/AtWt">IUPAC Commission</a> on Isotopic Abundances and Atomic
    * Weights.
    * Retrieved on 1/24/22.
    */
   private static final double[] atomicMass = { /* H Hydrogen */  1.008,
       /* 2 He Helium */ 4.002,
       /* 3 Li Lithium */ 6.94,
       /* 4 Be Beryllium */ 9.012,
       /* 5 B Boron */ 10.81,
       /* 6 C Carbon */ 12.011,
       /* 7 N Nitrogen */ 14.007,
       /* 8 O Oxygen */ 15.999,
       /* 9 F Fluorine */ 18.998,
       /* 10 Ne Neon */ 20.1797,
       /* 11 Na Sodium */ 22.989,
       /* 12 Mg Magnesium */ 24.305,
       /* 13 Al Aluminium */ 26.981,
       /* 14 Si Silicon */ 28.085,
       /* 15 P Phosphorus */ 30.973,
       /* 16 S Sulfur */ 32.06,
       /* 17 Cl Chlorine */ 35.45,
       /* 18 Ar Argon */ 39.948,
       /* 19 K Potassium */ 39.0983,
       /* 20 Ca Calcium */ 40.078,
       /* 21 Sc Scandium */ 44.955,
       /* 22 Ti Titanium */ 47.867,
       /* 23 V Vanadium */ 50.9415,
       /* 24 Cr Chromium */ 51.9961,
       /* 25 Mn Manganese */ 54.938,
       /* 26 Fe Iron */ 55.845,
       /* 27 Co Cobalt */ 58.933,
       /* 28 Ni Nickel */ 58.6934,
       /* 29 Cu Copper */ 63.546,
       /* 30 Zn Zinc */ 65.38,
       /* 31 Ga Gallium */ 69.723,
       /* 32 Ge Germanium */ 72.630,
       /* 33 As Arsenic */ 74.921,
       /* 34 Se Selenium */ 78.971,
       /* 35 Br Bromine */ 79.904,
       /* 36 Kr Krypton */ 83.798,
       /* 37 Rb Rubidium */ 85.4678,
       /* 38 Sr Strontium */ 87.62,
       /* 39 Y Yttrium */ 88.905,
       /* 40 Zr Zirconium */ 91.224,
       /* 41 Nb Niobium */ 92.906,
       /* 42 Mo Molybdenum */ 95.95,
       /* 43 Tc Technetium */ 97.0,
       /* 44 Ru Ruthenium */ 101.07,
       /* 45 Rh Rhodium */ 102.905,
       /* 46 Pd Palladium */ 106.42,
       /* 47 Ag Silver */ 107.8682,
       /* 48 Cd Cadmium */ 112.414,
       /* 49 In Indium */ 114.818,
       /* 50 Sn Tin */ 118.710,
       /* 51 Sb Antimony */ 121.760,
       /* 52 Te Tellurium */ 127.60,
       /* 53 I Iodine */ 126.904,
       /* 54 Xe Xenon */ 131.293,
       /* 55 Cs Caesium */ 132.905,
       /* 56 Ba Barium */ 137.327,
       /* 57 La Lanthanum */ 138.905,
       /* 58 Ce Cerium */ 140.116,
       /* 59 Pr Praseodymium */ 140.907,
       /* 60 Nd Neodymium */ 144.242,
       /* 61 Pm Promethium */ 145.0,
       /* 62 Sm Samarium */ 150.36,
       /* 63 Eu Europium */ 151.964,
       /* 64 Gd Gadolinium */ 157.25,
       /* 65 Tb Terbium */ 158.925,
       /* 66 Dy Dysprosium */ 162.500,
       /* 67 Ho Holmium */ 164.930,
       /* 68 Er Erbium */ 167.259,
       /* 69 Tm Thulium */ 168.934,
       /* 70 Yb Ytterbium */ 173.045,
       /* 71 Lu Lutetium */ 174.9668,
       /* 72 Hf Hafnium */ 178.486,
       /* 73 Ta Tantalum */ 180.947,
       /* 74 W Tungsten */ 183.84,
       /* 75 Re Rhenium */ 186.207,
       /* 76 Os Osmium */ 190.23,
       /* 77 Ir Iridium */ 192.217,
       /* 78 Pt Platinum */ 195.084,
       /* 79 Au Gold */ 196.966,
       /* 80 Hg Mercury */ 200.592,
       /* 81 Tl Thallium */ 204.38,
       /* 82 Pb Lead */ 207.2,
       /* 83 Bi Bismuth */ 208.980,
       /* 84 Po Polonium */ 209.0,
       /* 85 At Astatine */ 210.0,
       /* 86 Rn Radon */ 222.0,
       /* 87 Fr Francium */ 223.0,
       /* 88 Ra Radium */ 226.0,
       /* 89 Ac Actinium */ 227.0,
       /* 90 Th Thorium */ 232.0377,
       /* 91 Pa Protactinium */ 231.035,
       /* 92 U Uranium */ 238.028,
       /* 93 Np Neptunium */ 237.0,
       /* 94 Pu Plutonium */ 244.0,
       /* 95 Am Americium */ 243.0,
       /* 96 Cm Curium */ 247.0,
       /* 97 Bk Berkelium */ 247.0,
       /* 98 Cf Californium */ 251.0,
       /* 99 Es Einsteinium */ 252.0,
       /* 100 Fm Fermium */ 257.0,
       /* 101 Md Mendelevium */ 258.0,
       /* 102 No Nobelium */ 259.0,
       /* 103 Lr Lawrencium */ 262.0,
       /* 104 Rf Rutherfordium */ 267.0,
       /* 105 Db Dubnium */ 270.0,
       /* 106 Sg Seaborgium */ 269.0,
       /* 107 Bh Bohrium */ 270.0,
       /* 108 Hs Hassium */ 270.0,
       /* 109 Mt Meitnerium */ 278.0,
       /* 110 Ds Darmstadtium */ 281.0,
       /* 111 Rg Roentgenium */ 281.0,
       /* 112 Cn Copernicium */ 285.0,
       /* 113 Nh Nihonium */ 286.0,
       /* 114 Fl Flerovium */ 289.0,
       /* 115 Mc Moscovium */ 289.0,
       /* 116 Lv Livermorium */ 293.0,
       /* 117 Ts Tennessine */ 293.0,
       /* 118 Og Oganesson */ 294.0};
 }