/*
 *                    BioJava development code
 *
 * This code may be freely distributed and modified under the
 * terms of the GNU Lesser General Public Licence.  This should
 * be distributed with the code.  If you do not have a copy,
 * see:
 *
 *      http://www.gnu.org/copyleft/lesser.html
 *
 * Copyright for this code is held jointly by the individual
 * authors.  These should be listed in @author doc comments.
 *
 * For more information on the BioJava project and its aims,
 * or to join the biojava-l mailing list, visit the home page
 * at:
 *
 *      http://www.biojava.org/
 *
 */
package org.biojava.nbio.structure.cluster;

import org.biojava.nbio.structure.align.ce.CeMain;

import java.io.Serializable;

/**
 * The SubunitClustererParameters specifies the options used for the clustering
 * of the subunits in structures using the {@link SubunitClusterer}.
 * 
 * @author Peter Rose
 * @author Aleix Lafita
 * @since 5.0.0
 *
 */
public class SubunitClustererParameters implements Serializable {

        private static final long serialVersionUID = 1L;

        private int minimumSequenceLength = 20;
        private int absoluteMinimumSequenceLength = 5;
        private double minimumSequenceLengthFraction = 0.75;

        private boolean useGlobalMetrics;
        private double sequenceIdentityThreshold;
        private double sequenceCoverageThreshold = 0.75;

        private double rmsdThreshold = 3.0;
        private double structureCoverageThreshold = 0.75;
        private double tmThreshold = 0.5;

        private SubunitClustererMethod clustererMethod = SubunitClustererMethod.SEQUENCE_STRUCTURE;

        private String superpositionAlgorithm = CeMain.algorithmName;
        private boolean optimizeAlignment = true;

        private boolean useSequenceCoverage;
        private boolean useRMSD;
        private boolean useStructureCoverage;
        private boolean useTMScore;

        private boolean internalSymmetry = false;

        /**
         * Subunits aligned with these or better scores will be considered "identical".
         */
        private static final double hcSequenceIdentityLocal = 0.95;
        private static final double hcSequenceCoverageLocal = 0.75;
        private static final double hcSequenceIdentityGlobal = 0.85;

        /**
         * "Local" metrics are scoring
         * SubunitClustererMethod.SEQUENCE: sequence identity of a local alignment
         *                                  (normalised by the number of aligned residues)
         *                                  sequence coverage of the alignment
         *                                  (normalised by the length of the longer sequence)
         * SubunitClustererMethod.STRUCTURE: RMSD of the aligned substructures
         *                                   and structure coverage of the alignment
         *                                   (normalised by the length of the larger structure)
         * Two thresholds for each method are required.
         *
         * "Global" metrics are scoring
         * SubunitClustererMethod.SEQUENCE: sequence identity of a global alignment
         *                                  (normalised by the length of the alignment)
         * SubunitClustererMethod.STRUCTURE: TMScore of the aligned structures
         *                                  (normalised by the length of the larger structure)
         * One threshold for each method is required.
         *
         */
        public SubunitClustererParameters(boolean useGlobalMetrics) {
                this.useGlobalMetrics = useGlobalMetrics;

                if (useGlobalMetrics) {
                        sequenceIdentityThreshold = hcSequenceIdentityGlobal;
                        useSequenceCoverage = false;
                        useRMSD = false;
                        useStructureCoverage = false;
                        useTMScore = true;
                } else {
                        sequenceIdentityThreshold = hcSequenceIdentityLocal;
                        useSequenceCoverage = true;
                        useRMSD = true;
                        useStructureCoverage = true;
                        useTMScore = false;
                }
        }

        /**
         * Initialize with "local" metrics by default.
         */
        public SubunitClustererParameters() {
                this(false);
        }

        /**
         * Get the minimum number of residues of a subunits to be considered in the
         * clusters.
         * 
         * @return minimumSequenceLength
         */
        public int getMinimumSequenceLength() {
                return minimumSequenceLength;
        }

