package org.apidesign.apifest08.currency;

 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.

  * 

  * @author ked

  */

 public final class Convertor<AmountType, IdentifierType> {

     Computer<AmountType> computer;

     CurrencyValue<AmountType, IdentifierType> firstCurrencyExchangeRate;

     CurrencyValue<AmountType, IdentifierType> secondCurrencyExchangeRate;

     Convertor(

             Computer<AmountType> computer,

             CurrencyValue<AmountType, IdentifierType> firstCurrencyExchangeRate,

             CurrencyValue<AmountType, IdentifierType> secondCurrencyExchangeRate) {

         this.computer = computer;

         this.firstCurrencyExchangeRate = firstCurrencyExchangeRate;

         this.secondCurrencyExchangeRate = secondCurrencyExchangeRate;

     }

     /**

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

      * with respect to previously specified exchange rate.

      * 

      * @param currencyValue an amount of the one currency

      * @return an amount of the another one currency

      */

     public CurrencyValue<AmountType, IdentifierType> convert(CurrencyValue<AmountType, IdentifierType> currencyValue) {

         if (firstCurrencyExchangeRate.getIdentifier().equals(currencyValue.getIdentifier())) {

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

             computerRequest.setInput(currencyValue.getAmount());

             computerRequest.setInputCurrencyRatio(firstCurrencyExchangeRate.getAmount());

             computerRequest.setOutputCurrencyRatio(secondCurrencyExchangeRate.getAmount());

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

             return CurrencyValue.getCurrencyValue(

                     computerResponse.getResult(),

                     secondCurrencyExchangeRate.getIdentifier());

         } else if (secondCurrencyExchangeRate.getIdentifier().equals(currencyValue.getIdentifier())) {

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

             computerRequest.setInput(currencyValue.getAmount());

             computerRequest.setInputCurrencyRatio(secondCurrencyExchangeRate.getAmount());

             computerRequest.setOutputCurrencyRatio(firstCurrencyExchangeRate.getAmount());

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

             return CurrencyValue.getCurrencyValue(

                     computerResponse.getResult(),

                     firstCurrencyExchangeRate.getIdentifier());

         } else {

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

         }

     }

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

             Computer<AmountType> computer,

             CurrencyValue<AmountType, IdentifierType> firstCurrencyExchangeRate,

             CurrencyValue<AmountType, IdentifierType> secondCurrencyExchangeRate) {

         return new Convertor<AmountType, IdentifierType>(

                 computer,

                 firstCurrencyExchangeRate,

                 secondCurrencyExchangeRate);

     }

     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;

         }

     };

     /**

      * 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 getConvertor(DoubleComputer, firstCurrencyExchangeRate, secondCurrencyExchangeRate);

     }

     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;

         }

     };

     /**

      * 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 getConvertor(IntegerComputer, firstCurrencyExchangeRate, secondCurrencyExchangeRate);

     }

 }