// ******************************************************************************
   //
   // Title:       Force Field X.
   // Description: Force Field X - Software for Molecular Biophysics.
   // Copyright:   Copyright (c) Michael J. Schnieders 2001-2025.
   //
   // 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.cli;
  
  import ffx.potential.MolecularAssembly;
  import ffx.potential.bonded.Atom;
  import ffx.potential.bonded.Residue;
  import picocli.CommandLine.ArgGroup;
  import picocli.CommandLine.Option;
  
  import javax.annotation.Nonnull;
  import javax.annotation.Nullable;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.function.BiConsumer;
  import java.util.logging.Logger;
  
  import static ffx.utilities.StringUtils.parseAtomRanges;
  import static ffx.utilities.StringUtils.parseResidueString;
  
  /**
   * Represents command line options for scripts that support atom selections.
   *
   * @author Michael J. Schnieders
   * @since 1.0
   */
  public class AtomSelectionOptions {
  
    private static final Logger logger = Logger.getLogger(AtomSelectionOptions.class.getName());
  
    /**
     * The ArgGroup keeps the Atom Selection Options together when printing help.
     */
    @ArgGroup(heading = "%n Atom Selection Options%n", validate = false)
    private final AtomSelectionOptionGroup group = new AtomSelectionOptionGroup();
  
    public static void actOnAtoms(@Nonnull MolecularAssembly assembly, @Nullable String selection,
                                  @Nonnull BiConsumer<Atom, Boolean> action, @Nonnull String description) {
      if (selection == null || selection.equalsIgnoreCase("")) {
        // Empty or null string -- no changes.
        return;
      }
  
      Atom[] atoms = assembly.getAtomArray();
  
      // No atoms selected.
      if (selection.equalsIgnoreCase("NONE")) {
        for (Atom atom : atoms) {
          action.accept(atom, false);
        }
        logger.info(" No atoms are " + description + ".\n");
        return;
      }
  
      // All atoms selected
      if (selection.equalsIgnoreCase("ALL")) {
        for (Atom atom : atoms) {
          action.accept(atom, true);
        }
        logger.info(" All atoms are " + description + ".\n");
        return;
      }
  
      // A range(s) of atoms are active.
     int nAtoms = atoms.length;
     for (Atom atom : atoms) {
       action.accept(atom, false);
     }
 
     List<Integer> atomRanges = parseAtomRanges(description, selection, nAtoms);
     for (int i : atomRanges) {
       action.accept(atoms[i], true);
     }
     logger.info("\n " + description + " atoms set to: " + selection);
 
   }
 
   public static void actOnResidueAtoms(@Nonnull MolecularAssembly assembly, @Nullable String selection,
                                 @Nonnull BiConsumer<Atom, Boolean> action, String description) {
     if (selection == null || selection.equalsIgnoreCase("")) {
       // Empty or null string -- no changes.
       return;
     }
 
     Atom[] atoms = assembly.getAtomArray();
 
     // No atoms selected.
     if (selection.equalsIgnoreCase("NONE")) {
       for (Atom atom : atoms) {
         action.accept(atom, false);
       }
       logger.info(" No residues are " + description + ".\n");
       return;
     }
 
     // All atoms selected
     if (selection.equalsIgnoreCase("ALL")) {
       for (Atom atom : atoms) {
         action.accept(atom, true);
       }
       logger.info(" All residues (and atoms) are " + description + ".\n");
       return;
     }
 
     // A subset of atoms is active.
     for (Atom atom : atoms) {
       action.accept(atom, false);
     }
 
     // String for logging the selected residues and atoms
     StringBuilder seleRes = new StringBuilder();
     StringBuilder seleAtoms = new StringBuilder();
 
     int nResidues = assembly.getResidueList().size();
     List<String> resList = parseResidueString(description, selection, nResidues);
     assert resList.size() % 2 == 0;
 
     for (int i=0; i < resList.size(); i=i+2) {
       String chain = resList.get(i);
       int resid = Integer.parseInt(resList.get(i+1));
 
       List<Atom> atomList = new ArrayList<>();
 
       Residue res = assembly.getChain(chain).getResidue(resid);
       seleRes.append(res.toFormattedString(true, true)).append(",");
       if (res.getResidueType() == Residue.ResidueType.AA) {
         atomList = res.getSideChainAtoms(); // use side chain atoms if for amino acids
       } else if (res.getResidueType() == Residue.ResidueType.NA) {
         atomList = res.getBackboneAtoms(); // use 'backbone' atoms which correspond to the nucleobase for nucleic acids
       }
 
       // Apply desired function for selected atoms in the selected residues
       for (Atom atom : atomList) {
         seleAtoms.append(atom.getIndex()).append(",");
         action.accept(atom, true);
       }
     }
 
     logger.info("\n " + description + " residues are: " + seleRes.substring(0, seleRes.length()-1));
     logger.info(" " + description + " atoms set to: " + seleAtoms.substring(0, seleAtoms.length()-1));
   }
 
   /**
    * --aa or --activeAtoms Ranges of active atoms [NONE, ALL, Range(s): 1-3,6-N].
    *
    * @return Returns active atoms.
    */
   public String getActiveAtoms() {
     return group.activeAtoms;
   }
 
   /**
    * Set active atoms for a MolecularAssembly.
    *
    * @param molecularAssembly a {@link ffx.potential.MolecularAssembly} object.
    */
   public void setActiveAtoms(MolecularAssembly molecularAssembly) {
     // First, evaluate the inactive atom selection.
     setInactive(molecularAssembly);
 
     // Second, evaluate the active atom selection, which takes precedence over the inactive flag.
     setActive(molecularAssembly);
   }
 
   /**
    * --ia or --inactiveAtoms Ranges of inactive atoms [NONE, ALL, Range(s): 1-3,6-N].
    *
    * @return Returns inactive atoms.
    */
   public String getInactiveAtoms() {
     return group.inactiveAtoms;
   }
 
   /**
    * Check if either the active or inactive atom selection is set.
    *
    * @return True if one of the fields is not empty.
    */
   public boolean isAtomSelectionSet() {
     if (group.activeAtoms != null && !group.activeAtoms.isEmpty()) {
       return true;
     }
     return group.inactiveAtoms != null && !group.inactiveAtoms.isEmpty();
   }
 
   private void setInactive(MolecularAssembly assembly) {
     actOnAtoms(assembly, getInactiveAtoms(), (Atom a, Boolean b) -> a.setActive(!b), "Inactive");
   }
 
   private void setActive(MolecularAssembly assembly) {
     actOnAtoms(assembly, getActiveAtoms(), Atom::setActive, "Active");
   }
 
   /**
    * Collection of Atom Selection Options.
    */
   private static class AtomSelectionOptionGroup {
 
     /**
      * --aa or --activeAtoms Ranges of active atoms [NONE, ALL, Range(s): 1-3,6-N].
      */
     @Option(names = {"--aa",
         "--active"}, paramLabel = "<selection>", defaultValue = "",
         description = "Ranges of active atoms [NONE, ALL, Range(s): 1-3,6-N].")
     public String activeAtoms = "";
 
     /**
      * --ia or --inactiveAtoms Ranges of inactive atoms [NONE, ALL, Range(s): 1-3,6-N].
      */
     @Option(names = {"--ia",
         "--inactive"}, paramLabel = "<selection>", defaultValue = "",
         description = "Ranges of inactive atoms [NONE, ALL, Range(s): 1-3,6-N].")
     public String inactiveAtoms = "";
   }
 }