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

        if (firstCurrencyExchangeRate.getIdentifier() == null ||

            secondCurrencyExchangeRate.getIdentifier() == null ||

            firstCurrencyExchangeRate.getIdentifier().equals(secondCurrencyExchangeRate.getIdentifier())) {

                throw new IllegalArgumentException("Inappropriate exchange rates' identifiers!");

        }

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

        if (firstCurrencyExchangeRate.getIdentifier().equals(targetCurrency) &&

            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 if (secondCurrencyExchangeRate.getIdentifier().equals(targetCurrency) &&

                   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 {

            throw new IllegalArgumentException("Inappropriate currencies 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);

    }

}