package org.apidesign.apifest08.currency;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

/** This is the skeleton class for your API. You need to make it public, so

 * it is accessible to your client code (currently in Task1Test.java) file.

 * <p>

 * Feel free to create additional classes or rename this one, just keep all

 * the API and its implementation in this package. Do not spread it outside

 * to other packages.

 */

public final class Convertor {

    //version 1 fields

    private String currency1 = null;

    private String currency2 = null;

    private Rate rate = null;

    //version 2 field

    private List<TimeLimitedCurrencyRate> currencyRates = null;

    //version - for compatible mode

    private int instanceVersion = 0; //compatible mode because of problem with empty currency and CZE -> CZE (1:2) rate

    Convertor(String currency1, String currency2, Rate rate) {

        instanceVersion = 1;

        if ((currency1 == null) || (currency2 == null) || (rate == null)) {

            throw new IllegalArgumentException("All arguments have to be non-null.");

        }

        this.currency1 = currency1;

        this.currency2 = currency2;

        this.rate = rate;

    }

    Convertor(final CurrencyRate ... currencyRate) {

        instanceVersion = 2;

        if (currencyRate == null) {

            throw new IllegalArgumentException("Parameter cannot be null.");

        }

        if (currencyRate.length == 0) {

            throw new IllegalArgumentException("CurrencyRates cannot be empty.");

        }

        Set<Pair<String,String>> currencies = new HashSet<Pair<String,String>>();

        List<TimeLimitedCurrencyRate> curRates = new ArrayList<TimeLimitedCurrencyRate>();

        for (int i = 0; i < currencyRate.length; i++) {

            final CurrencyRate curRat = currencyRate[i];

            if (curRat == null) {

                throw new IllegalArgumentException("Parameter cannot be null.");

            }

            //check that currencyRate is not defined twice

            Pair<String, String> curPair= new Pair<String, String>(curRat.getCurrency1(), curRat.getCurrency2());

            if (currencies.contains(curPair)) {

                throw new IllegalArgumentException("Pair of currencies in a currency rate cannot be defined twice");

            }

            currencies.add(curPair);

            if (curRat instanceof TimeLimitedCurrencyRate) {

                curRates.add((TimeLimitedCurrencyRate)curRat);

            } else {

                curRates.add(new TimeLimitedCurrencyRate() { //create delegate which implements TimeLimitedCurrencyRate

                    public long getFromTime() {

                        return Long.MIN_VALUE;

                    }

                    public long getToTime() {

                        return Long.MAX_VALUE;

                    }

                    public String getCurrency1() {

                        return curRat.getCurrency1();

                    }

                    public String getCurrency2() {

                        return curRat.getCurrency2();

                    }

                    public Rate getRate() {

                        return curRat.getRate();

                    }

                });

            }

        }

        this.currencyRates = Collections.unmodifiableList(curRates);

    }

    Convertor(final int fakeParameter, final TimeLimitedCurrencyRate ... currencyRate) { //use fake parameter just to specify which constructor should be invoked

        instanceVersion = 3;

        if (currencyRate == null) {

            throw new IllegalArgumentException("Parameter cannot be null.");

        }

        List<TimeLimitedCurrencyRate> curRates = new ArrayList<TimeLimitedCurrencyRate>();

        for (int i = 0; i < currencyRate.length; i++) {

            final TimeLimitedCurrencyRate curRat = currencyRate[i];

            if (curRat == null) {

                throw new IllegalArgumentException("Parameter cannot be null.");

            }

            curRates.add(curRat);

        }

        this.currencyRates = Collections.unmodifiableList(curRates);

    }

    public double convert(String fromCurrency, String toCurrency, int amount) {

        return convert(fromCurrency, toCurrency, amount, System.currentTimeMillis());

    }

    public double convert(String fromCurrency, String toCurrency, int amount, Date date) {

        if (date == null) {

            throw new IllegalArgumentException("Date cannot be null");

        }

        return convert(fromCurrency, toCurrency, amount, date.getTime());

    }

    public double convert(String fromCurrency, String toCurrency, int amount, long time) {

        if (instanceVersion == 1) {

            if ((fromCurrency == null) || (toCurrency == null)) {

                throw new IllegalArgumentException("All arguments have to be non-null.");

            }

            if (currency1.equals(fromCurrency) && currency2.equals(toCurrency)) {

                return rate.convertAtoB(amount);

            } else if (currency2.equals(fromCurrency) && currency1.equals(toCurrency)) {

                return rate.convertBtoA(amount);

            } else {

                throw new IllegalArgumentException("Convertor " + this.toString() +

                        " cannot work with currencies " + fromCurrency + " and " + toCurrency + ".");

            }

        } else { //instanceVersion >= 2

            //find suitable convertor

           for (TimeLimitedCurrencyRate curRate : currencyRates) {

                if ((curRate.getCurrency1().equals(fromCurrency))&&

                        (curRate.getCurrency2().equals(toCurrency))&&

                        (curRate.getFromTime() <= time) &&

                        (curRate.getToTime() >= time))

                {

                    return curRate.getRate().convertAtoB(amount);

                }

            }

            //suitable convertor not found, try to find inverse convertor

            for (TimeLimitedCurrencyRate curRate : currencyRates) {

                if ((curRate.getCurrency2().equals(fromCurrency))&&

                        (curRate.getCurrency1().equals(toCurrency))&&

                        (curRate.getFromTime() <= time) &&

                        (curRate.getToTime() >= time))

                {

                    return curRate.getRate().convertBtoA(amount);

                }

            }

            //even inverse convertor not found

            throw new IllegalArgumentException("Cannot work with selected currencies.");

        }

    }

