package org.apidesign.apifest08.currency;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Set;

 import org.apidesign.apifest08.currency.Computer.ComputerRequest;

 import org.apidesign.apifest08.currency.Computer.ComputerResponse;

 /**

  * Convertor.

  * 

  * In Task 1's version provides conversion between currency values

  * with amount stored in integer or double, that are identified

  * with string value. Exchange rates are immutable.

  * 

  * In Task2's version provides support for multiple exchange rates

  * between different currencies & merging exchange rates from

  * existing convertors into new convertor's instance.

  * No time for javadoc these features, sorry.

  * 

  * @author ked

  */

 public final class Convertor<AmountType, IdentifierType> {

     Computer<AmountType> computer;

     List<ExchangeRateValue<AmountType, IdentifierType>> exchangeRates = new ArrayList<ExchangeRateValue<AmountType, IdentifierType>>();

     Convertor(

             Computer<AmountType> computer,

             Collection<ExchangeRateValue<AmountType, IdentifierType>> exchangeRates) {

         this.computer = computer;

         for (ExchangeRateValue<AmountType, IdentifierType> exchangeRate : exchangeRates) {

             if (findExchangeRate(

                     this.exchangeRates,

                     exchangeRate.getCurrencyA().getIdentifier(),

                     exchangeRate.getCurrencyB().getIdentifier()) != null) {

                 throw new IllegalArgumentException("Duplicate exchange rate!");

             }

             this.exchangeRates.add(exchangeRate);

         }

     }

     private ExchangeRateValue<AmountType, IdentifierType> findExchangeRate(

             Collection<ExchangeRateValue<AmountType, IdentifierType>> exchangeRates,

             IdentifierType currencyA,

             IdentifierType currencyB) {

         for (ExchangeRateValue<AmountType, IdentifierType> exchangeRate : exchangeRates) {

             if ((exchangeRate.getCurrencyA().getIdentifier().equals(currencyA) && exchangeRate.getCurrencyB().getIdentifier().equals(currencyB)) ||

                     (exchangeRate.getCurrencyA().getIdentifier().equals(currencyB) && exchangeRate.getCurrencyB().getIdentifier().equals(currencyA))) {

                 return exchangeRate;

             }

         }

         return null;

     }

     /**

      * Convert an amount of the one currency to an amount of the another one currency

      * with respect to previously specified exchange rates.

      * 

      * @param targetCurrency an identifier of the requested currency

      * @param currencyValue an amount of the another one currency

      * @return an amount of the requested currency

      */

     public CurrencyValue<AmountType, IdentifierType> convert(

             IdentifierType targetCurrency,

             CurrencyValue<AmountType, IdentifierType> currencyValue) {

         ExchangeRateValue<AmountType, IdentifierType> exchangeRate =

                 findExchangeRate(exchangeRates, currencyValue.getIdentifier(), targetCurrency);

         if (exchangeRate == null) {

             throw new IllegalArgumentException("Inappropriate currencies to convert!");

         }

         ComputerRequest<AmountType> computerRequest = new ComputerRequest<AmountType>();

         computerRequest.setInput(currencyValue.getAmount());

         IdentifierType targetCurrencyRef; // just for backward compatibility :-(

         if (exchangeRate.getCurrencyA().getIdentifier().equals(targetCurrency)) {

             computerRequest.setInputCurrencyRatio(exchangeRate.getCurrencyB().getAmount());

             computerRequest.setOutputCurrencyRatio(exchangeRate.getCurrencyA().getAmount());

             targetCurrencyRef = exchangeRate.getCurrencyA().getIdentifier();

         } else {

             computerRequest.setInputCurrencyRatio(exchangeRate.getCurrencyA().getAmount());

             computerRequest.setOutputCurrencyRatio(exchangeRate.getCurrencyB().getAmount());

             targetCurrencyRef = exchangeRate.getCurrencyB().getIdentifier();

         }

         ComputerResponse<AmountType> computerResponse = computer.compute(computerRequest);

         return CurrencyValue.getCurrencyValue(

                 computerResponse.getResult(),

                 targetCurrencyRef);

     }

     // ---

     // MERGING

     // ---

     static <AmountType, IdentifierType> Convertor<AmountType, IdentifierType> mergeConvertors(

             Computer<AmountType> computer,

             Collection<Convertor<AmountType, IdentifierType>> convertors) {

         Set<ExchangeRateValue<AmountType, IdentifierType>> exchangeRatesSet = new HashSet<ExchangeRateValue<AmountType, IdentifierType>>();

         for (Convertor<AmountType, IdentifierType> convertor : convertors) {

             exchangeRatesSet.addAll(convertor.exchangeRates);

         }

         return getConvertor(computer, exchangeRatesSet);

     }

     static <AmountType, IdentifierType> Convertor<AmountType, IdentifierType> mergeConvertors(

             Computer<AmountType> computer,

             Convertor<AmountType, IdentifierType> convertorA,

             Convertor<AmountType, IdentifierType> convertorB) {

         Collection<Convertor<AmountType, IdentifierType>> convertors =

                 new ArrayList<Convertor<AmountType, IdentifierType>>();

         convertors.add(convertorA);

         convertors.add(convertorB);

         return mergeConvertors(computer, convertors);

     }

     public static Convertor<Double, String> mergeConvertorsDoubleString(

             Collection<Convertor<Double, String>> convertors) {

         return mergeConvertors(DoubleComputer, convertors);

     }

     public static Convertor<Double, String> mergeConvertorsDoubleString(

             Convertor<Double, String> convertorA,

             Convertor<Double, String> convertorB) {

         return mergeConvertors(DoubleComputer, convertorA, convertorB);

     }

     public static Convertor<Integer, String> mergeConvertorsIntegerString(

             Collection<Convertor<Integer, String>> convertors) {

         return mergeConvertors(IntegerComputer, convertors);

     }

     public static Convertor<Integer, String> mergeConvertorsIntegerString(

             Convertor<Integer, String> convertorA,

             Convertor<Integer, String> convertorB) {

         return mergeConvertors(IntegerComputer, convertorA, convertorB);

     }

     // ---

     // CREATION

     // ---

     static <AmountType, IdentifierType> Convertor<AmountType, IdentifierType> getConvertor(

             Computer<AmountType> computer, Collection<ExchangeRateValue<AmountType, IdentifierType>> exchangeRates) {

         return new Convertor<AmountType, IdentifierType>(computer, exchangeRates);

     }

     static <AmountType, IdentifierType> Convertor<AmountType, IdentifierType> getConvertor(

             Computer<AmountType> computer, ExchangeRateValue<AmountType, IdentifierType> exchangeRate) {

         Collection<ExchangeRateValue<AmountType, IdentifierType>> exchangeRates =

                 new ArrayList<ExchangeRateValue<AmountType, IdentifierType>>();

         exchangeRates.add(exchangeRate);

         return getConvertor(computer, exchangeRates);

     }

     public static Convertor<Double, String> getConvertorDoubleString(

             Collection<ExchangeRateValue<Double, String>> exchangeRates) {

         return getConvertor(DoubleComputer, exchangeRates);

     }

     public static Convertor<Double, String> getConvertorDoubleString(

             ExchangeRateValue<Double, String> exchangeRate) {

         return getConvertor(DoubleComputer, exchangeRate);

     }

     public static Convertor<Integer, String> getConvertorIntegerString(

             Collection<ExchangeRateValue<Integer, String>> exchangeRates) {

         return getConvertor(IntegerComputer, exchangeRates);

     }

     public static Convertor<Integer, String> getConvertorIntegerString(

             ExchangeRateValue<Integer, String> exchangeRate) {

         return getConvertor(IntegerComputer, exchangeRate);

     }

     // ---

     // BACKWARD COMPATIBILITY - CREATION

     // ---

     /**

      * Creates convertor for Double|String values with specified exchange rate

      * between two currencies.

      * 

      * @param firstCurrencyExchangeRate first currency

      * @param secondCurrencyExchangeRate second currency

      * @return convertor

      */

     public static Convertor<Double, String> getConvertorDoubleString(

             CurrencyValue<Double, String> firstCurrencyExchangeRate,

             CurrencyValue<Double, String> secondCurrencyExchangeRate) {

         return getConvertorDoubleString(ExchangeRateValue.getExchangeRate(firstCurrencyExchangeRate, secondCurrencyExchangeRate));

     }

     /**

      * Creates convertor for Integer|String values with specified exchange rate

      * between two currencies.

      * 

      * @param firstCurrencyExchangeRate first currency

      * @param secondCurrencyExchangeRate second currency

      * @return convertor

      */

     public static Convertor<Integer, String> getConvertorIntegerString(

             CurrencyValue<Integer, String> firstCurrencyExchangeRate,

             CurrencyValue<Integer, String> secondCurrencyExchangeRate) {

         return getConvertorIntegerString(ExchangeRateValue.getExchangeRate(firstCurrencyExchangeRate, secondCurrencyExchangeRate));

     }

     // ---

     // COMPUTERS

     // ---

     static final Computer<Double> DoubleComputer = new Computer<Double>() {

         public ComputerResponse<Double> compute(ComputerRequest<Double> request) {

             ComputerResponse<Double> response = new ComputerResponse<Double>();

             response.setResult(request.getInput() * request.getOutputCurrencyRatio() / request.getInputCurrencyRatio());

             return response;

         }

     };

     static final Computer<Integer> IntegerComputer = new Computer<Integer>() {

         public ComputerResponse<Integer> compute(ComputerRequest<Integer> request) {

             ComputerResponse<Integer> response = new ComputerResponse<Integer>();

             response.setResult(request.getInput() * request.getOutputCurrencyRatio() / request.getInputCurrencyRatio());

             return response;

         }

     };

 }