package org.apidesign.apifest08.currency;

 import java.math.BigDecimal;

 import java.math.RoundingMode;

 import java.util.Collections;

 import java.util.Currency;

 import java.util.HashSet;

 import java.util.Set;

 /**

  * The exchange rate between two currencies.

  *

  * @author D'Arcy Smith

  * @version 1.1

  */

 public final class ExchangeRate

 {

     /**

      * 

      */

     private final Currency currencyA;

     /**

      * 

      */

     private final Currency currencyB;

     /**

      * 

      */

     private final BigDecimal rateAtoB;

     /**

      * 

      */

     private final BigDecimal rateBtoA;

     /**

      * Construct an ExchangeRate with the specified values.

      * 

      * @param a the first currency

      * @param b the second currency

      * @param ra the rate to convert a to b

      * @param rb the rate to covertt b to a

      * @throws IllegalArgumentException if any parameter is null.

      */

     public ExchangeRate(final Currency   a,

                         final Currency   b,

                         final BigDecimal ra,

                         final BigDecimal rb)

     {

         if(a == null)

         {

             throw new IllegalArgumentException("a cannot be null");

         }

         if(b == null)

         {

             throw new IllegalArgumentException("b cannot be null");

         }

         if(ra == null)

         {

             throw new IllegalArgumentException("ra cannot be null");

         }

         if(rb == null)

         {

             throw new IllegalArgumentException("rb cannot be null");

         }

         if(ra.compareTo(BigDecimal.ZERO) <= 0)

         {

             throw new IllegalArgumentException("ra cannot be <= 0, was: " + ra);

         }

         if(rb.compareTo(BigDecimal.ZERO) <= 0)

         {

             throw new IllegalArgumentException("rb cannot be <= 0, was: " + ra);

         }

         currencyA = a;

         currencyB = b;

         rateAtoB  = ra;

         rateBtoA  = rb;

     }

     /**

      * Get the first currency.

      * 

      * @return the first currency.

      */

     public Currency getCurrencyA()

     {

         return currencyA;

     }

     /**

      * Get the second currency.

      * 

      * @return the second currency.

      */

     public Currency getCurrencyB()

     {

         return currencyB;

     }

     /**

      * Get the conversion rate from currencyA to currencyB.

      * 

      * @return the conversion rate from currencyA to currencyB.

      */

     public BigDecimal getRateAtoB()

     {

         return rateAtoB;

     }

     /**

      * Get the conversion rate from currencyB to currencyA.

      * 

      * @return the conversion rate from currencyB to currencyA.

      */

     public BigDecimal getRateBtoA()

     {

         return rateBtoA;

     }

     public static ExchangeRate getExchangeRate(final Currency   a,

                                                final Currency   b,

                                                final BigDecimal va,

                                                final BigDecimal vb)

     {

         final BigDecimal   rateAtoB;

         final BigDecimal   rateBtoA;

         final ExchangeRate rate;    

         if(a == null)

         {

             throw new IllegalArgumentException("a cannot be null");

         }

         if(b == null)

         {

             throw new IllegalArgumentException("b cannot be null");

         }

         if(a.equals(b))

         {

             rateAtoB = BigDecimal.ONE;

             rateBtoA = BigDecimal.ONE;

         }

         else 

         {

             rateAtoB = vb.divide(va, 20, RoundingMode.HALF_DOWN);

             rateBtoA = va.divide(vb, 20, RoundingMode.HALF_DOWN);

         }

         rate = new ExchangeRate(a, 

                                 b,

                                 rateAtoB.setScale(20, RoundingMode.HALF_EVEN),

                                 rateBtoA.setScale(20, RoundingMode.HALF_EVEN));

         return (rate);

     }

     public BigDecimal convert(final Currency   from,

                               final Currency   to,

                               final BigDecimal amount)

         throws InvalidConversionException

     {

         final BigDecimal result;

         if(amount == null)

         {

             throw new IllegalArgumentException("amount cannot be null");

         }

         if(from == null)

         {

             throw new IllegalArgumentException("from cannot be null");

         }

         if(to == null)

         {

             throw new IllegalArgumentException("to cannot be null");

         }

         if(!(from.equals(currencyA)) && (!(from.equals(currencyB))))

         {

             throw new InvalidConversionException("cannot convert from: " + from.getCurrencyCode(), from, currencyA, currencyB);

         }

         if(!(to.equals(currencyA)) && (!(to.equals(currencyB))))

         {

             throw new InvalidConversionException("cannot convert to: " + to.getCurrencyCode(), to, currencyA, currencyB);

         }

         result = amount.multiply(getConversionRate(from, to));

         return (result.setScale(2, RoundingMode.HALF_DOWN));

     }

     /**

      * Check to see if converting between the two currencies is possible.

      * 

      * @param from the currency to convert from.

      * @param to the currency to convert to.

      * @return true if the conversion is possible.

      * @throws IllegalArgumentException if either from or to are null.

      */

     public boolean canConvert(final Currency from, final Currency to)

     {

         if(from == null)

         {

             throw new IllegalArgumentException("from cannot be null");

         }

         if(to == null)

         {

             throw new IllegalArgumentException("to cannot be null");

         }

         return ((from.equals(currencyA) || from.equals(currencyB)) &&

                 (to.equals(currencyA)   || to.equals(currencyB)));

     }

     /**

      * Get the currencies that the convertor supports.

      * 

      * @return the supported currencies.

      */

     public Set<Currency> getCurrencies()

     {

         final Set<Currency> currencies;

         currencies = new HashSet<Currency>();

         currencies.add(currencyA);

         currencies.add(currencyB);

         return (Collections.unmodifiableSet(currencies));

     }

     /**

      * Get the conversion rate between two currencies.

      * 

      * @param from the currency to convert from.

      * @param to the currency to convert to.

      * @return the conversion rate between the two currencies.

      * @throws InvalidConversionException if canConvert would return false.

      * @throws IllegalArgumentException if either from or to are null.

      */

     public BigDecimal getConversionRate(final Currency from, 

                                         final Currency to)

         throws InvalidConversionException

     {                

         final BigDecimal rate;

         if(from == null)

         {

             throw new IllegalArgumentException("from cannot be null");

         }

         if(to == null)

         {

             throw new IllegalArgumentException("to cannot be null");

         }

         if(from.equals(to))

         {

             rate = BigDecimal.ONE;

         }

         else 

         {

             if(from.equals(currencyA))

             {

                 rate = rateAtoB;

             }

             else

             {

                 rate = rateBtoA;

             }

         }

         return (rate);

     }

     public String toString()

     {

         return (rateAtoB + " : " + rateBtoA);

     }

     @Override

     public boolean equals(Object obj) {

         if (obj == null) {

             return false;

         }

         if (getClass() != obj.getClass()) {

             return false;

         }

         final ExchangeRate other = (ExchangeRate) obj;

         if (this.currencyA != other.currencyA && (this.currencyA == null || !this.currencyA.equals(other.currencyA))) {

             return false;

         }

         if (this.currencyB != other.currencyB && (this.currencyB == null || !this.currencyB.equals(other.currencyB))) {

             return false;

         }

         if (this.rateAtoB != other.rateAtoB && (this.rateAtoB == null || !this.rateAtoB.equals(other.rateAtoB))) {

             return false;

         }

         if (this.rateBtoA != other.rateBtoA && (this.rateBtoA == null || !this.rateBtoA.equals(other.rateBtoA))) {

             return false;

         }

         return true;

     }

     @Override

     public int hashCode() {

         int hash = 7;

         hash = 97 * hash + (this.currencyA != null ? this.currencyA.hashCode() : 0);

         hash = 97 * hash + (this.currencyB != null ? this.currencyB.hashCode() : 0);

         hash = 97 * hash + (this.rateAtoB != null ? this.rateAtoB.hashCode() : 0);

         hash = 97 * hash + (this.rateBtoA != null ? this.rateBtoA.hashCode() : 0);

         return hash;

     }

 }