package org.apidesign.apifest08.currency;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Date;

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.

 * 

 * In Task3's version supports reading of current exchange rates

 * from data sources. Data sources are merged during convertors' merging

 * as well as static exchange rates.

 * No time for javadoc, again.

 * 

 * In Task4's version takes into account validity range of data sources,

 * can convert using an exchange rate value according to the specified instant

 * of the time and provides a method for creating a new convertor with the same

 * data sources as the old one, but with their validity ranges limited

 * to the specified range.

 * As usual, no time for javadoc.

 * 

 * @author ked

 */

public final class Convertor<AmountType, IdentifierType> {

    Computer<AmountType> computer;

    // each static exchange rate is a special case of an exchange rate data source

    // historically separated

    List<ExchangeRateDataSource<AmountType, IdentifierType>> staticExchangeRateDataSources =

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

    List<ExchangeRateDataSource<AmountType, IdentifierType>> exchangeRateDataSources =

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

    // ---

    // BASICS

    // ---

    Convertor(Computer<AmountType> computer) {

        this.computer = computer;

    }

    void addExchangeRateDataSources(

            List<ExchangeRateDataSource<AmountType, IdentifierType>> target,

            Collection<ExchangeRateDataSource<AmountType, IdentifierType>> exchangeRateDataSources) {

        for (ExchangeRateDataSource<AmountType, IdentifierType> exchangeRateDataSource : exchangeRateDataSources) {

            if (isOverlappingExchangeRate(

                    exchangeRateDataSource.getCurrencyAIdentifier(),

                    exchangeRateDataSource.getCurrencyBIdentifier(),

                    exchangeRateDataSource.getValidFrom(),

                    exchangeRateDataSource.getValidTill())) {

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

            }

            target.add(exchangeRateDataSource);

        }

    }

    ExchangeRateValue<AmountType, IdentifierType> findExchangeRate(

            IdentifierType currencyA,

            IdentifierType currencyB,

            Date instant) {

        ExchangeRateValue<AmountType, IdentifierType> result = null;

        result = findExchangeRateInternal(staticExchangeRateDataSources, currencyA, currencyB, instant);

        if (result != null) {

            return result;

        }

        result = findExchangeRateInternal(exchangeRateDataSources, currencyA, currencyB, instant);

        return result;

    }

    ExchangeRateValue<AmountType, IdentifierType> findExchangeRateInternal(

            List<ExchangeRateDataSource<AmountType, IdentifierType>> where,

            IdentifierType currencyA,

            IdentifierType currencyB,

            Date instant) {

        for (ExchangeRateDataSource<AmountType, IdentifierType> exchangeRateDataSource : where) {

            if (((exchangeRateDataSource.getCurrencyAIdentifier().equals(currencyA) && exchangeRateDataSource.getCurrencyBIdentifier().equals(currencyB)) ||

                    (exchangeRateDataSource.getCurrencyAIdentifier().equals(currencyB) && exchangeRateDataSource.getCurrencyBIdentifier().equals(currencyA))) &&

                    DateUtil.isInRange(instant, exchangeRateDataSource.getValidFrom(), exchangeRateDataSource.getValidTill())) {

                return exchangeRateDataSource.getExchangeRate();

            }

        }

        return null;

    }

    boolean isOverlappingExchangeRate(

            IdentifierType currencyA,

            IdentifierType currencyB,

            Date from,

            Date to) {

        boolean result = false;

        result = isOverlappingExchangeRateInternal(staticExchangeRateDataSources, currencyA, currencyB, from, to);

        if (result == true) {

            return result;

        }

        result = isOverlappingExchangeRateInternal(exchangeRateDataSources, currencyA, currencyB, from, to);

        return result;

    }

    boolean isOverlappingExchangeRateInternal(

            List<ExchangeRateDataSource<AmountType, IdentifierType>> where,

            IdentifierType currencyA,

            IdentifierType currencyB,

            Date from,

            Date to) {

        for (ExchangeRateDataSource<AmountType, IdentifierType> exchangeRateDataSource : where) {

            if (((exchangeRateDataSource.getCurrencyAIdentifier().equals(currencyA) && exchangeRateDataSource.getCurrencyBIdentifier().equals(currencyB)) ||

                    (exchangeRateDataSource.getCurrencyAIdentifier().equals(currencyB) && exchangeRateDataSource.getCurrencyBIdentifier().equals(currencyA))) &&

                    DateUtil.isRangesOverlapping(from, to, exchangeRateDataSource.getValidFrom(), exchangeRateDataSource.getValidTill())) {

                return true;

            }

        }

        return false;

    }

