package com.hfg.bio.seq.alignment;

import java.util.List;

import com.hfg.bio.HfgBioXML;
import com.hfg.exception.ProgrammingException;
import com.hfg.math.Range;
import com.hfg.util.CompareUtil;
import com.hfg.util.StringUtil;
import com.hfg.xml.XMLNode;
import com.hfg.xml.XMLTag;

//------------------------------------------------------------------------------
/**
 Pairwise sequence alignment scoring data.
 <div>
 @author J. Alex Taylor, hairyfatguy.com
 </div>
 */
//------------------------------------------------------------------------------
// com.hfg XML/HTML Coding Library
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// J. Alex Taylor, President, Founder, CEO, COO, CFO, OOPS hairyfatguy.com
// jataylor@hairyfatguy.com
//------------------------------------------------------------------------------

public class AlignmentScoring implements Cloneable, Comparable<AlignmentScoring>
{
   private List<Range<Integer>> mScoringBoundaries; // 1-based
   private Float            mRawScore;
   private Integer          mNumIdentities;
   private Integer          mComparisonLength;
   private Integer          mAdjustedComparisonLength;
   private Float            mPctIdentity;
   private Float            mAdjustedPctIdentity;
   private Float            mEValue;
   private Float            mPValue;
   private Float            mZScore;
   private Integer          mQueryInternalGapLength;

   //###########################################################################
   // CONSTRUCTORS
   //###########################################################################

   //---------------------------------------------------------------------------
   public AlignmentScoring()
   {
   }

   //---------------------------------------------------------------------------
   public AlignmentScoring(XMLNode inXMLNode)
   {
      if (! inXMLNode.getTagName().equals(HfgBioXML.ALIGNMENT_SCORING))
      {
         throw new RuntimeException("Cannot construct a " + this.getClass().getSimpleName() + " from a " + inXMLNode.getTagName() + " tag!");
      }


      String rawScoreString = inXMLNode.getAttributeValue(HfgBioXML.SCORE_ATT);
      if (StringUtil.isSet(rawScoreString))
      {
         setScore(Float.parseFloat(rawScoreString));
      }

      String numIdentititesString = inXMLNode.getAttributeValue(HfgBioXML.NUM_IDENTITIES_ATT);
      if (StringUtil.isSet(numIdentititesString))
      {
         setNumIdentities(Integer.parseInt(numIdentititesString));
      }

      String comparisionLenString = inXMLNode.getAttributeValue(HfgBioXML.COMPARISON_LENGTH_ATT);
      if (StringUtil.isSet(comparisionLenString))
      {
         setComparisonLength(Integer.parseInt(comparisionLenString));
      }
   }

   //###########################################################################
   // PUBLIC METHODS
   //###########################################################################

   //---------------------------------------------------------------------------
   public AlignmentScoring combine(AlignmentScoring inValue)
   {
      AlignmentScoring result = clone();

      if (inValue != null
          && inValue.getComparisonLength() > 0)
      {
         result.incrementComparisonLength(inValue.getComparisonLength());
         result.incrementNumIdentities(inValue.getNumIdentities());

         if (result.mAdjustedComparisonLength != null
               && inValue.mAdjustedComparisonLength != null)
         {
            result.mAdjustedComparisonLength += inValue.mAdjustedComparisonLength;
         }

         if (inValue.mQueryInternalGapLength != null)
         {
            if (null == result.mQueryInternalGapLength)
            {
               result.mQueryInternalGapLength = inValue.mQueryInternalGapLength;
            }
            else
            {
               result.mQueryInternalGapLength += inValue.mQueryInternalGapLength;
            }
         }

         if (result.getScore() != null
               && inValue.getScore() != null)
         {
            result.setScore(result.getScore() + inValue.getScore());
         }

         if (result.getPValue() != null
               && inValue.getPValue() != null)
         {
            result.setPValue(result.getPValue() * inValue.getPValue());
         }

         // TODO: E-value & Z-score
         // TODO: Scoring boundaries?

         result.mPctIdentity = null;
         result.mAdjustedPctIdentity = null;
      }

      return result;
   }

   //---------------------------------------------------------------------------
   @Override
   public AlignmentScoring clone()
   {
      AlignmentScoring cloneObj;
      try
      {
         cloneObj = (AlignmentScoring) super.clone();
      }
      catch (Exception e)
      {
         throw new ProgrammingException(e);
      }

      return cloneObj;
   }

   //--------------------------------------------------------------------------
   @Override
   public boolean equals(Object inObj2)
   {
      return (inObj2 != null
            && inObj2 instanceof AlignmentScoring
            && 0 == compareTo((AlignmentScoring) inObj2));
   }

   //--------------------------------------------------------------------------
   @Override
   public int hashCode()
   {
      int hashCode = 0;
      if (getScore() != null)
      {
         hashCode += getScore().hashCode();
      }

      hashCode += 31 * getNumIdentities();

      return hashCode;
   }