        /**
         * Set the minimum number of residues of a subunits to be considered in the
         * clusters.
         * 
         * @param minimumSequenceLength
         */
        public void setMinimumSequenceLength(int minimumSequenceLength) {
                this.minimumSequenceLength = minimumSequenceLength;
        }

        /**
         * If the shortest subunit sequence length is higher or equal the
         * minimumSequenceLengthFraction times the median subunit sequence length,
         * then the minimumSequenceLength is set to shortest subunit sequence
         * length, but not shorter than the absoluteMinimumSequenceLength.
         * <p>
         * This adaptive feature allows the consideration of structures mainly
         * constructed by very short chains, such as collagen (1A3I)
         * 
         * @return the absoluteMinimumSequenceLength
         */
        public int getAbsoluteMinimumSequenceLength() {
                return absoluteMinimumSequenceLength;
        }

        /**
         * If the shortest subunit sequence length is higher or equal the
         * minimumSequenceLengthFraction times the median subunit sequence length,
         * then the minimumSequenceLength is set to shortest subunit sequence
         * length, but not shorter than the absoluteMinimumSequenceLength.
         * <p>
         * This adaptive feature allows the consideration of structures mainly
         * constructed by very short chains, such as collagen (1A3I)
         * 
         * @param absoluteMinimumSequenceLength
         */
        public void setAbsoluteMinimumSequenceLength(
                        int absoluteMinimumSequenceLength) {
                this.absoluteMinimumSequenceLength = absoluteMinimumSequenceLength;
        }

        /**
         * If the shortest subunit sequence length is higher or equal the
         * minimumSequenceLengthFraction times the median subunit sequence length,
         * then the minimumSequenceLength is set to shortest subunit sequence
         * length, but not shorter than the absoluteMinimumSequenceLength.
         * <p>
         * This adaptive feature allows the consideration of structures mainly
         * constructed by very short chains, such as collagen (1A3I)
         * 
         * @return the minimumSequenceLengthFraction
         */
        public double getMinimumSequenceLengthFraction() {
                return minimumSequenceLengthFraction;
        }

        /**
         * If the shortest subunit sequence length is higher or equal the
         * minimumSequenceLengthFraction times the median subunit sequence length,
         * then the minimumSequenceLength is set to shortest subunit sequence
         * length, but not shorter than the absoluteMinimumSequenceLength.
         * <p>
         * This adaptive feature allows the consideration of structures mainly
         * constructed by very short chains, such as collagen (1A3I)
         * 
         * @param minimumSequenceLengthFraction
         */
        public void setMinimumSequenceLengthFraction(
                        double minimumSequenceLengthFraction) {
                this.minimumSequenceLengthFraction = minimumSequenceLengthFraction;
        }

        /**
         * Sequence identity threshold to consider for the subunits clustering.
         * <p>
         * Two subunits with sequence identity equal or higher than the threshold
         * will be clustered together.
         * 
         * @return sequenceIdentityThreshold
         */
        public double getSequenceIdentityThreshold() {
                return sequenceIdentityThreshold;
        }

        /**
         * Sequence identity threshold to consider for the sequence subunit
         * clustering.
         * <p>
         * Two subunits with sequence identity equal or higher than the threshold
         * will be clustered together.
         * 
         * @param sequenceIdentityThreshold
         */
        public void setSequenceIdentityThreshold(double sequenceIdentityThreshold) {
                this.sequenceIdentityThreshold = sequenceIdentityThreshold;
        }

        /**
         * The minimum coverage of the sequence alignment between two subunits to be
         * clustered together.
         *
         * @return sequenceCoverageThreshold
         */
        public double getSequenceCoverageThreshold() {
                return sequenceCoverageThreshold;
        }