    /**

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

        return convert(targetCurrency, currencyValue, new Date()); // System.currentTimeMillis()

    }

    public CurrencyValue<AmountType, IdentifierType> convert(

            IdentifierType targetCurrency,

            CurrencyValue<AmountType, IdentifierType> currencyValue,

            Date instant) {

        ExchangeRateValue<AmountType, IdentifierType> exchangeRate =

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

        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 = new ComputerResponse<AmountType>();

        computer.compute(computerRequest, computerResponse);

        return CurrencyValue.getCurrencyValue(

                computerResponse.getResult(),

                targetCurrencyRef);

    }

    // ---

    // LIMITING

    // ---

    Collection<ExchangeRateDataSource<AmountType, IdentifierType>> limitDataSources(

            Collection<ExchangeRateDataSource<AmountType, IdentifierType>> source,

            Date from, Date till) {

        Collection<ExchangeRateDataSource<AmountType, IdentifierType>> result =

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

        for (ExchangeRateDataSource<AmountType, IdentifierType> dataSource : source) {

            result.add(ExchangeRateDataSource.getExchangeRateDataSource(

                    dataSource.getCurrencyAIdentifier(), dataSource.getCurrencyBIdentifier(),

                    dataSource.getExchangeRateProvider(),

                    DateUtil.getRangesIntersectionBottom(dataSource.getValidFrom(), from),

                    DateUtil.getRangesIntersectionTop(dataSource.getValidTill(), till)));

        }

        return result;

    }

    public Convertor<AmountType, IdentifierType> limitConvertor(Date from, Date till) {

        Collection<ExchangeRateDataSource<AmountType, IdentifierType>> limitedStatic =

                limitDataSources(staticExchangeRateDataSources, from, till);

        Collection<ExchangeRateDataSource<AmountType, IdentifierType>> limited =

                limitDataSources(exchangeRateDataSources, from, till);

        Convertor<AmountType, IdentifierType> c = new Convertor<AmountType, IdentifierType>(computer);

        c.addExchangeRateDataSources(c.staticExchangeRateDataSources, limitedStatic);

        c.addExchangeRateDataSources(c.exchangeRateDataSources, limited);

        return c;

    }

    // ---

    // MERGING

    // ---

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

            Computer<AmountType> computer,

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

        Set<ExchangeRateDataSource<AmountType, IdentifierType>> mergedStatic =

                new HashSet<ExchangeRateDataSource<AmountType, IdentifierType>>();

        Set<ExchangeRateDataSource<AmountType, IdentifierType>> merged =

                new HashSet<ExchangeRateDataSource<AmountType, IdentifierType>>();

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

            mergedStatic.addAll(convertor.staticExchangeRateDataSources);

        }

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

            merged.addAll(convertor.exchangeRateDataSources);

        }

        Convertor<AmountType, IdentifierType> c = new Convertor<AmountType, IdentifierType>(computer);

        c.addExchangeRateDataSources(c.staticExchangeRateDataSources, mergedStatic);

        c.addExchangeRateDataSources(c.exchangeRateDataSources, merged);

        return c;

    }

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

        Convertor<AmountType, IdentifierType> c = new Convertor<AmountType, IdentifierType>(computer);

        Collection<ExchangeRateDataSource<AmountType, IdentifierType>> exchangeRateDataSources =

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

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

            exchangeRateDataSources.add(

                    ExchangeRateDataSource.getExchangeRateDataSource(

                    exchangeRate.getCurrencyA().getIdentifier(), exchangeRate.getCurrencyB().getIdentifier(),

                    StaticExchangeRateProvider.getStaticExchangeRateProvider(exchangeRate)));

        }

        c.addExchangeRateDataSources(c.staticExchangeRateDataSources, exchangeRateDataSources);

        return c;

    }

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

            Computer<AmountType> computer, Collection<ExchangeRateDataSource<AmountType, IdentifierType>> exchangeRateDataSources) {

        Convertor<AmountType, IdentifierType> c = new Convertor<AmountType, IdentifierType>(computer);

        c.addExchangeRateDataSources(c.exchangeRateDataSources, exchangeRateDataSources);

        return c;

    }

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

    }

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

            Computer<AmountType> computer, ExchangeRateDataSource<AmountType, IdentifierType> exchangeRateDataSource) {

        Collection<ExchangeRateDataSource<AmountType, IdentifierType>> exchangeRateDataSources =

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

        exchangeRateDataSources.add(exchangeRateDataSource);

        return getConvertorDataSource(computer, exchangeRateDataSources);

    }

    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<Double, String> getConvertorDataSourceDoubleString(

            Collection<ExchangeRateDataSource<Double, String>> exchangeRateDataSources) {

        return getConvertorDataSource(DoubleComputer, exchangeRateDataSources);

    }

    public static Convertor<Double, String> getConvertorDataSourceDoubleString(

            ExchangeRateDataSource<Double, String> exchangeRateDataSource) {

        return getConvertorDataSource(DoubleComputer, exchangeRateDataSource);

    }

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

    }

    public static Convertor<Integer, String> getConvertorDataSourceIntegerString(

            Collection<ExchangeRateDataSource<Integer, String>> exchangeRateDataSources) {

        return getConvertorDataSource(IntegerComputer, exchangeRateDataSources);

    }

    public static Convertor<Integer, String> getConvertorDataSourceIntegerString(

            ExchangeRateDataSource<Integer, String> exchangeRateDataSource) {

        return getConvertorDataSource(IntegerComputer, exchangeRateDataSource);

    }

    // ---

    // 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 void compute(ComputerRequest<Double> request, ComputerResponse<Double> response) {

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

        }

    };

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

        public void compute(ComputerRequest<Integer> request, ComputerResponse<Integer> response) {

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

        }

    };

}