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

     }

 }