        /**
         * The minimum coverage of the sequence alignment between two subunits to be
         * clustered together.
         *
         * @param sequenceCoverageThreshold
         */
        public void setSequenceCoverageThreshold(double sequenceCoverageThreshold) {
                this.sequenceCoverageThreshold = sequenceCoverageThreshold;
        }

        /**
         * Structure similarity threshold (measured with RMSD) to consider for the
         * structural subunit clustering.
         * 
         * @return rmsdThreshold
         */
        public double getRMSDThreshold() {
                return rmsdThreshold;
        }

        /**
         * Structure similarity threshold (measured with RMSD) to consider for the
         * structural subunit clustering.
         * 
         * @param rmsdThreshold
         */
        public void setRMSDThreshold(double rmsdThreshold) {
                this.rmsdThreshold = rmsdThreshold;
        }

        /**
         * Structure similarity threshold (measured with TMScore) to consider for the
         * structural subunit clustering.
         *
         * @return tmThreshold
         */
        public double getTMThreshold() {
                return tmThreshold;
        }

        /**
         * Structure similarity threshold (measured with TMScore) to consider for the
         * structural subunit clustering.
         *
         * @param tmThreshold
         */
        public void setTMThreshold(double tmThreshold) {
                this.tmThreshold = tmThreshold;
        }

        /**
         * The minimum coverage of the structure alignment between two subunits to be
         * clustered together.
         *
         * @return structureCoverageThreshold
         */
        public double getStructureCoverageThreshold() {
                return structureCoverageThreshold;
        }

        /**
         * The minimum coverage of the structure alignment between two subunits to be
         * clustered together.
         *
         * @param structureCoverageThreshold
         */
        public void setStructureCoverageThreshold(double structureCoverageThreshold) {
                this.structureCoverageThreshold = structureCoverageThreshold;
        }

        /**
         * Method to cluster subunits.
         *
         * @return clustererMethod
         */
        public SubunitClustererMethod getClustererMethod() {
                return clustererMethod;
        }

        /**
         * Method to cluster subunits.
         * 
         * @param method
         */
        public void setClustererMethod(SubunitClustererMethod method) {
                this.clustererMethod = method;
        }

        /**
         * The internal symmetry option divides each {@link Subunit} of each
         * {@link SubunitCluster} into its internally symmetric repeats.
         * <p>
         * The {@link SubunitClustererMethod#STRUCTURE} must be chosen to consider
         * internal symmetry, otherwise this parameter will be ignored.
         * 
         * @return true if internal symmetry is considered, false otherwise
         */
        public boolean isInternalSymmetry() {
                return internalSymmetry;
        }

        /**
         * The internal symmetry option divides each {@link Subunit} of each
         * {@link SubunitCluster} into its internally symmetric repeats.
         * <p>
         * The {@link SubunitClustererMethod#STRUCTURE} must be chosen to consider
         * internal symmetry, otherwise this parameter will be ignored.
         * 
         * @param internalSymmetry
         *            true if internal symmetry is considered, false otherwise
         */
        public void setInternalSymmetry(boolean internalSymmetry) {
                this.internalSymmetry = internalSymmetry;
        }

        @Override
        public String toString() {
                return "SubunitClustererParameters [minimumSequenceLength="
                                + minimumSequenceLength + ", absoluteMinimumSequenceLength="
                                + absoluteMinimumSequenceLength
                                + ", minimumSequenceLengthFraction="
                                + minimumSequenceLengthFraction
                                + ", sequenceIdentityThreshold=" + sequenceIdentityThreshold
                                + ", rmsdThreshold=" + rmsdThreshold + ", coverageThreshold="
                                + sequenceCoverageThreshold + ", clustererMethod=" + clustererMethod
                                + ", internalSymmetry=" + internalSymmetry + "]";
        }

        /**
         * Method to superpose subunits (i.e., structural aligner).
         *
         * @return superpositionAlgorithm
         */
        public String getSuperpositionAlgorithm() {
                return superpositionAlgorithm;
        }