   //--------------------------------------------------------------------------
   @Override
   public int compareTo(AlignmentScoring inObj2)
   {
      int score = - CompareUtil.compare(getScore(), inObj2.getScore());
      if (0 == score)
      {
         score = - CompareUtil.compare(getNumIdentities(), inObj2.getNumIdentities());
      }

      return score;
   }

   //---------------------------------------------------------------------------
   @Override
   public String toString()
   {
      return String.format("%.2f: [%d / %d]", getScore(), getNumIdentities(), getComparisonLength());
   }

   //--------------------------------------------------------------------------
   public XMLNode toXMLNode()
   {
      XMLTag tag = new XMLTag(HfgBioXML.ALIGNMENT_SCORING);

      if (getScore() != null)
      {
         tag.setAttribute(HfgBioXML.SCORE_ATT, getScore());
      }

      if (getComparisonLength() != 0)
      {
         tag.setAttribute(HfgBioXML.NUM_IDENTITIES_ATT, getNumIdentities());
      }

      if (getComparisonLength() != 0)
      {
         tag.setAttribute(HfgBioXML.COMPARISON_LENGTH_ATT, getComparisonLength());
      }


      return tag;
   }

   //---------------------------------------------------------------------------
   public void clear()
   {
      mNumIdentities = null;
      mComparisonLength = null;
      mAdjustedComparisonLength = null;
      mPctIdentity = null;
      mAdjustedPctIdentity = null;
      mEValue = null;
      mPValue = null;
      mZScore = null;
   }

