package org.apidesign.apifest08.currency;

import java.math.BigDecimal;

import java.math.MathContext;

import java.math.RoundingMode;

import java.util.Collections;

import java.util.Currency;

import java.util.HashSet;

import java.util.Set;

/**

 * Convert between two currencies.

 *

 * @author D'Arcy Smith

 * @version 1.0

 */

final class ConvertorImpl

    implements Convertor

{

    /**

     * The currency to convert from.

     */

    private final Currency currencyA;

    /**

     * The currency to convert to.

     */

    private final Currency currencyB;

    /**

     * The echange rate between a and b.

     */

    private final BigDecimal currencyARate;

    /**

     * The echange rate between b and a.

     */

    private final BigDecimal currencyBRate;

    /**

     * Constructs a convertor with the specified currencies.

     * 

     * @param a the currency to convert from.

     * @param aRate the exchage rage between from and to.

     * @param b the currency to convert to.

     * @param bRate the exchage rage between to and from.

     * @throws IllegalArgumentException if either any of the arguments are null or if either rate <= 0.

     */

    public ConvertorImpl(final Currency   a,

                         final BigDecimal aRate,

                         final Currency   b,

                         final BigDecimal bRate)

    {

        if(a == null)

        {

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

        }

        if(b == null)

        {

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

        }

        if(aRate == null)

        {

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

        }

        if(bRate == null)

        {

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

        }

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

        {

            throw new IllegalArgumentException("aRate must be > 0, was: " + aRate);

        }

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

        {

            throw new IllegalArgumentException("bRate must be > 0, was: " + bRate);

        }

        currencyA     = a;

        currencyB     = b;

        currencyARate = aRate;

        currencyBRate = bRate;

    }

    /**

     * Convert an amount from one currency to another.

     * 

     * @param from the currency to convert from.

     * @param to the currency to convert to.

     * @param amount the amount to convert.

     * @return the converted amount.

     * @throws IllegalArgumentException if any of the arguments are null.

     * @throws InvalidConversionException if either from or to are not equal to the currencies passed to the constructor.

     */

    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 

        {

            final BigDecimal rateX;

            final BigDecimal rateY;

            final BigDecimal temp;

            if(from.equals(currencyA))

            {

                rateX = currencyARate;

                rateY = currencyBRate;

            }

            else

            {

                rateX = currencyBRate;

                rateY = currencyARate;

            }

            temp = BigDecimal.ONE.divide(rateX, MathContext.DECIMAL64);

            rate = temp.multiply(rateY);

        }

        return (rate.setScale(20, RoundingMode.HALF_EVEN));

    }

    /**

     * Check to see if two ConvertorImpls are equal.

     *

     * @param obj the object to check

     * @return if the ConvertorImpls are not the same (cuyrrencies and rates).

     */

    @Override

    public boolean equals(Object obj)

    {

        if (obj == null)

        {

            return false;

        }

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

        {

            return false;

        }

        final ConvertorImpl other = (ConvertorImpl) obj;

        // it would be nice if NetBeans could chck to see if the variable is final and guaranteed not to be null... but that

        // would likely be tricky... but in a NetBeans engineer reads that see if you can do it :-)

        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.currencyARate != other.currencyARate && (this.currencyARate == null || !this.currencyARate.equals(other.currencyARate)))

        {

            return false;

        }

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

        {

            return false;

        }

        return true;

    }

    /**

     * Get the hashCode of the Convertor.

     *

     * @return the hashCode of the convertor.

     */

    @Override

    public int hashCode()

    {

        int hash = 7;

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

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

        hash = 37 * hash + (this.currencyARate != null ? this.currencyARate.hashCode() : 0);

        hash = 37 * hash + (this.currencyBRate != null ? this.currencyBRate.hashCode() : 0);

        return hash;

    }

    /**

     * Get the currencyCode of both currencies.

     *

     * @return the currency codes of both currencies.

     */

    @Override

    public String toString()

    {

        return (currencyA.getCurrencyCode() + " to " + currencyB.getCurrencyCode());

    }

}