    public double convert(String fromCurrency, String toCurrency, double amount) {

        return convert(fromCurrency, toCurrency, amount, System.currentTimeMillis());

    }

    public double convert(String fromCurrency, String toCurrency, double amount, Date date) {

        if (date == null) {

            throw new IllegalArgumentException("Date cannot be null");

        }

        return convert(fromCurrency, toCurrency, amount, date.getTime());

    }

    public double convert(String fromCurrency, String toCurrency, double amount, long time) {

        if (instanceVersion == 1) {

            if ((fromCurrency == null) || (toCurrency == null)) {

                throw new IllegalArgumentException("All arguments have to be non-null.");

            }

            if (currency1.equals(fromCurrency) && currency2.equals(toCurrency)) {

                return rate.convertAtoB(amount);

            } else if (currency2.equals(fromCurrency) && currency1.equals(toCurrency)) {

                return rate.convertBtoA(amount);

            } else {

                throw new IllegalArgumentException("Convertor " + this.toString() +

                        " cannot work with currencies " + fromCurrency + " and " + toCurrency + ".");

            }

        } else { //instanceVersion >= 2

            //find suitable convertor

            for (TimeLimitedCurrencyRate curRate : currencyRates) {

                if ((curRate.getCurrency1().equals(fromCurrency))&&

                        (curRate.getCurrency2().equals(toCurrency))&&

                        (curRate.getFromTime() <= time) &&

                        (curRate.getToTime() >= time))

                {

                    return curRate.getRate().convertAtoB(amount);

                }

            }

            //suitable convertor not found, try to find inverse convertor

            for (TimeLimitedCurrencyRate curRate : currencyRates) {

                if ((curRate.getCurrency2().equals(fromCurrency))&&

                        (curRate.getCurrency1().equals(toCurrency))&&

                        (curRate.getFromTime() <= time) &&

                        (curRate.getToTime() >= time))

                {

                    return curRate.getRate().convertBtoA(amount);

                }

            }

            //even inverse convertor not found

            throw new IllegalArgumentException("Cannot work with selected currencies.");

        }

    }

    /**

     * Returns currency rates. If instantiated with constructor from vesion 1

     * it creates new collection with one CurrencyRate.

     * Note, it can cause exception because of empty currencies or same currencies.

     */

    public Collection<CurrencyRate> getCurrencyRates() {

        if (instanceVersion == 1) {

            List<CurrencyRate> ret = new ArrayList<CurrencyRate>();

            ret.add(new CurrencyRateImpl(currency1, currency2, rate)); //here it checks that currency rate is not nonsense

            return Collections.unmodifiableCollection(ret);

        } else { //instanceVersion >= 2

            List<CurrencyRate> ret = new ArrayList<CurrencyRate>(currencyRates);

            return Collections.unmodifiableCollection(ret);

        }

    }

    public Collection<TimeLimitedCurrencyRate> getTimeLimitedCurrencyRates() {

        if (instanceVersion == 1) {

            List<TimeLimitedCurrencyRate> ret = new ArrayList<TimeLimitedCurrencyRate>();

            ret.add(new CurrencyRateImpl(currency1, currency2, rate)); //here it checks that currency rate is not nonsense

            return Collections.unmodifiableCollection(ret);

        } else { //instanceVersion >= 2

            List<TimeLimitedCurrencyRate> ret = new ArrayList<TimeLimitedCurrencyRate>(currencyRates);

            return Collections.unmodifiableCollection(ret);

        }

    }

    @Override

    public String toString() {

        if (instanceVersion == 1) {

            return currency1 + currency2;

        } else { //instanceVersion == 2

            return super.toString(); //better be compatible in future :-)

        }

    }

    @Override

    public boolean equals(Object obj) {

        if (instanceVersion == 1) {

            if (obj == null) {

                return false;

            }

            if (getClass() != obj.getClass()) {

                return false;

            }

            final Convertor other = (Convertor) obj;

            if (this.currency1 != other.currency1 && (this.currency1 == null || !this.currency1.equals(other.currency1))) {

                return false;

            }

            if (this.currency2 != other.currency2 && (this.currency2 == null || !this.currency2.equals(other.currency2))) {

                return false;

            }

            if (this.rate != other.rate && (this.rate == null || !this.rate.equals(other.rate))) {

                return false;

            }

            return true;

        } else { //instanceVersion == 2

            return super.equals(obj); //better be compatible in future :-)

        }

    }

    @Override

    public int hashCode() {

        if (instanceVersion == 1) {

            int hash = 5;

            hash = 67 * hash + (this.currency1 != null ? this.currency1.hashCode() : 0);

            hash = 67 * hash + (this.currency2 != null ? this.currency2.hashCode() : 0);

            hash = 67 * hash + (this.rate != null ? this.rate.hashCode() : 0);

        return hash;

        } else { //instanceVersion == 2

            return super.hashCode(); //better be compatible in future :-)

        }

    }

}