package com.hfg.chem;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;

import com.hfg.util.CompareUtil;
import com.hfg.util.StringUtil;
import com.hfg.util.collection.CollectionUtil;
import com.hfg.util.collection.OrderedMap;

//------------------------------------------------------------------------------
/**
 Container for elemental composition 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 ElementalComposition implements Comparable
{
   private Map<Element, Float> mMap = new OrderedMap<>(10);
   private String mChemicalFormula;

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

   //--------------------------------------------------------------------------
   public ElementalComposition()
   {

   }

   //--------------------------------------------------------------------------
   public ElementalComposition(Map<Element, Float> inMap)
   {
      add(inMap);
   }

   //--------------------------------------------------------------------------
   public ElementalComposition(Map<Element, Float> inMap, int inNum)
   {
      add(inMap, inNum);
   }

   //--------------------------------------------------------------------------
   public ElementalComposition(ElementalComposition inElementalComposition)
   {
      add(inElementalComposition);
   }

   //--------------------------------------------------------------------------
   public ElementalComposition(ElementalComposition inElementalComposition, int inNum)
   {
      add(inElementalComposition, inNum);
   }

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


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

   //--------------------------------------------------------------------------
   @Override
   public int hashCode()
   {
      int hashcode = 31;
      for (Element element : mMap.keySet())
      {
         hashcode = hashcode + 31 * element.hashCode() * mMap.get(element).intValue();
      }

      return hashcode;
   }

   //--------------------------------------------------------------------------
   @Override
   public boolean equals(Object inObj)
   {
      boolean result = false;

      if (inObj != null)
      {
         result = (0 == compareTo(inObj));
      }

      return result;
   }

   //--------------------------------------------------------------------------
   @Override
   public int compareTo(Object inObj)
   {
      int result = -1;

      if (inObj instanceof ElementalComposition)
      {
         result = CompareUtil.compare(getChemicalFormula(), ((ElementalComposition)inObj).getChemicalFormula());
      }

      return result;
   }

   //--------------------------------------------------------------------------
   public Collection<Element> keySet()
   {
      return mMap != null ? mMap.keySet() : null;
   }

   //--------------------------------------------------------------------------
   public Map<Element, Float> toMap()
   {
      return mMap != null ? Collections.unmodifiableMap(mMap) : null;
   }

   //--------------------------------------------------------------------------
   public Float get(Element inElement)
   {
      return mMap != null ? mMap.get(inElement) : null;
   }

   //--------------------------------------------------------------------------
   public Float put(Element inElement, int inCount)
   {
      return put(inElement, (float) inCount);
   }

   //--------------------------------------------------------------------------
   public Float put(Element inElement, float inCount)
   {
      clearCalculatedProperties();

      if (null == mMap)
      {
         mMap = new OrderedMap<>(10);
      }

      return mMap.put(inElement, inCount);
   }

   //--------------------------------------------------------------------------
   public ElementalComposition add(ElementalComposition inValue)
   {
      return add(inValue, 1);
   }

   //--------------------------------------------------------------------------
   public ElementalComposition add(ElementalComposition inValue, int inNum)
   {
      if (inValue != null
          && CollectionUtil.hasValues(inValue.mMap))
      {
         for (Element element : inValue.keySet())
         {
            addAtoms(element, inValue.get(element) * inNum);
         }
      }

      return this;
   }

   //--------------------------------------------------------------------------
   public ElementalComposition add(Matter inValue)
   {
      if (inValue != null)
      {
         Map<Element, Float> elementalComposition = inValue.getElementalComposition();
         if (elementalComposition != null)
         {
            add(elementalComposition);
         }
      }

      return this;
   }

   //--------------------------------------------------------------------------
   public ElementalComposition add(Map<Element, Float> inMap)
   {
      return add(inMap, 1);
   }

   //--------------------------------------------------------------------------
   public ElementalComposition add(Map<Element, Float> inMap, int inNum)
   {
      if (CollectionUtil.hasValues(inMap))
      {
         for (Element element : inMap.keySet())
         {
            addAtoms(element, inMap.get(element) * inNum);
         }
      }

      return this;
   }

   //--------------------------------------------------------------------------
   public ElementalComposition addAtoms(Element inElement, int inNum)
   {
      return addAtoms(inElement, new Float(inNum));
   }

   //--------------------------------------------------------------------------
   public ElementalComposition addAtoms(Element inElement, float inNum)
   {
      if (null == mMap)
      {
         mMap = new OrderedMap<>(10);
      }

      Float count = mMap.get(inElement);
      float newCount = inNum + (count != null ? count : 0);

      mMap.put(inElement, newCount);

      clearCalculatedProperties();

      return this;
   }

   //--------------------------------------------------------------------------
   public ElementalComposition remove(Matter inValue)
   {
      return remove(inValue != null ? inValue.getElementalComposition() : null, 1);
   }

   //--------------------------------------------------------------------------
   public ElementalComposition remove(Map<Element, Float> inMap)
   {
      return remove(inMap, 1);
   }

   //--------------------------------------------------------------------------
   public ElementalComposition remove(Map<Element, Float> inMap, int inNum)
   {
      if (CollectionUtil.hasValues(inMap))
      {
         for (Element element : inMap.keySet())
         {
            addAtoms(element, inMap.get(element) * -inNum);
         }
      }

      return this;
   }

   //--------------------------------------------------------------------------
   public ElementalComposition remove(ElementalComposition inValue)
   {
      return remove(inValue, 1);
   }

   //--------------------------------------------------------------------------
   public ElementalComposition remove(ElementalComposition inValue, int inNum)
   {
      if (inValue != null)
      {
         for (Element element : inValue.keySet())
         {
            addAtoms(element, - inValue.get(element) * inNum);
         }
      }

      return this;
   }

   //--------------------------------------------------------------------------
   public void clear()
   {
      mMap = null;
      clearCalculatedProperties();
   }

   //--------------------------------------------------------------------------
   /**
    Returns a chemical formula String like 'C5H11NO'. If carbon is present, it
    is listed first followed by the other elements in ascending mass order.
    Symbols for isotopes are enclosed in square brackets such as '[2H]2O'
    for deuterated water.
    @return the chemical formula string
    */
   public String getChemicalFormula()
   {
      if (null == mChemicalFormula)
      {
         mChemicalFormula = getChemicalFormula(false);
      }

      return mChemicalFormula;
   }

   //--------------------------------------------------------------------------
   /**
    Returns a chemical formula String like 'C₅H₁₁NO'. If carbon is present, it
    is listed first followed by the other elements in ascending mass order.
    Symbols for isotopes are enclosed in square brackets such as '[²H]₂O'
    for deuterated water.
    @return the chemical formula string
    */
   public String getChemicalFormulaWithSubscripts()
   {
      return getChemicalFormula(true);
   }

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

   //--------------------------------------------------------------------------
   private void clearCalculatedProperties()
   {
      mChemicalFormula = null;
   }

   //--------------------------------------------------------------------------
   private String getChemicalFormula(boolean inUseSubscripts)
   {
      StringBuilder compositionString = new StringBuilder();
      if (CollectionUtil.hasValues(mMap))
      {
         List<Element> elements = new ArrayList<>(mMap.keySet());
         Collections.sort(elements);

         if (elements.remove(Element.CARBON))
         {
            Float count = mMap.get(Element.CARBON);
            if (count != null && count != 0)
            {
               String countString = (count == count.intValue() ? count.intValue() + "" : String.format("%3.1f", count.floatValue()) + "");
               if (inUseSubscripts)
               {
                  countString = StringUtil.toSubscript(countString);
               }
               compositionString.append("C" + (count == 1 ? "" : (count < 0 ? "(" + countString + ")" : countString)));
            }
         }
         else if (elements.remove(Element.NITROGEN))
         {
            Float count = mMap.get(Element.NITROGEN);
            if (count != null && count != 0)
            {
               String countString = (count == count.intValue() ? count.intValue() + "" : String.format("%3.1f", count.floatValue()) + "");
               if (inUseSubscripts)
               {
                  countString = StringUtil.toSubscript(countString);
               }
               compositionString.append("N" + (count == 1 ? "" : (count < 0 ? "(" + countString + ")" : countString)));
            }
         }

         for (Element element : elements)
         {
            Float count = mMap.get(element);
            // Encode pure isotopes in square brackets like "[²H]" for deuterium
            if (count != null && count != 0)
            {
               String countString = (count == count.intValue() ? count.intValue() + "" : String.format("%3.1f", count.floatValue()) + "");
               String symbol;
               if (null == element)
               {
                  symbol = "*";
               }
               else
               {
                  symbol = element.getSymbol();
                  if (inUseSubscripts)
                  {
                     countString = StringUtil.toSubscript(countString);
                     if (element instanceof Isotope)
                     {
                        symbol = StringUtil.toSuperscript(((Isotope) element).getMassNumber()) + ((Isotope) element).getElement().getSymbol();
                     }
                  }
               }

               compositionString.append((element instanceof Isotope ? "[" + symbol + "]" : symbol)
                     + (count == 1 ? "" : (count < 0 ? "(" + countString + ")" : countString)));
            }
         }
      }

      return compositionString.length() > 0 ? compositionString.toString() : null;
   }

}