package com.hfg.units;


import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.*;
import java.util.regex.Pattern;

import com.hfg.exception.ProgrammingException;
import com.hfg.util.CompareUtil;
import com.hfg.util.StringBuilderPlus;
import com.hfg.util.StringUtil;
import com.hfg.util.collection.CollectionUtil;
import com.hfg.util.collection.OrderedSet;

// NOTE: Add new unit classes to the /META-DATA/services/com.hfg.units.Unit file
//       for them to be properly discoverable!!!
//------------------------------------------------------------------------------
/**
 Container for units.
 <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 Unit implements Comparable
{
   private static MathContext sDefaultMathContext = new MathContext(16, RoundingMode.HALF_UP);
   private static Set<Unit> sInstances = new OrderedSet<>(50);
   private static Map<String, Unit> sLookupMap = new HashMap<>();
   private static boolean sInitialized = false;

   private MeasurementSystem mMeasurementSystem;
   private String  mName;
   private Set<String>  mAlternateNames;
   private String  mPlural;
   private String  mAbbrev;
   private String mPluralAbbrev;
   private QuantityType mQuantityType;
   private Integer mPow;
   private BaseSIUnitConverter mConversionToBaseSIUnit;
   private List<SubUnit> mSubUnits;
   private MathContext mMathContext;


   //---------------------------------------------------------------------------
   protected Unit(QuantityType inQuantityType, String inName, String inAbbrev, Integer inPow)
   {
      this(null, inQuantityType, inName, inAbbrev, inPow, null);
   }

   //---------------------------------------------------------------------------
   protected Unit(MeasurementSystem inSystem, QuantityType inQuantityType, String inName, String inAbbrev, Integer inPow)
   {
      this(inSystem, inQuantityType, inName, inAbbrev, inPow, null);
   }

   //---------------------------------------------------------------------------
   protected Unit(QuantityType inQuantityType, String inName, String inAbbrev, Integer inPow, BaseSIUnitConverter inConversionToBaseSIUnit)
   {
      this(null, inQuantityType, inName, inAbbrev, inPow, inConversionToBaseSIUnit);
   }

   //---------------------------------------------------------------------------
   protected Unit(MeasurementSystem inSystem, QuantityType inQuantityType, String inName, String inAbbrev, Integer inPow, BaseSIUnitConverter inConversionToBaseSIUnit)
   {
      mMeasurementSystem = inSystem;
      mQuantityType = inQuantityType;
      mName   = inName;
      mAbbrev = inAbbrev;
      mPow    = inPow;
      mConversionToBaseSIUnit = inConversionToBaseSIUnit;

      addToMaps(this);
   }

   //---------------------------------------------------------------------------
   protected Unit(MeasurementSystem inSystem, QuantityType inQuantityType, String inName, String inAbbrev, Integer inPow, BaseSIUnitConverter inConversionToBaseSIUnit, SubUnit[] inSubUnits)
   {
      mMeasurementSystem = inSystem;
      mQuantityType = inQuantityType;
      mName   = inName;
      mAbbrev = inAbbrev;
      mPow    = inPow;
      mConversionToBaseSIUnit = inConversionToBaseSIUnit;

      if (inSubUnits != null
            && inSubUnits.length > 0)
      {
         mSubUnits = new ArrayList<>(Arrays.asList(inSubUnits));
      }

      addToMaps(this);
   }

   //---------------------------------------------------------------------------
   protected Unit(MeasurementSystem inSystem, QuantityType inQuantityType, SubUnit inSubUnit)
   {
      mMeasurementSystem = inSystem;
      mQuantityType = inQuantityType;
      mSubUnits = new ArrayList<>(1);
      mSubUnits.add(inSubUnit);

      addToMaps(this);
   }

   //---------------------------------------------------------------------------
   protected Unit(Unit inSubUnit, SI_ScalingFactor inScalingFactor)
   {
      this(new SubUnit(inSubUnit, inScalingFactor));
   }

   //---------------------------------------------------------------------------
   protected Unit(SubUnit... inSubUnits)
   {
      if (null == inSubUnits
          || 0 == inSubUnits.length)
      {
         throw new RuntimeException("No SubUnits specified!");
      }

      initFromSubUnits(Arrays.asList(inSubUnits));
   }

   //---------------------------------------------------------------------------
   protected Unit(List<SubUnit> inSubUnits)
   {
      initFromSubUnits(inSubUnits);
   }

   //---------------------------------------------------------------------------
   protected Unit(MeasurementSystem inSystem, QuantityType inQuantityType, String inName, String inAbbrev, List<SubUnit> inSubUnits)
   {
      mMeasurementSystem = inSystem;
      mQuantityType = inQuantityType;
      mName     = inName;
      mAbbrev   = inAbbrev;
      mSubUnits = inSubUnits;

      addToMaps(this);
   }

   //---------------------------------------------------------------------------
   protected Unit(MeasurementSystem inSystem, QuantityType inQuantityType, String inName, String inAbbrev, SubUnit... inSubUnits)
   {
      mMeasurementSystem = inSystem;
      mQuantityType = inQuantityType;
      mName     = inName;
      mAbbrev   = inAbbrev;

      if (inSubUnits != null
            && inSubUnits.length > 0)
      {
         mSubUnits = new ArrayList<>(Arrays.asList(inSubUnits));
      }

      addToMaps(this);
   }

   //---------------------------------------------------------------------------
   private void initFromSubUnits(List<SubUnit> inSubUnits)
   {
      mSubUnits = inSubUnits;

      mMeasurementSystem = mSubUnits.get(0).getUnit().getMeasurementSystem();

      // Add to the lookup map but not to the list of instances since these are not "official"
      String name = name();
      if (! sLookupMap.containsKey(name)   // Don't override an existing mapping
          && (getSubUnits().size() > 1
              || null == getSubUnits().get(0).getScalingFactor()))  // Don't add scaled simple base units
      {
         sLookupMap.put(name, this);
      }
   }

   //---------------------------------------------------------------------------
   private void addToMaps(Unit inValue)
   {
      sInstances.add(inValue);
      sLookupMap.put(inValue.name(), inValue);
   }

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

   //---------------------------------------------------------------------------
   /**
    Sets the default MathContext to specify precision and rounding during operations.
    * @param inValue the MathContext to use
    */
   public static void setDefaultMathContext(MathContext inValue)
   {
      sDefaultMathContext = inValue;
   }

   //---------------------------------------------------------------------------
   /**
    Sets the MathContext to specify precision and rounding during operations with this Unit.
    * @param inValue the MathContext to use
    */
   public Unit setMathContext(MathContext inValue)
   {
      mMathContext = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public MathContext getMathContext()
   {
      return mMathContext != null ? mMathContext : sDefaultMathContext;
   }

   //---------------------------------------------------------------------------
   public static Collection<? extends Unit> values()
   {
      ensureExtendingClassesAreInitialized();

      return Collections.unmodifiableCollection(sInstances);
   }

   //---------------------------------------------------------------------------
   public static Unit valueOf(SubUnit inSubUnit)
   {
      List<SubUnit> subUnits = new ArrayList<>(1);
      subUnits.add(inSubUnit);

      return valueOf(subUnits);
   }

   //---------------------------------------------------------------------------
   public static Unit valueOf(List<SubUnit> inSubUnits)
   {
      Unit unit = null;

      if (CollectionUtil.hasValues(inSubUnits))
      {
         for (Unit existingUnit : sInstances)
         {
            if (0 == existingUnit.compareTo(inSubUnits))
            {
               unit = existingUnit;
               break;
            }
         }

         if (null == unit)
         {
            unit = new Unit(inSubUnits);
         }
      }

      return unit;
   }

   //---------------------------------------------------------------------------
   public static Unit valueOf(String inString)
   {
      ensureExtendingClassesAreInitialized();

      Unit unit = null;

      if (StringUtil.isSet(inString))
      {
         String string = inString.trim();

         List<SubUnit> subUnits = new ArrayList<>(5);

         if (string.contains("/"))
         {
            String[] pieces = string.split("/");
            if (pieces.length > 2)
            {
               throw new UnitParseException("Multiple '/' operators in a unit string is ambiguous!");
            }

            // Special nasty case: '% v/v'
            if (string.equalsIgnoreCase(ConcentrationUnit.pct_by_volume.getAbbrev())
                || ConcentrationUnit.pct_by_volume.getAlternateNames().contains(string))
            {
               subUnits.addAll(ConcentrationUnit.pct_by_volume.getSubUnits());
            } // Special nasty case: '% w/w'
            else if (string.equalsIgnoreCase(ConcentrationUnit.pct_by_weight.getAbbrev())
                || ConcentrationUnit.pct_by_weight.getAlternateNames().contains(string))
            {
               subUnits.addAll(ConcentrationUnit.pct_by_weight.getSubUnits());
            }
            else
            {
               // Numerator
               subUnits.addAll(parseNumeratorBlockOfUnits(pieces[0].trim()));

               // Denominator
               subUnits.addAll(parseDenominatorBlockOfUnits(pieces[1].trim()));
            }
         }
         else
         {
            subUnits.addAll(parseNumeratorBlockOfUnits(string));
         }

         // Does the configuration of subunits match a defined unit?
         for (Unit stdUnit : sInstances)
         {
            if (stdUnit.hasSubUnits()
                  && 0 == CompareUtil.compare(stdUnit.getSubUnits(), subUnits))
            {
               unit = stdUnit;
               break;
            }
         }

         if (null == unit
             && 1 == subUnits.size())
         {
            SubUnit subUnit = subUnits.get(0);
            for (Unit stdUnit : sInstances)
            {
               if (stdUnit.equals(subUnit.getUnit())
                     && null == subUnit.getPow()
                     && null == subUnit.getScalingFactor())
               {
                  unit = stdUnit;
                  break;
               }
            }
         }

         if (null == unit)
         {
            // If all the subunits are of the same type, use that type as the constructor.
            Set<QuantityType> quantityTypes = new HashSet<>(2);
            for (SubUnit subUnit : subUnits)
            {
               quantityTypes.add(subUnit.getUnit().getQuantityType());
            }

            if (1 == quantityTypes.size())
            {
               QuantityType quantityType =  quantityTypes.iterator().next();

               if (quantityType.equals(QuantityType.TIME))
               {
                  unit = new TimeUnit(subUnits);
               }
               else if (quantityType.equals(QuantityType.LENGTH))
               {
                  unit = new LengthUnit(subUnits);
               }
               else if (quantityType.equals(QuantityType.MASS))
               {
                  unit = new MassUnit(subUnits);
               }
               else if (quantityType.equals(QuantityType.VOLUME))
               {
                  unit = new VolumeUnit(subUnits);
               }
               else if (quantityType.equals(QuantityType.CONCENTRATION))
               {
                  unit = new ConcentrationUnit(subUnits);
               }
               else if (quantityType.equals(QuantityType.AREA))
               {
                  unit = new AreaUnit(subUnits);
               }
               else if (quantityType.equals(QuantityType.BIOLOGICAL_POTENCY))
               {
                  unit = new BiologicalPotencyUnit(subUnits);
               }
               else if (quantityType.equals(QuantityType.CATALYTIC_ACTIVITY))
               {
                  unit = new CatalyticActivityUnit(subUnits);
               }
               else if (quantityType.equals(QuantityType.ELECTRIC_CURRENT))
               {
                  unit = new ElectricCurrentUnit(subUnits);
               }
            }

            // As a last resort just create a Unit from the SubUnits.
            if (null == unit)
            {
               unit = new Unit(subUnits);
            }
         }
      }

      return unit;
   }

   //---------------------------------------------------------------------------
   @Override
   public String toString()
   {
      StringBuilderPlus buffer = new StringBuilderPlus().setDelimiter(" ");
      if (StringUtil.isSet(getAbbrev()))
      {
         buffer.append(getAbbrev());
         if (getPow() != null)
         {
            buffer.append(StringUtil.toSuperscript(getPow()));
         }
      }
      else if (hasSubUnits())
      {
         for (SubUnit subUnit : getSubUnits())
         {
            if (subUnit.getPow() != null
                && subUnit.getPow().equals(-1)
                && 2 == getSubUnits().size()
                && 1 == getSubUnits().indexOf(subUnit)
                && (null == getSubUnits().get(0).getPow()
                    ||  getSubUnits().get(0).getPow() > 0))
            {
               buffer.append("/");
               if (subUnit.getScalingFactor() != null)
               {
                  buffer.append(subUnit.getScalingFactor().getSymbol());
               }
               buffer.append(subUnit.toStringMinusPow());
            }
            else
            {
               buffer.delimitedAppend(subUnit);
            }
         }
      }
      else
      {
         throw new ProgrammingException("Unit with no abbreviation or SubUnits!");
      }

      return buffer.toString();
   }

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

   //---------------------------------------------------------------------------
   @Override
   public int hashCode()
   {
      int hashCode = 0;

      if (getMeasurementSystem() != null)
      {
         hashCode += 31 * getMeasurementSystem().hashCode();
      }

      if (getQuantityType() != null)
      {
         hashCode += 31 * getQuantityType().hashCode();
      }

      if (getPow() != null)
      {
         hashCode += 31 * getPow().hashCode();
      }

      if (hasSubUnits())
      {
         for (SubUnit subUnit : getSubUnits())
         {
            hashCode += 31 * subUnit.hashCode();
         }
      }
      else
      {
         if (name() != null)
         {
            hashCode += 31 * name().hashCode();
         }
      }

      return hashCode;
   }

   //---------------------------------------------------------------------------
   public int compareTo(Object inObj2)
   {
      int result = -1;
      if (inObj2 != null)
      {
         if (inObj2 instanceof Unit)
         {
            Unit unit2 = (Unit) inObj2;

            result = CompareUtil.compare(getMeasurementSystem(), unit2.getMeasurementSystem());

/*
            if (0 == result)
            {
               result = CompareUtil.compare(name(), unit2.name());
            }
*/
            if (0 == result)
            {
               result = CompareUtil.compare(getQuantityType(), unit2.getQuantityType());
            }

            if (0 == result)
            {
               result = CompareUtil.compare(getPow(), unit2.getPow());
            }

            if (0 == result)
            {
               if (hasSubUnits())
               {
                  result = CompareUtil.compare(getSubUnits(), unit2.getSubUnits());
               }
               else
               {
                  result = CompareUtil.compare(name(), unit2.name());
               }
            }
         }
      }

      return result;
   }

   //---------------------------------------------------------------------------
   public int compareTo(List<SubUnit> inSubUnits)
   {
      int result = -1;
      if (inSubUnits != null)
      {
         if (1 == inSubUnits.size())
         {
            // Does this unit equal the specified subunit?

            SubUnit subUnit = inSubUnits.get(0);

            result = CompareUtil.compare(this, subUnit.getUnit());

            if (0 == result)
            {
               result = CompareUtil.compare(getPow(), subUnit.getPow());
            }

            if (0 == result
                  && subUnit.getScalingFactor() != null)
            {
               result = -1;
            }
         }

         if (result != 0
               && hasSubUnits())
         {
            result = CompareUtil.compare(getSubUnits(), inSubUnits);

            if (0 == result)
            {
               if (getPow() != null)
               {
                  result = 1;
               }
            }
         }
      }

      return result;
   }

   //---------------------------------------------------------------------------
   public String name()
   {
      if (null == mName
          && CollectionUtil.hasValues(mSubUnits))
      {
         StringBuilderPlus name = new StringBuilderPlus().setDelimiter(" ");
         for (SubUnit subUnit : mSubUnits)
         {
            String subUnitName = subUnit.getUnit().name();
            if (null == subUnitName)
            {
               name = null;
               break;
            }

            if (subUnit.getScalingFactor() != null)
            {
               subUnitName = subUnit.getScalingFactor().getPrefix() + subUnitName;
            }

            if (subUnit.getPow() != null)
            {
               subUnitName += StringUtil.toSuperscript(subUnit.getPow());
            }

            name.delimitedAppend(subUnitName);
         }

         if (StringUtil.isSet(name))
         {
            mName = name.toString();
         }
      }

      return mName;
   }

   //---------------------------------------------------------------------------
   public String getAbbrev()
   {
      if (null == mAbbrev
          && CollectionUtil.hasValues(mSubUnits))
      {
         StringBuilderPlus abbrev = new StringBuilderPlus().setDelimiter(" ");
         for (int i = 0; i < mSubUnits.size(); i++)
         {
            SubUnit subUnit = mSubUnits.get(i);

            String subUnitAbbrev = subUnit.getUnit().getAbbrev();
            if (null == subUnitAbbrev)
            {
               abbrev = null;
               break;
            }

            String powString = "";

            if (subUnit.getPow() != null)
            {
               if (1 == i
                   && -1 == subUnit.getPow()
                   && (null == mSubUnits.get(0).getPow()
                       || mSubUnits.get(0).getPow() > 1))
               {
                  abbrev.append("/");
               }
               else
               {
                  if (i > 0)
                  {
                     abbrev.append(" ");
                  }
                  powString = StringUtil.toSuperscript(subUnit.getPow());
               }
            }

            if (subUnit.getScalingFactor() != null)
            {
               subUnitAbbrev = subUnit.getScalingFactor().getSymbol() + subUnitAbbrev;
            }

            subUnitAbbrev += powString;

            abbrev.append(subUnitAbbrev);
         }

         if (StringUtil.isSet(abbrev))
         {
            mAbbrev = abbrev.toString();
         }
      }

      return mAbbrev;
   }

   //---------------------------------------------------------------------------
   public Unit addAlternateName(String inValue)
   {
      if (null == mAlternateNames)
      {
         mAlternateNames = new HashSet<>(4);
      }

      sLookupMap.put(inValue, this);
      return this;
   }

   //---------------------------------------------------------------------------
   public Set<String> getAlternateNames()
   {
      return mAlternateNames;
   }

   //---------------------------------------------------------------------------
   public Unit setPlural(String inValue)
   {
      mPlural = inValue;
      sLookupMap.put(mPlural, this);
      return this;
   }

   //---------------------------------------------------------------------------
   public String getPlural()
   {
      return mPlural;
   }


   //---------------------------------------------------------------------------
   public Unit setPluralAbbrev(String inValue)
   {
      mPluralAbbrev = inValue;
      sLookupMap.put(mPluralAbbrev, this);
      return this;
   }

   //---------------------------------------------------------------------------
   public String getPluralAbbrev()
   {
      return mPluralAbbrev;
   }


   //---------------------------------------------------------------------------
   public Unit setMeasurementSystem(MeasurementSystem inValue)
   {
      mMeasurementSystem = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public MeasurementSystem getMeasurementSystem()
   {
      return mMeasurementSystem;
   }

   //---------------------------------------------------------------------------
   public QuantityType getQuantityType()
   {
      if (null == mQuantityType
            && CollectionUtil.hasValues(getSubUnits())
            && 1 == getSubUnits().size())
      {
         mQuantityType = getSubUnits().get(0).getUnit().getQuantityType();
      }

      return mQuantityType;
   }

   //---------------------------------------------------------------------------
   public Integer getPow()
   {
      if (null == mPow
            && CollectionUtil.hasValues(getSubUnits())
            && 1 == getSubUnits().size())
      {
         mPow = getSubUnits().get(0).getUnit().getPow();
      }

      return mPow;
   }

   //---------------------------------------------------------------------------
   public boolean hasSubUnits()
   {
      return CollectionUtil.hasValues(mSubUnits);
   }

   //---------------------------------------------------------------------------
   public List<SubUnit> getSubUnits()
   {
      return mSubUnits;
   }

   //---------------------------------------------------------------------------
   public double computeBaseSIValue(double inValue)
   {
      double value = inValue;

      if (mConversionToBaseSIUnit != null)
      {
         value = mConversionToBaseSIUnit.apply(value);
      }
      else if (hasSubUnits()
               && 1 == getSubUnits().size()
               && getSubUnits().get(0).getUnit().mConversionToBaseSIUnit != null)
      {
         // The unit has a converter but was wrapped by another unit
         value = getSubUnits().get(0).getUnit().mConversionToBaseSIUnit.apply(value);
      }
      else if (getMeasurementSystem() != null
               && (getMeasurementSystem().equals(MeasurementSystem.Metric)
                   || getMeasurementSystem().equals(MeasurementSystem.SI)))
      {
         // Put the value in SI base units by scaling
         Map<QuantityType, SI_ScalingFactor> scalingFactorMap = new HashMap<>(3);

         if (getQuantityType() != null
             || ! hasSubUnits())
         {
            scalingFactorMap.put(getQuantityType(), SI_ScalingFactor.one);
         }
         else
         {
            for (SubUnit subUnit : getSubUnits())
            {
               QuantityType quantityType = subUnit.getUnit().getQuantityType();
               scalingFactorMap.put(quantityType, SI_ScalingFactor.one);
            }
         }

         value = computeScaledValue(value, scalingFactorMap);
      }
      else
      {
         throw new UnitException("Couldn't convert " + name() + " to base SI units! No converter specified.");
      }

      return value;
   }

   //---------------------------------------------------------------------------
   public double computeValueFromBaseSIValue(double inValue)
   {
      double value = inValue;

      if (CollectionUtil.hasValues(getSubUnits()))
      {
         for (SubUnit subUnit : getSubUnits())
         {
            if (subUnit.getScalingFactor() != null)
            {
               if (subUnit.getPow() != null
                     && subUnit.getPow() < 0)
               {
                  value *= subUnit.getScalingFactor().getScalingFactor();
               }
               else
               {
                  value = value / subUnit.getScalingFactor().getScalingFactor();
               }
            }
         }
      }

      if (mConversionToBaseSIUnit != null)
      {
         value = mConversionToBaseSIUnit.reverse(value);
      }

      return value;
   }

   //---------------------------------------------------------------------------
   public double computeScaledValue(double inValue, Map<QuantityType, SI_ScalingFactor> inScalingFactorMap)
   {
      BigDecimal value = allocateBigDecimal(inValue);

      if (CollectionUtil.hasValues(getSubUnits()))
      {
         for (SubUnit subUnit : getSubUnits())
         {
            SI_ScalingFactor scalingFactor = inScalingFactorMap.get(subUnit.getUnit().getQuantityType());
            if (scalingFactor != null)
            {
               BigDecimal adjustedScalingFactor = allocateBigDecimal(scalingFactor.getScalingFactor())
                     .multiply(allocateBigDecimal(subUnit.getScalingFactor() != null ? subUnit.getScalingFactor().getScalingFactor() : 1d));

               if (subUnit.getPow() != null
                     && subUnit.getPow() < 0)
               {
                  value = value.divide(adjustedScalingFactor, getMathContext());
               }
               else
               {
                  value = value.multiply(adjustedScalingFactor);
               }
            }
         }
      }
      else
      {
         SI_ScalingFactor scalingFactor = inScalingFactorMap.get(getQuantityType());
         if (scalingFactor != null)
         {
            if (getPow() != null
                  && getPow() < 0)
            {
               value = value.multiply(allocateBigDecimal(scalingFactor.getScalingFactor()));
            }
            else
            {
               value = value.divide(allocateBigDecimal(scalingFactor.getScalingFactor()), getMathContext());
            }
         }
      }

      return value.doubleValue();
   }

   //---------------------------------------------------------------------------
   public String computeUnitLabel(Map<QuantityType, SI_ScalingFactor> inScalingFactorMap, boolean isPlural)
   {
      StringBuilderPlus buffer = new StringBuilderPlus().setDelimiter(" ");

      if (! CollectionUtil.hasValues(inScalingFactorMap)
          && StringUtil.isSet(getAbbrev()))
      {
         buffer.delimitedAppend(isPlural && StringUtil.isSet(getPluralAbbrev()) ? getPluralAbbrev() : getAbbrev());
      }
      else
//      if (StringUtil.isSet(getAbbrev())
//            || ! hasSubUnits())
      if (! hasSubUnits()
//          || (1 == getSubUnits().size()))
          || getQuantityType() != null)
      {
         String prefix = "";
         if (CollectionUtil.hasValues(inScalingFactorMap))
         {
            SI_ScalingFactor scalingFactor = inScalingFactorMap.get(getQuantityType());
            if (scalingFactor != null)
            {
               prefix = scalingFactor.getSymbol();
            }
         }

         buffer.delimitedAppend(prefix + toString());
         if (getPow() != null)
         {
            buffer.append(StringUtil.toSuperscript(getPow()));
         }
      }
      else
      {
         for (SubUnit subUnit : getSubUnits())
         {
            String prefix = "";
            boolean prefixApplied = false;
            if (inScalingFactorMap != null)
            {
               SI_ScalingFactor scalingFactor = inScalingFactorMap.get(subUnit.getUnit().getQuantityType());
               if (scalingFactor != null)
               {
                  prefix = scalingFactor.getSymbol();
                  prefixApplied = true;
               }
            }

            if (subUnit.getPow() != null
                && subUnit.getPow().equals(-1)
                && 2 == getSubUnits().size()
                && 1 == getSubUnits().indexOf(subUnit)
                && (null == getSubUnits().get(0).getPow()
                    ||  getSubUnits().get(0).getPow() > 0))
            {
               buffer.append("/" + prefix);
               if (! prefixApplied
                   && subUnit.getScalingFactor() != null)
               {
                  buffer.append(subUnit.getScalingFactor().getSymbol());
               }
               buffer.append(subUnit.getUnit().getAbbrev());
            }
            else
            {
               buffer.delimitedAppend(prefix);
               if (! prefixApplied
                   && subUnit.getScalingFactor() != null)
               {
                  buffer.append(subUnit.getScalingFactor().getSymbol());
               }

               buffer.append(subUnit.getUnit().getAbbrev());

               if (subUnit.getPow() != null)
               {
                  buffer.append(StringUtil.toSuperscript(subUnit.getPow()));
               }
            }

         }
      }

      return buffer.toString();
   }

   //---------------------------------------------------------------------------
   public Unit getNumerator()
   {
      Unit numerator = null;

      if (CollectionUtil.hasValues(getSubUnits()))
      {
         List<SubUnit> numeratorSubUnits = new ArrayList<>(4);

         for (SubUnit subUnit : getSubUnits())
         {
            if (null == subUnit.getPow()
                || subUnit.getPow() > 0)
            {
               if (subUnit.getUnit().hasSubUnits()
                   && ! subUnit.getUnit().getQuantityType().equals(QuantityType.VOLUME)) // Don't unroll L to dm3
               {
                  for (SubUnit subSubUnit : subUnit.getUnit().getSubUnits())
                  {
                     if (null == subSubUnit.getPow()
                           || subSubUnit.getPow() > 0)
                     {
                        numeratorSubUnits.add(new SubUnit(subSubUnit.getUnit(), subUnit.getScalingFactor(), subUnit.getPow()));
                     }
                  }
               }
               else
               {
                  numeratorSubUnits.add(subUnit);
               }
            }
         }

         if (CollectionUtil.hasValues(numeratorSubUnits))
         {
            numerator = Unit.valueOf(numeratorSubUnits);
         }
      }
      else if (null == getPow()
            || getPow() > 0)
      {
         numerator = this;
      }

      return numerator;
   }

   //---------------------------------------------------------------------------
   public Unit getDenominator()
   {
      Unit denominator = null;

      if (CollectionUtil.hasValues(getSubUnits()))
      {
         List<SubUnit> denominatorSubUnits = new ArrayList<>(4);
         for (SubUnit subUnit : getSubUnits())
         {

            if (subUnit.getUnit().hasSubUnits()
                  && subUnit.getUnit().getSubUnits().size() > 1) // or L will unroll into dm3
            {
               for (SubUnit subSubUnit : subUnit.getUnit().getSubUnits())
               {
                  if (subSubUnit.getPow() != null
                        && subSubUnit.getPow() < 0)
                  {
                     // Don't use the scaling factor of the parent subunit
                     denominatorSubUnits.add(new SubUnit(subSubUnit.getUnit(), subSubUnit.getScalingFactor(), subSubUnit.getPow().equals(-1) ? null : -subSubUnit.getPow()));
                  }
               }
            }
            else if (subUnit.getPow() != null
                  && subUnit.getPow() < 0)
            {
               denominatorSubUnits.add(new SubUnit(subUnit.getUnit(), subUnit.getScalingFactor(), subUnit.getPow().equals(-1) ? null : -subUnit.getPow()));
            }
         }

         if (CollectionUtil.hasValues(denominatorSubUnits))
         {
            denominator = Unit.valueOf(denominatorSubUnits);
         }
      }
      else if (getPow() != null
            && getPow() < 0)
      {
         if (getPow().equals(-1))
         {
            denominator = Unit.valueOf(getAbbrev());
         }
         else
         {
            denominator = Unit.valueOf(new SubUnit(this, -getPow()));
         }
      }

      return denominator;
   }

   //###########################################################################
   // PRIVATE METHODS
   //###########################################################################

   //---------------------------------------------------------------------------
   private BigDecimal allocateBigDecimal(double inValue)
   {
      return new BigDecimal(Double.toString(inValue), getMathContext());
   }

   //---------------------------------------------------------------------------
   // This is done to ensure that calls to values() and valueOf() have registered values to work with.
   // The file /META-DATA/services/com.hfg.units.Unit holds the names of the classes to be initialized.
   // (Had to create a custom ServiceLoader that doesn't try to instantiate the properties but just
   // calls Class.forName() to initialize the static definitions.)
   private static void ensureExtendingClassesAreInitialized()
   {
      if (! sInitialized)
      {
         try
         {
            new UnitServiceLoader().load();
         }
         catch (Exception e)
         {
            // Ignore
         }

         sInitialized = true;
      }
   }


   //---------------------------------------------------------------------------
   private static List<SubUnit> parseNumeratorBlockOfUnits(String inString)
   {
      List<SubUnit> subUnits = new ArrayList<>(4);

      String[] pieces = inString.split("\\s+");
      String unparsableBit = null;
      for (String piece : pieces)
      {
         if (StringUtil.isSet(unparsableBit))
         {
            piece = unparsableBit + " " + piece;
         }

         SubUnit subUnit = parseSubUnit(piece);
         if (null == subUnit)
         {
            // Not recognized? Perhaps it's part of a multi-word unit?
            unparsableBit = piece;
         }
         else
         {
            unparsableBit = null;

            // Special nasty case: 'fl oz' can get misinterpreted as femto liters and ounce.
            if (subUnit.getUnit().equals(MassUnit.ounce)
                && subUnits.size() > 0
                && subUnits.get(subUnits.size() - 1).getUnit().equals(VolumeUnit.liter)
                && subUnits.get(subUnits.size() - 1).getScalingFactor().equals(SI_ScalingFactor.femto))
            {
               subUnits.remove(subUnits.size() - 1);
               subUnit = new SubUnit(VolumeUnit.fluid_ounce, subUnit.getPow());
            }

            subUnits.add(subUnit);
         }
      }

      if (StringUtil.isSet(unparsableBit))
      {
         // Special nasty case: "mole equivalent"
         if (unparsableBit.equalsIgnoreCase("equivalent")
             && 1 == subUnits.size()
             && subUnits.get(0).equals(AmountOfSubstanceUnit.mole))
         {
            subUnits.set(0, new SubUnit(AmountOfSubstanceUnit.mole_equivalent));
         }
         // Special nasty case: "fluid dram". 'fl' can get misinterpreted as femto liters.
         else if (unparsableBit.equalsIgnoreCase("dr")
             && 1 == subUnits.size()
             && subUnits.get(0).getUnit().equals(VolumeUnit.liter)
             && subUnits.get(0).getScalingFactor().equals(SI_ScalingFactor.femto))
         {
            subUnits.set(0, new SubUnit(VolumeUnit.fluid_dram));
         }
         else
         {
            throw new UnitParseException("Couldn't match " + StringUtil.singleQuote(unparsableBit) + " to a unit!");
         }
      }

      return subUnits;
   }

   //---------------------------------------------------------------------------
   private static List<SubUnit> parseDenominatorBlockOfUnits(String inString)
   {
      List<SubUnit> subUnits = new ArrayList<>(4);

      String[] pieces = inString.split("\\s+");
      String unparsableBit = null;
      for (String piece : pieces)
      {
         if (StringUtil.isSet(unparsableBit))
         {
            piece = unparsableBit + " " + piece;
         }

         SubUnit subUnit = parseSubUnit(piece);
         if (null == subUnit)
         {
            // Not recognized? Perhaps it's part of a multi-word unit?
            unparsableBit = piece;
         }
         else
         {
            unparsableBit = null;

            // Special nasty case: 'fl oz' can get misinterpreted as femto liters and ounce.
            if (subUnit.getUnit().equals(MassUnit.ounce)
                  && subUnits.size() > 0
                  && subUnits.get(subUnits.size() - 1).getUnit().equals(VolumeUnit.liter)
                  && subUnits.get(subUnits.size() - 1).getScalingFactor().equals(SI_ScalingFactor.femto))
            {
               subUnits.remove(subUnits.size() - 1);
               subUnit = new SubUnit(VolumeUnit.fluid_ounce, subUnit.getPow());
            }

            Integer pow = subUnit.getPow();
            if (pow != null)
            {
               pow = - pow;
            }
            else
            {
               pow = -1;
            }

            subUnits.add(new SubUnit(subUnit.getUnit(), subUnit.getScalingFactor(), pow));
         }
      }

      if (StringUtil.isSet(unparsableBit))
      {
         throw new UnitParseException("Couldn't match " + StringUtil.singleQuote(unparsableBit) + " to a unit!");
      }

      return subUnits;
   }

   //---------------------------------------------------------------------------
   private static SubUnit parseSubUnit(String inString)
   {
      SubUnit subUnit = null;

      String string = inString;
      Integer pow = extractPow(string);

      Unit unit = null;
      SI_ScalingFactor scalingFactor = null;

      if (pow != null)
      {
         // Remove the pow from the end of the string
         string = string.substring(0, string.length() - pow.toString().length());
      }

      // Attempt to match using unit abbreviations
      for (Unit unitValue : sInstances)
      {
         if (StringUtil.isSet(unitValue.getAbbrev())
               && string.endsWith(unitValue.getAbbrev()))
         {
            // Is there a prefix?
            int endIndex = string.length() - unitValue.getAbbrev().length();
            if (endIndex > 0)
            {
               if (unitValue.getMeasurementSystem().equals(MeasurementSystem.SI)
                     || unitValue.getMeasurementSystem().equals(MeasurementSystem.Metric))
               {
                  String prefix = string.substring(0, endIndex);
                  SI_ScalingFactor matchingScalingFactor = SI_ScalingFactor.valueOf(prefix);
                  if (matchingScalingFactor != null)
                  {
                     // We found a match
                     unit = unitValue;
                     scalingFactor = matchingScalingFactor;
                     break;
                  }
               }
            }
            else
            {
               // We found a match that has no scaling factor
               unit = unitValue;
               break;
            }
         }
      }

      if (null == unit)
      {
         // Attempt to match using unit names
         for (String key : sLookupMap.keySet())
         {
            if (StringUtil.isSet(key))
            {
               // Does the string end with the unit name?
               if (Pattern.compile(key + "$", Pattern.CASE_INSENSITIVE).matcher(string).find())
               {
                  Unit unitValue = sLookupMap.get(key);

                  // Is there a prefix?
                  int endIndex = string.length() - key.length();
                  if (endIndex > 0)
                  {
                     String prefix = string.substring(0, endIndex);
                     SI_ScalingFactor matchingScalingFactor = SI_ScalingFactor.valueOf(prefix);
                     if (matchingScalingFactor != null)
                     {
                        // We found a match
                        unit = unitValue;
                        scalingFactor = matchingScalingFactor;
                        break;
                     }
                  }
                  else
                  {
                     // We found a match that has no scaling factor
                     unit = unitValue;
                     break;
                  }
               }
            }
         }
      }

      if (null == unit
          && inString.endsWith("s"))
      {
         // The units may have been pluralized
         subUnit = parseSubUnit(inString.substring(0, inString.length() - 1));
      }

      if (null == unit
          && inString.endsWith("."))
      {
         // The units may have had a period at the end of its abbreviation
         subUnit = parseSubUnit(inString.substring(0, inString.length() - 1));
      }


      return (subUnit != null ? subUnit : unit != null ? new SubUnit(unit, scalingFactor, pow) : null);
   }

   //---------------------------------------------------------------------------
   private static Integer extractPow(String inString)
   {
      StringBuilder buffer = new StringBuilder();
      for (int i = inString.length() - 1; i > 0; i--)
      {
         Character superscriptChar = null;
         switch (inString.charAt(i))
         {
            case '\u207B':
               superscriptChar = '-';
               break;
            case '\u2070':
               superscriptChar = '0';
               break;
            case 0xB9:
               superscriptChar = '1';
               break;
            case 0xB2:
               superscriptChar = '2';
               break;
            case 0xB3:
               superscriptChar = '3';
               break;
            case '\u2074':
               superscriptChar = '4';
               break;
            case '\u2075':
               superscriptChar = '5';
               break;
            case '\u2076':
               superscriptChar = '6';
               break;
            case '\u2077':
               superscriptChar = '7';
               break;
            case '\u2078':
               superscriptChar = '8';
               break;
            case '\u2079':
               superscriptChar = '9';
               break;
         }

         if (superscriptChar != null)
         {
            buffer.insert(0, superscriptChar);
         }
         else
         {
            break;
         }
      }

      return (buffer.length() > 0 ? Integer.parseInt(buffer.toString()) : null);
   }

}