package com.hfg.bio.seq.genomic.assembly;

import java.io.Serializable;
import java.util.Set;

import com.hfg.util.CompareUtil;
import com.hfg.util.collection.OrderedSet;

//------------------------------------------------------------------------------
/**
 * Enumeration of genomic representation values.
 * <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 final class GenomicRepresentation implements Serializable, Comparable<GenomicRepresentation>
{

   private final String mName;
   private final int    mIndex;

   private static final Set<GenomicRepresentation> sValues = new OrderedSet<>(2);

   public static final GenomicRepresentation FULL    = new GenomicRepresentation("Full");
   public static final GenomicRepresentation PARTIAL = new GenomicRepresentation("Partial");

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

   //--------------------------------------------------------------------------
   private GenomicRepresentation(String inName)
   {
      mName = inName;
      mIndex = sValues.size();
      sValues.add(this);
   }

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

   //--------------------------------------------------------------------------
   @Override
   public final String toString()
   {
      return mName;
   }

   //--------------------------------------------------------------------------
   public static GenomicRepresentation valueOf(String inValue)
   {
      GenomicRepresentation outValue = null;

      for (GenomicRepresentation value : sValues)
      {
         if (value.toString().equalsIgnoreCase(inValue))
         {
            outValue = value;
            break;
         }
      }

      return outValue;
   }

   //--------------------------------------------------------------------------
   public static GenomicRepresentation[] values()
   {
      return sValues.toArray(new GenomicRepresentation[] {});
   }


   //--------------------------------------------------------------------------
   public final String name()
   {
      return mName;
   }

   //--------------------------------------------------------------------------
   @Override
   public final int hashCode()
   {
      return mIndex;
   }

   //--------------------------------------------------------------------------
   @Override
   public final boolean equals(Object inObj)
   {
      return (inObj instanceof GenomicRepresentation
              && mIndex == ((GenomicRepresentation) inObj).mIndex);
   }

   //--------------------------------------------------------------------------
   /**
    * This method is called after de-serialization, allowing the object
    * to nominate a replacement object to be used in the output
    * graph instead of this object. We don't want multiple objects of each type
    * to exist in a target VM, so instances replace themselves with
    * local objects.
    */
   private Object readResolve()
   {
      GenomicRepresentation outValue = null;

      for (GenomicRepresentation value : sValues)
      {
         if (mIndex == value.mIndex)
         {
            outValue = value;
            break;
         }
      }

      return outValue;
   }

   //--------------------------------------------------------------------------
   /**
    * Compares this object with the specified object for order.  Returns a
    * negative integer, zero, or a positive integer as this object is less
    * than, equal to, or greater than the specified object.
    *
    * <p>The implementor must ensure
    * {@code sgn(x.compareTo(y)) == -sgn(y.compareTo(x))}
    * for all {@code x} and {@code y}.  (This
    * implies that {@code x.compareTo(y)} must throw an exception iff
    * {@code y.compareTo(x)} throws an exception.)
    *
    * <p>The implementor must also ensure that the relation is transitive:
    * {@code (x.compareTo(y) > 0 && y.compareTo(z) > 0)} implies
    * {@code x.compareTo(z) > 0}.
    *
    * <p>Finally, the implementor must ensure that {@code x.compareTo(y)==0}
    * implies that {@code sgn(x.compareTo(z)) == sgn(y.compareTo(z))}, for
    * all {@code z}.
    *
    * <p>It is strongly recommended, but <i>not</i> strictly required that
    * {@code (x.compareTo(y)==0) == (x.equals(y))}.  Generally speaking, any
    * class that implements the {@code Comparable} interface and violates
    * this condition should clearly indicate this fact.  The recommended
    * language is "Note: this class has a natural ordering that is
    * inconsistent with equals."
    *
    * <p>In the foregoing description, the notation
    * {@code sgn(}<i>expression</i>{@code )} designates the mathematical
    * <i>signum</i> function, which is defined to return one of {@code -1},
    * {@code 0}, or {@code 1} according to whether the value of
    * <i>expression</i> is negative, zero, or positive, respectively.
    *
    * @param inObj2 the object to be compared.
    * @return a negative integer, zero, or a positive integer as this object
    * is less than, equal to, or greater than the specified object.
    * @throws ClassCastException   if the specified object's type prevents it
    *                              from being compared to this object.
    */
   @Override
   public int compareTo(GenomicRepresentation inObj2)
   {
      int result = -1;
      if (inObj2 != null)
      {
         result = CompareUtil.compare(mIndex, inObj2.mIndex);
      }

      return result;
   }
}