package org.apidesign.apifest08.currency;

import java.math.BigDecimal;

import java.util.Currency;

import java.util.Date;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

final class DatedCompositeConvertorImpl

    implements TimedConvertor

{

    /**

     * The convertors that are supported.

     */

    private final DatedConvertor[] convertors;

    /**

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

     */

    private final Map<DateRange, Map<Currency, Map<Currency, Convertor>>> datedConversions;

    {

        datedConversions = new HashMap<DateRange, Map<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.

     */

    DatedCompositeConvertorImpl(Convertor ... cs)

    {

        int i;

        convertors = new DatedConvertor[cs.length];

        i          = 0;

        for(final Convertor c : cs)

        {

            if(!(c instanceof DatedConvertor))

            {

                throw new IllegalArgumentException("cs must only contain DatedConvertors");

            }

            convertors[i] = (DatedConvertor)c;

            i++;

        }

        // track all of the known conversion

        for(final DatedConvertor convertor : convertors)

        {

            final Set<Currency>      currencies;

            Map<Currency, Convertor> possible;

            DateRange                range;

            if(convertor == null)

            {

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

            }

            currencies = convertor.getCurrencies();

            range      = convertor.getDateRange();

            for(final Currency currency : currencies)

            {

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

                possibleConversions = datedConversions.get(range);

                if(possibleConversions == null)

                {

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

                    datedConversions.put(range, possibleConversions);

                }

                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        

        // 

        // NOTE: no attempt is made to deal with dates for DatedConvertors... nothing we can do about it.

        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;

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

                        possibleConversions.get(range);

                        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)

    {

        throw new UnsupportedOperationException();

    }

    /**

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

    {

        throw new UnsupportedOperationException();

    }

    /**

     * 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

    {

        throw new UnsupportedOperationException();

    }

    private Convertor getConvertor(final Currency from, final Currency to, final Date date)

    {

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

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

        }

        possibleConversions = null;

        for(final DateRange range : datedConversions.keySet())

        {

            if(range.isInRange(date))

            {

                possibleConversions = datedConversions.get(range);

                break;

            }

        }

        if(possibleConversions == null)

        {

            return (null);

        }

        possible  = possibleConversions.get(from);

        if(possible == null)

        {

            return (null);

        }

        convertor = possible.get(to);

        if(convertor == null)

        {

            return (null);

        }

        return (convertor);

    }

    /**

     * 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

    {

        throw new InvalidConversionException("No date for the conversion", from);

    }

    public BigDecimal convert(final Currency   from, 

                              final Currency   to, 

                              final BigDecimal amount, 

                              final Date       date) 

        throws InvalidConversionException 

    {

        final Convertor  convertor;

        final BigDecimal total;

        convertor = getConvertor(from, to, date);

        if(convertor == null)

        {

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

        }

        if(canConvert(from, to, date))

        {

            final TimedConvertor timeConvertor;

            timeConvertor = (TimedConvertor)convertor;

            total         = timeConvertor.convert(from, to, amount, date);

        }

        else

        {

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

        }

        return (total);

    }

    public boolean canConvert(final Currency from,

                              final Currency to,

                              final Date     date)

    {

        Convertor     convertor;

        final boolean retVal;

        convertor = getConvertor(from, to, date);

        if(convertor != null)

        {

            final TimedConvertor timeConvertor;

            timeConvertor = (TimedConvertor)convertor;

            retVal        = timeConvertor.canConvert(from, to, date);

        }

        else

        {

            retVal = false;

        }

        return (retVal);

    }

}