// ******************************************************************************
   //
   // 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.algorithms.cli;
  
  import ffx.algorithms.AlgorithmFunctions;
  import ffx.algorithms.AlgorithmListener;
  import ffx.algorithms.AlgorithmUtils;
  import ffx.crystal.Crystal;
  import ffx.numerics.Potential;
  import ffx.potential.MolecularAssembly;
  import ffx.utilities.FFXCommand;
  import ffx.utilities.FFXBinding;
  import org.apache.commons.lang3.Strings;
  
  import javax.annotation.Nullable;
  import java.io.File;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  import java.util.Objects;
  import java.util.stream.Collectors;
  
  import static java.lang.String.format;
  
  /**
   * Base class for scripts in the Algorithms package, providing some key functions.
   *
   * @author Michael J. Schnieders
   * @since 1.0
   */
  public class AlgorithmsCommand extends FFXCommand {
  
    /**
     * An instance of AlgorithmFunctions passed into the current context.
     */
    public AlgorithmFunctions algorithmFunctions;
  
    /**
     * An active MolecularAssembly passed into the current context or loaded by the Script from a file
     * argument.
     */
    public MolecularAssembly activeAssembly;
  
    /**
     * An instance of the AlgorithmListener interface.
     */
    public AlgorithmListener algorithmListener;
  
    /**
     * The directory in which to place output files. Mostly for tests.
     */
    protected File baseDir;
  
    public AlgorithmsCommand() {
      super();
    }
  
    public AlgorithmsCommand(FFXBinding binding) {
      super(binding);
    }
  
    /**
     * Create a Script using the supplied command line arguments.
     *
    * @param args The command line arguments.
    */
   public AlgorithmsCommand(String[] args) {
     super(args);
   }
 
   /**
    * Reclaims resources associated with all Potential objects associated with this script.
    *
    * @return If all Potentials had resources reclaimed.
    */
   public boolean destroyPotentials() {
     boolean allSucceeded = true;
     for (Potential potent : getPotentials()) {
       logger.fine(format(" Potential %s is being destroyed. ", potent));
       allSucceeded = allSucceeded && potent.destroy();
     }
     return allSucceeded;
   }
 
   /**
    * Returns a List of all Potential objects associated with this script.
    *
    * @return All Potentials. Sometimes empty, never null.
    */
   public List<Potential> getPotentials() {
     List<Potential> potentials = new ArrayList<>();
     if (activeAssembly != null && activeAssembly.getPotentialEnergy() != null) {
       potentials.add(activeAssembly.getPotentialEnergy());
     }
     return potentials;
   }
 
   /**
    * Returns a List of all Potential objects from the supplied MolecularAssembly array.
    * Should be written to tolerate nulls, as many tests run help() and exit without
    * instantiating their Potentials.
    *
    * @param assemblies An array of MolecularAssembly instances.
    * @return All Potentials. Sometimes empty, never null.
    */
   public List<Potential> getPotentialsFromAssemblies(MolecularAssembly[] assemblies) {
     if (assemblies == null) {
       return new ArrayList<>();
     }
     return Arrays.stream(assemblies)
         .filter(Objects::nonNull)
         .map(MolecularAssembly::getPotentialEnergy)
         .filter(Objects::nonNull)
         .collect(Collectors.toList());
   }
 
   /**
    * {@inheritDoc}
    *
    * <p>Execute the BaseScript init method, then load algorithm functions.
    */
   @Override
   public boolean init() {
     if (!super.init()) {
       return false;
     }
 
     if (binding.hasVariable("functions")) {
       algorithmFunctions = (AlgorithmFunctions) binding.getVariable("functions");
     } else {
       algorithmFunctions = new AlgorithmUtils();
       binding.setVariable("functions", algorithmFunctions);
     }
 
     activeAssembly = null;
     if (binding.hasVariable("active")) {
       activeAssembly = (MolecularAssembly) binding.getVariable("active");
     }
 
     algorithmListener = null;
     if (binding.hasVariable("listener")) {
       algorithmListener = (AlgorithmListener) binding.getVariable("listener");
     }
 
     if (binding.hasVariable("baseDir")) {
       baseDir = (File) binding.getVariable("baseDir");
     }
 
     return true;
   }
 
   /**
    * Sets the directory this script should save files to. Mostly used for tests.
    *
    * @param baseDir Directory to save output to.
    */
   public void setBaseDir(File baseDir) {
     this.baseDir = baseDir;
   }
 
   /**
    * Return a File in the base directory with the same name as the input file.
    * <p>
    * This will just be the original file if baseDir was never set, which is the case for production
    * runs.
    *
    * @param file File to find a save location for.
    * @return Returns a File in the base directory with the same name as the input file.
    */
   protected File saveDirFile(File file) {
     if (baseDir == null || !baseDir.exists() || !baseDir.isDirectory() || !baseDir.canWrite()) {
       return file;
     } else {
       String baseName = file.getName();
       String newName = baseDir.getAbsolutePath() + File.separator + baseName;
       return new File(newName);
     }
   }
 
   /**
    * If a filename is supplied, open it and return the MolecularAssembly. Otherwise, the current
    * activeAssembly is returned (which may be null).
    *
    * @param filename Filename to open.
    * @return The active assembly.
    */
   public MolecularAssembly getActiveAssembly(@Nullable String filename) {
     if (filename != null) {
       // Open the supplied file.
       MolecularAssembly[] assemblies = {algorithmFunctions.open(filename)};
       activeAssembly = assemblies[0];
     }
     return activeAssembly;
   }
 
   /**
    * If a filename is supplied, open it and return the MolecularAssemblies. Otherwise, the current
    * activeAssembly is returned (which may be null).
    *
    * @param filename Filename to open.
    * @return The active assemblies.
    */
   public MolecularAssembly[] getActiveAssemblies(@Nullable String filename) {
     MolecularAssembly[] assemblies;
     if (filename != null) {
       // Open the supplied file.
       assemblies = algorithmFunctions.openAll(filename);
       activeAssembly = assemblies[0];
       return assemblies;
     } else {
       assemblies = new MolecularAssembly[]{activeAssembly};
     }
     return assemblies;
   }
 
   /**
    * Update the title line of the structure with Energy and Density.
    *
    * @param energy Newly minimized energy value.
    */
   public void updateTitle(double energy) {
     // Replace existing energy and density label if present
     String oldName = activeAssembly.getName();
     Crystal crystal = activeAssembly.getCrystal();
     if (crystal != null && !crystal.aperiodic()) {
       double density = crystal.getDensity(activeAssembly.getMass());
       if (Strings.CI.contains(oldName, "Energy:")
           || Strings.CI.contains(oldName, "Density:")) {
         String[] tokens = oldName.trim().split(" +");
         int numTokens = tokens.length;
         // The first element should always be the number of atoms in XYZ.
         StringBuilder sb = new StringBuilder();
         for (int i = 0; i < numTokens; i++) {
           if (Strings.CI.contains(tokens[i], "Energy:")) {
             // i++ skips the current entry (value associated with "Energy")
             tokens[i++] = Double.toString(energy);
           } else if (Strings.CI.contains(tokens[i], "Density:")) {
             // i++ skips the current entry (value associated with "Density")
             tokens[i++] = Double.toString(density);
           } else {
             // Accrue previous name.
             sb.append(tokens[i]).append(" ");
           }
         }
         // Opted to add energy/density after to preserve formatting.
         activeAssembly.setName(format("%s Energy: %9.4f Density: %9.4f",
             sb, energy, density));
       } else {
         // Append energy and density to structure name (line 1 of XYZ).
         activeAssembly.setName(format("%s Energy: %9.4f Density: %9.4f",
             oldName, energy, density));
       }
     } else {
       if (Strings.CI.contains(oldName, "Energy:")) {
         String[] tokens = oldName.trim().split(" +");
         int numTokens = tokens.length;
         // The first element should always be number of atoms in XYZ.
         StringBuilder sb = new StringBuilder();
         for (int i = 0; i < numTokens; i++) {
           if (Strings.CI.contains(tokens[i], "Energy:")) {
             // i++ skips the current entry (value associated with "Energy")
             tokens[i++] = Double.toString(energy);
           } else {
             // Accrue previous name.
             sb.append(tokens[i]).append(" ");
           }
         }
         // Opted to add energy/density after to preserve formatting.
         activeAssembly.setName(format("%s Energy: %9.4f", sb, energy));
       } else {
         // Append energy and density to the structure name (line 1 of XYZ).
         activeAssembly.setName(format("%s Energy: %9.4f", oldName, energy));
       }
     }
   }
 }