package org.apidesign.apifest08.currency;

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.util.Collections;

import java.util.Currency;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

/**

 * A composite convertor allows conversions between many currencies by forwarding conversion requests to stored convertors.

 * A composite convertor will build all possible conversions that are allowed by the underlying set of convertors.

 *

 * @author D'Arcy Smith

 * @verson 1.0

 */

final class CompositeConvertorImpl

    implements Convertor

{

    /**

     * The convertors that are supported.

     */

    private final Convertor[] convertors;

    /**

     * Keeps track of what convertors to use to convert between currencies.

     */

    private final Map<Currency, Map<Currency, Convertor>> possibleConversions;

    {

        possibleConversions = new HashMap<Currency, Map<Currency, Convertor>>();

    }

    /**

     * Construct a ComositeConvertorImpl with the specified convertors.

     * This will result in all possible conversions between the supplied currencies being made.

     * 

     * @param cs the convertors to use.

     * @throws IllegalArgumentException if any of the items in cs are null.

     */

    CompositeConvertorImpl(Convertor ... cs)

    {

        int newConvertors;

        convertors = cs;

        // track all of the known conversion

        for(final Convertor convertor : convertors)

        {

            final Set<Currency>      currencies;

            Map<Currency, Convertor> possible;

            if(convertor == null)

            {

                throw new IllegalArgumentException("cs cannot contain null");

            }

            currencies = convertor.getCurrencies();

            for(final Currency currency : currencies)

            {

                possible = possibleConversions.get(currency);

                if(possible == null)

                {

                    possible = new HashMap<Currency, Convertor>();

                    possibleConversions.put(currency, possible);

                }

                for(final Currency c : currencies)

                {

                    possible.put(c, convertor);

                }

            }

        }

        // make up conversions that can be derived... eg:

        //   we have:

        //      USD <-> CAD

        //      CAD <-> CZK

        //      SSK <-> GBP

        //   we can derive:

        //      USD <-> CZK

        //   we cannot derive:

        //      USD <-> GBP

        //      CAD <-> GBP

        //      CZK <-> GBP

        do

        {

            newConvertors = 0;

            // todo... need to loop this until all the ones that can be handled are done.

            for(final Currency from : getCurrencies())

            {

                for(final Currency to : getCurrencies())

                {

                    if(!(canConvert(from, to)))

                    {

                        final Set<Currency> fromCurrencies;

                        final Set<Currency> toCurrencies;

                        final Set<Currency> common;

                        fromCurrencies = possibleConversions.get(from).keySet();

                        toCurrencies   = possibleConversions.get(to).keySet();

                        common         = new HashSet<Currency>();

                        for(final Currency currency : fromCurrencies)

                        {

                            if(toCurrencies.contains(currency))

                            {

                                common.add(currency);

                            }

                        }

                        for(final Currency currency : common)

                        {

                            final Convertor convertor;

                            convertor = createConvertor(from, to, currency);

                            possibleConversions.get(from).put(to, convertor);

                            possibleConversions.get(to).put(from, convertor);

                            newConvertors++;

                        }

                    }

                }

            }

        }

        while(newConvertors > 0);

    }

    /**

     * 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)

    {

        final Map<Currency, Convertor> possible;

        if(from == null)

        {

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

        }

        if(to == null)

        {

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

        }

        possible = possibleConversions.get(from);

        if(possible.containsKey(to))

        {

            return (true);

        }

        return (false);

    }

    /**

     * Get the currencies that the convertor supports.  Just because a currency is

     * supported does not mean that canConvert will return true.

     * 

     * @return the supported currencies.

     */

    public Set<Currency> getCurrencies()

    {

        final Set<Currency> currencies;

        currencies = possibleConversions.keySet();

        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 IllegalArgumentException if either from or to is null.

     * @throws InvalidConversionException if canConvert would return false.

     */

    public BigDecimal getConversionRate(final Currency from, final Currency to)

        throws InvalidConversionException

    {

        final Map<Currency, Convertor> possible;

        Convertor                      convertor;

        if(from == null)

        {

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

        }

        if(to == null)

        {

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

        }

        if(!(canConvert(from, to)))

        {

            throw new InvalidConversionException("cannot convert", to);

        }

        possible  = possibleConversions.get(from);

        convertor = possible.get(to);

        if(convertor == null)

        {

            throw new Error();

        }

        return (convertor.getConversionRate(from, to));

    }

    /**

     * 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 valid for the convertor.

     */

    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");

        }

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

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

    }

    /**

     * Create a convertor between two currencies using another currency that is able to convert between both.

     * 

     * @param from the currency to convert from.

     * @param to the currency to convert to.

     * @param intermediary the currency to use as a go-between.

     * @return a Convertor that is able to convert between from an to.

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

     */

    private Convertor createConvertor(final Currency from,

                                      final Currency to,

                                      final Currency intermediary) 

    {

        final Convertor fromIntermediary;

        final Convertor toIntermediary;

        if(from == null)

        {

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

        }

        if(to == null)

        {

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

        }

        if(intermediary == null)

        {

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

        }

        fromIntermediary = possibleConversions.get(from).get(intermediary);

        toIntermediary   = possibleConversions.get(to).get(intermediary);

        try

        {

            final BigDecimal fromRate;

            final BigDecimal toRate;

            final BigDecimal rate;

            final Convertor  convertor;

            fromRate  = fromIntermediary.getConversionRate(from, intermediary);

            toRate    = toIntermediary.getConversionRate(intermediary, to);

            rate      = fromRate.multiply(toRate);

            convertor = ConvertorFactory.getConvertor(from, BigDecimal.ONE, to, rate);

            return (convertor);

        }

        catch (InvalidConversionException ex)

        {

            throw new Error();

        }

    }

}