        /**
         * Method to cluster subunits.
         *
         * @param superpositionAlgorithm
         */
        public void setSuperpositionAlgorithm(String superpositionAlgorithm) {
                this.superpositionAlgorithm = superpositionAlgorithm;
        }

        /**
         * Whether the alignment algorithm should try its best to optimize the alignment,
         * or we are happy with a quick and dirty result. Effect depends on implementation
         * of the specific algorithm's method.   *
         *
         * @return optimizeAlignment
         */
        public boolean isOptimizeAlignment() {
                return optimizeAlignment;
        }

        /**
         * Whether the alignment algorithm should try its best to optimize the alignment,
         * or we are happy with a quick and dirty result. Effect depends on implementation
         * of the specific algorithm's method.   *
         *
         * @param optimizeAlignment
         */
        public void setOptimizeAlignment(boolean optimizeAlignment) {
                this.optimizeAlignment = optimizeAlignment;
        }

        /**
         * Use RMSD for evaluating structure similarity
         *
         * @return useRMSD
         */
        public boolean isUseRMSD() { return useRMSD; }

        /**
         * Use RMSD for evaluating structure similarity
         *
         * @param useRMSD
         */
        public void setUseRMSD(boolean useRMSD) {
                this.useRMSD = useRMSD;
        }

        /**
         * Use TMScore for evaluating structure similarity
         *
         * @return useTMScore
         */
        public boolean isUseTMScore() {
                return useTMScore;
        }

        /**
         * Use TMScore for evaluating structure similarity
         *
         * @param useTMScore
         */
        public void setUseTMScore(boolean useTMScore) {
                this.useTMScore = useTMScore;
        }

        /**
         * Use sequence coverage for evaluating sequence similarity
         *
         * @return useSequenceCoverage
         */
        public boolean isUseSequenceCoverage() {
                return useSequenceCoverage;
        }

        /**
         * Use sequence coverage for evaluating sequence similarity
         *
         * @param useSequenceCoverage
         */
        public void setUseSequenceCoverage(boolean useSequenceCoverage) {
                this.useSequenceCoverage = useSequenceCoverage;
        }

        /**
         * Use structure coverage for evaluating sequence similarity
         *
         * @return useStructureCoverage
         */
        public boolean isUseStructureCoverage() {
                return useStructureCoverage;
        }

        /**
         * Use structure coverage for evaluating sequence similarity
         *
         * @param useStructureCoverage
         */
        public void setUseStructureCoverage(boolean useStructureCoverage) {
                this.useStructureCoverage = useStructureCoverage;
        }

        /**
         * Use metrics calculated relative to the whole sequence or structure,
         * rather than the aligned part only
         *
         * @return useGlobalMetrics
         */
        public boolean isUseGlobalMetrics() {
                return useGlobalMetrics;
        }

        /**
         * Use metrics calculated relative to the whole sequence or structure,
         * rather than the aligned part only
         *
         * @param useGlobalMetrics
         */
        public void setUseGlobalMetrics(boolean useGlobalMetrics) {
                this.useGlobalMetrics = useGlobalMetrics;
        }

        /**
         * Whether the subunits can be considered "identical" by sequence alignment.
         * For local sequence alignment (normalized by the number of aligned pairs)
         * this means 0.95 or higher identity and 0.75 or higher coverage.
         * For global sequence alignment (normalised by the alignment length)
         * this means 0.85 or higher sequence identity.
         *
         * @param sequenceIdentity
         * @param sequenceCoverage
         * @return true if the sequence alignment scores are equal to
         * or better than the "high confidence" scores, false otherwise.
         */
        public boolean isHighConfidenceScores(double sequenceIdentity, double sequenceCoverage) {
                if (useGlobalMetrics)
                        return sequenceIdentity>=hcSequenceIdentityGlobal;
                else
                        return sequenceIdentity>=hcSequenceIdentityLocal && sequenceCoverage >= hcSequenceCoverageLocal;
        }


}