package org.apidesign.apifest08.currency;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 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<CurrencyRate> 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<CurrencyRate> curRates = new ArrayList<CurrencyRate>();

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

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

             curRates.add(curRat);

         }

         this.currencyRates = Collections.unmodifiableList(curRates);

     }

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

         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 (CurrencyRate curRate : currencyRates) {

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

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

                 {

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

                 }

             }

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

             for (CurrencyRate curRate : currencyRates) {

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

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

                 {

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

         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 (CurrencyRate curRate : currencyRates) {

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

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

                 {

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

                 }

             }

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

             for (CurrencyRate curRate : currencyRates) {

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

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

                 {

                     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

             return currencyRates;

         }

     }

     @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 :-)

         }

     }

 }