/**
    * Copyright 2009 Timothy Johnston Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
    * file except in compliance with the License. You may obtain a copy of the License at
    * 
    * http://www.apache.org/licenses/LICENSE-2.0
    * 
    * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
    * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
    * specific language governing permissions and limitations under the License.
   */
  
  package com.timjohnstondev.unitconverter.model;
  
  import java.math.BigDecimal;
  import java.math.RoundingMode;
  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * A {@code Property}, such as temperature, pressure or length, has units and conversion factors or formulas to convert
   * between the different units.
   */
  public class Property implements Comparable <Property>
  {
    private int order;
    private String name;
    private List <Conversion> conversions = new ArrayList <Conversion>();
    private boolean hasFormula;
    private boolean usesMoles;
  
    /**
     * Constructs a {@code Property} with the given name and specifies if it uses formulas or factors for unit conversion.
     * 
     * @param newName the descriptive name of this {@code Property}
     * @param isFormulaBased determines if this {@code Property} will use formulas or factors for unit conversion
     * @param canUseMoles determines if this {@code Property} can do mole to mass and mass to mole unit conversions
     */
    public Property(final String newName, final boolean isFormulaBased, final boolean canUseMoles)
    {
      name = newName;
      hasFormula = isFormulaBased;
      usesMoles = canUseMoles;
    }
  
    /**
     * Returns this {@code Property}'s sort order
     * 
     * @return the sort order of this property
     */
    public final int getOrder()
    {
      return order;
    }
  
    /**
     * Sets this {@code Property}'s sort order
     * 
     * @param newOrder the new sort order of this property
     */
    public final void setOrder(final int newOrder)
    {
      order = newOrder;
    }
  
    /**
     * Returns this {@code Property}'s name
     * 
     * @return the name of this property
     */
    public final String getName()
    {
      return name;
    }
  
    /**
     * Returns {@code true} if this {@code Property} can do mole to mass and mass to mole unit conversions, else {@code
     * false}
     * 
     * @return {@code true} if this {@code Property} can do mole to mass and mass to mole unit conversions, else {@code
     *         false}
     */
    public final boolean usesMoles()
    {
      return usesMoles;
    }
  
    /**
     * Returns {@code true} if this {@code Property} uses formulas for unit conversion, else {@code false}
     * 
     * @return {@code true} if this {@code Property} uses formulas for unit conversion, else {@code false}
     */
    public final boolean hasFormula()
    {
      return hasFormula;
    }
  
    /**
     * Adds a {@link Conversion} which is a formula or factor that is used to perform unit conversions.
     * 
    * @param conversion factor or formula to perform the conversion
    */
   public final void addConversion(final Conversion conversion)
   {
     conversions.add(conversion);
   }
 
   /**
    * Returns a list of the symbols for this {@code Property}.
    * 
    * @return a list of the symbols
    */
   final List <String> getSymbols()
   {
     final List <String> symbols = new ArrayList <String>();
     for (Conversion conversion : conversions)
     {
       if (!symbols.contains(conversion.getFormattedUnitSymbol()))
       {
         symbols.add(conversion.getFormattedUnitSymbol());
       }
     }
     return symbols;
   }
 
   /**
    * Returns the {@link Conversion} factor or formula for this {@code Property} for going from one set of units to
    * another.
    * 
    * @param fromSymbol the original units
    * @param toSymbol the desired units
    * @return the {@code Conversion} factor or formula to perform the conversion
    */
   final String getConversion(final String fromSymbol, final String toSymbol)
   {
     String result = "";
     if (hasFormula)
     {
       result = getFormula(fromSymbol, toSymbol);
     }
     else
     {
       final BigDecimal fromFactor = new BigDecimal(getConversion(fromSymbol));
       final BigDecimal toFactor = new BigDecimal(getConversion(toSymbol));
       final BigDecimal quotient = toFactor.divide(fromFactor, 30, RoundingMode.HALF_UP);
       result = quotient.stripTrailingZeros().toPlainString();
     }
     return result;
   }
 
   /**
    * Returns this symbol's name in unabbreviated words for this {@code Property}.
    * 
    * @param unitSymbol the symbol that represents the returned name
    * @return the name for this symbol
    */
   final String getUnitName(final String unitSymbol)
   {
     String unitName = "";
     for (Conversion conversion : conversions)
     {
       if (unitSymbol.equals(conversion.getFormattedUnitSymbol()))
       {
         unitName = conversion.getUnitName();
       }
     }
     return unitName;
   }
 
   private String getFormula(final String fromSymbol, final String toSymbol)
   {
     String formula = "";
     for (Conversion conversion : conversions)
     {
       final String fromUnitSymbol = conversion.getUnitSymbol();
       final String toUnitSymbol = ((ConversionFormula) conversion).getToUnitSymbol();
       if (fromSymbol.equals(fromUnitSymbol) && toSymbol.equals(toUnitSymbol))
       {
         formula = conversion.getConversion();
         break;
       }
     }
     return formula;
   }
 
   private String getConversion(final String symbol)
   {
     String value = "";
     for (Conversion conversion : conversions)
     {
       if (symbol.equals(conversion.getFormattedUnitSymbol()))
       {
         value = conversion.getConversion();
         break;
       }
     }
     return value;
   }
 
   /**
    * Updates the unit separator symbol
    * 
    * @param symbol the new unit separator symbol
    */
   public final void setUnitSeparator(final String symbol)
   {
     for (Conversion conversion : conversions)
     {
       conversion.setUnitSeparator(symbol);
     }
   }
 
   @Override
   public final int compareTo(final Property prop)
   {
     return order - prop.getOrder();
   }
 }