   //---------------------------------------------------------------------------
   /**
    Specifies an optional 1-based list of alignment position ranges which should
    be considered for scoring.
    @param inValue List of 1-based Ranges to score
    @return this AlignmentScoring object to enable method chaining
    */
   public AlignmentScoring setScoringBoundaries(List<Range<Integer>> inValue)
   {
      mScoringBoundaries = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public List<Range<Integer>> getScoringBoundaries()
   {
      return mScoringBoundaries;
   }

   //---------------------------------------------------------------------------
   public AlignmentScoring setScore(Float inValue)
   {
      mRawScore = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public Float getScore()
   {
      return mRawScore;
   }

   //---------------------------------------------------------------------------
   public AlignmentScoring setNumIdentities(Integer inValue)
   {
      mNumIdentities = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public AlignmentScoring incrementNumIdentities()
   {
      return incrementNumIdentities(1);
   }

   //---------------------------------------------------------------------------
   public AlignmentScoring incrementNumIdentities(int inValue)
   {
      mNumIdentities = (mNumIdentities != null ? mNumIdentities : 0) + inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public int getNumIdentities()
   {
      return mNumIdentities != null ? mNumIdentities : 0;
   }


   //---------------------------------------------------------------------------
   public AlignmentScoring setComparisonLength(Integer inValue)
   {
      mComparisonLength = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public AlignmentScoring incrementComparisonLength()
   {
      return incrementComparisonLength(1);
   }

   //---------------------------------------------------------------------------
   public AlignmentScoring incrementComparisonLength(int inValue)
   {
      mComparisonLength = (mComparisonLength != null ? mComparisonLength : 0) + inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public int getComparisonLength()
   {
      return mComparisonLength != null ? mComparisonLength : 0;
   }

   //---------------------------------------------------------------------------
   /**
    Doesn't penalize sequence's terminal gaps.
    @return the adjusted comparison length
    */
   public int getAdjustedComparisonLength()
   {
      return mAdjustedComparisonLength != null ? mAdjustedComparisonLength : mComparisonLength != null ? mComparisonLength : 0;
   }

   //---------------------------------------------------------------------------
   public Float getPctIdentity()
   {
      if (null == mPctIdentity
            && mComparisonLength != null)
      {
         mPctIdentity = mComparisonLength > 0 && mNumIdentities != null ? 100f * mNumIdentities / mComparisonLength.floatValue() : 0;
      }

      return mPctIdentity;
   }

   //---------------------------------------------------------------------------
   /**
    Sets the percent identity that doesn't penalize sequence's terminal gaps.
    @return this AlignmentScoring object to enable method chaining
    */
   public AlignmentScoring setAdjustedPctIdentity(Float inValue)
   {
      mAdjustedPctIdentity = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   /**
    Doesn't penalize sequence's terminal gaps.
    @return the adjusted percent identity
    */
   public Float getAdjustedPctIdentity()
   {
      if (null == mAdjustedPctIdentity
            && getAdjustedComparisonLength() > 0)
      {
         mAdjustedPctIdentity = mNumIdentities != null ? 100f * mNumIdentities / (float) getAdjustedComparisonLength() : 0;
      }

      return mAdjustedPctIdentity != null ? mAdjustedPctIdentity : getPctIdentity();
   }


   //---------------------------------------------------------------------------
   public AlignmentScoring setEValue(Float inValue)
   {
      mEValue = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public Float getEValue()
   {
      return mEValue;
   }

   //---------------------------------------------------------------------------
   public AlignmentScoring setPValue(Float inValue)
   {
      mPValue = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public Float getPValue()
   {
      return mPValue;
   }

   //---------------------------------------------------------------------------
   public AlignmentScoring setZScore(Float inValue)
   {
      mZScore = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public Float getZScore()
   {
      return mZScore;
   }


   //---------------------------------------------------------------------------
   /**
    Returns the total number of non-terminal query gap positions where the subject is not a gap.
    * @return the total number of non-terminal query gap positions where the subject is not a gap
    */
   public Integer getQueryInternalGapLength()
   {
      return mQueryInternalGapLength;
   }

   //---------------------------------------------------------------------------
   public void calculate(PairwiseSeqAlignment inAlignment)
   {
      int numIdentities = 0;
      int comparisonLength = 0;
      int adjustedComparisonLength = 0;
      int queryInternalGapLength = 0;  // The total number of non-terminal query gap positions where the subject is not a gap

      AlignedQuery alignedQuery = inAlignment.getAlignedQuery();
      AlignedSubject alignedSubject = inAlignment.getAlignedSubject();

      String queryResidues = alignedQuery.getAlignedSeq().toLowerCase(); // Lower-casing for case-insensitive comparison
      String subjectResidues = alignedSubject.getAlignedSeq().toLowerCase();


      Integer lastQueryResidueIndex = queryResidues.length() - 1;
      if (null == alignedQuery.getSeq()
            || alignedQuery.getSeqLocation().getEnd().equals(alignedQuery.getSeq().length()))
      {
         for (int i = queryResidues.length() - 1; i >= 0; i--)
         {
            char queryResidue = queryResidues.charAt(i);
            if (queryResidue != '-')
            {
               lastQueryResidueIndex = i;
               break;
            }
         }
      }

      Integer lastSubjectResidueIndex = subjectResidues.length() - 1;
      if (null == alignedSubject.getSeq()
            || alignedSubject.getSeqLocation().getEnd().equals(alignedSubject.getSeq().length()))
      {
         for (int i = subjectResidues.length() - 1; i >= 0; i--)
         {
            char subjectResidue = subjectResidues.charAt(i);
            if (subjectResidue != '-')
            {
               lastSubjectResidueIndex = i;
               break;
            }
         }
      }

      int lastIndex = Math.min(lastQueryResidueIndex, lastSubjectResidueIndex);

      // Did the query start before this alignment?
      boolean queryStarted = alignedQuery.getSeqLocation() != null
            && alignedQuery.getSeqLocation().getStart() != null
            && alignedQuery.getSeqLocation().getStart() > 1;

      // Did the subject start before this alignment?
      boolean subjectStarted = alignedSubject.getSeqLocation() != null
            && alignedSubject.getSeqLocation().getStart() != null
            && alignedSubject.getSeqLocation().getStart() > 1;

      boolean firstAlignedQueryResidueEncountered = false;

      for (int i = 0; i < queryResidues.length(); i++)
      {
         char queryResidue   = queryResidues.charAt(i);
         char subjectResidue = subjectResidues.charAt(i);

         if (! firstAlignedQueryResidueEncountered
               && queryResidue != '-')
         {
            firstAlignedQueryResidueEncountered = true;

            if (! queryStarted)
            {
               queryStarted = true;
            }
         }


         if (! subjectStarted
               && subjectResidue != '-')
         {
            subjectStarted = true;
         }

         // Default to true if no boundaries were specified
         boolean isInScoringRegion = true;
         if (mScoringBoundaries != null)
         {
            isInScoringRegion = false;
            for (Range<Integer> range : mScoringBoundaries)
            {
               if (range.contains(i + 1))
               {
                  isInScoringRegion = true;
                  break;
               }
            }
         }

         if ((queryResidue != '-' || subjectResidue != '-')
             && isInScoringRegion)
         {
            if (queryResidue == subjectResidue)
            {
               numIdentities++;
            }

            comparisonLength++;

            if (queryStarted
                  && subjectStarted
                  && i <= lastIndex)
            {
               adjustedComparisonLength++;
            }
         }

         if (queryResidue == '-'
               && subjectResidue != '-'
               && firstAlignedQueryResidueEncountered
               && isInScoringRegion
               && i < lastQueryResidueIndex)
         {
            queryInternalGapLength++;
         }
      }

      mNumIdentities = numIdentities;
      mComparisonLength = comparisonLength;
      mAdjustedComparisonLength = adjustedComparisonLength;
      mQueryInternalGapLength = queryInternalGapLength;
   }
}