package org.apidesign.apifest08.currency;

import static org.apidesign.apifest08.currency.Assert.notNull;

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Currency;

import java.util.Date;

import java.util.GregorianCalendar;

import java.util.List;

import java.util.TimeZone;

/**

 * Currency covertor.

 */

public final class Convertor {

	private List<ConvertorDelegate> convertorDelegates = new ArrayList<ConvertorDelegate>();

	/**

	 * Create new instance of the converter for the given currencies and its rate.

	 * 

	 * @param rateValue the rate between the first and the second currency

	 * @param currencyFirst the first currency

	 * @param currencySecond the second currency

	 */

	public Convertor(BigDecimal rateValue, Currency currencyFirst, Currency currencySecond) {

		notNull(currencyFirst, "currencyFirst");

		notNull(currencySecond, "currencySecond");		

		notNull(rateValue, "rateValue");	

		convertorDelegates.add(new ConvertorDelegate(new StaticRateProvider(rateValue), currencyFirst, currencySecond, null, null));

	}

	/**

	 * Create new instance of the converter for the given currencies and its rate. 

	 * A rate value is provided by {@link RateProvider}.

	 * 

	 * @param rateProvider the rate provider

	 * @param currencyFirst the first currency

	 * @param currencySecond the second currency

	 */

	public Convertor(RateProvider rateProvider, Currency currencyFirst, Currency currencySecond) {

		notNull(currencyFirst, "currencyFirst");

		notNull(currencySecond, "currencySecond");		

		notNull(rateProvider, "rateProvider");

		convertorDelegates.add(new ConvertorDelegate(rateProvider, currencyFirst, currencySecond, null, null));

	}

	/**

	 * Create new instance of the convertor. The associated rate(s) is timely limited

	 * by a given 'from' and 'till'. 

	 * @param convertor

	 * @param from

	 * @param till

	 */

	public Convertor(Convertor convertor, Date from, Date till) {

	    notNull(convertor, "convertor");

		notNull(from, "from");

		notNull(till, "till");				

		for(ConvertorDelegate delegate: convertor.convertorDelegates) {

			convertorDelegates.add(new ConvertorDelegate(delegate.rateProvider, delegate.first, delegate.second, from, till));

		}

	}

	/**

	 * Create new instance of the convertor from the given convertors. 

	 * @param convertors the convertors

	 */

	public Convertor(Convertor... convertors) {

		notNull(convertors, "convertors");

		if(convertors.length == 0) {

			throw new IllegalArgumentException("There must be at least one converter.");

		}

		for(Convertor convertor: convertors) {

			if(convertor != null) {

				for(ConvertorDelegate delegate: convertor.convertorDelegates) {

					convertorDelegates.add(new ConvertorDelegate(delegate.rateProvider, delegate.first, delegate.second, delegate.from, delegate.till));

				}

			}

		}

	}

	/**

	 * Converts an amount value between the two currencies of this converter. The rate is taken 

	 * for current time.

	 *  

	 * @param amount an amount

	 * @param fromCurrency an amount currency

	 * @param toCurrency to a target currency

	 * @return a converted amount value

	 * 

	 * @throws ConversionException if the conversion fails

	 * @throws UnsupportedConversionException if the conversion between a given currencies is not supported.

	 */

	public Amount convert(BigDecimal amount, Currency fromCurrency, Currency toCurrency) throws ConversionException {

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

	}

	/**

	 * Converts an amount value between the two currencies of this converter and its 

	 * associated rate for a given time.

	 *  

	 * @param amount an amount

	 * @param fromCurrency an amount currency

	 * @param toCurrency to a target currency

	 * @param time time

	 * @return a converted amount value

	 * 

	 * @throws ConversionException if the conversion fails

	 * @throws UnsupportedConversionException if the conversion between a given currencies and time is not supported.

	 */

	public Amount convert(BigDecimal amount, Currency fromCurrency, Currency toCurrency, Date time) throws ConversionException {

		notNull(amount, "amount");

		notNull(fromCurrency, "fromCurrency");

		notNull(toCurrency, "toCurrency");		

		notNull(time, "time");

		ConvertorDelegate appropriateDelegate = null;

		//try find an appropriate delegate for conversion

		for(ConvertorDelegate delegate : convertorDelegates) {

			if(delegate.isConversionSupported(fromCurrency, toCurrency) && delegate.isConversionSupported(time)) {				

				appropriateDelegate = delegate;				

			}

		}

		if(appropriateDelegate == null) {

			throw new UnsupportedConversionException(fromCurrency, toCurrency, time);

		}

		return appropriateDelegate.convert(amount, fromCurrency, toCurrency);

	}

	/**

	 * Internal delegate implements a logic for conversion between two currencies

	 * and vice versa. There could be time limitation for the associated rate.

	 * 

	 * @see #isConversionSupported(Currency, Currency)

	 */

	private static class ConvertorDelegate {

		private final Currency first;

		private final Currency second;

		private final RateProvider rateProvider;

		private final Date from;

		private final Date till;

		public static final BigDecimal one = new BigDecimal(1);

		private ConvertorDelegate(RateProvider rateProvider, Currency currencyFirst, Currency currencySecond, Date from, Date till) {

			this.rateProvider = rateProvider;

			this.first = currencyFirst;

			this.second = currencySecond;

			this.from = from;

			this.till = till;

		}

		private Amount convert(BigDecimal amount, Currency fromCurrency, Currency toCurrency) throws ConversionException {

			BigDecimal rateValue = getRateValue(fromCurrency, toCurrency);

			BigDecimal result = rateValue.multiply(amount);			

			return new Amount(result, toCurrency);	

		}

		private BigDecimal getRateValue(Currency fromCurrency, Currency toCurrency) {		

			BigDecimal retVal;

			if(first == fromCurrency) {

				BigDecimal rateValue = rateProvider.getRate();

				if(rateValue == null) {

					throw new NullPointerException("Rate cannot be null!");

				}

				retVal = rateValue;

			} else {	

				BigDecimal rateValue = rateProvider.getRate();

				if(rateValue == null) {

					throw new NullPointerException("Rate cannot be null!");

				}

				//reverse rate	

				retVal = one.divide(rateValue, 10 ,RoundingMode.HALF_UP);

			}

			return retVal;

		}

		/**

		 * @return <code>true</code> if the delegate is able to convert from the given currency

		 * to the given currency and vice versa otherwise <code>false</code>.

		 */

		private boolean isConversionSupported(Currency fromCurrency, Currency toCurrency) {

			return ((fromCurrency == first || fromCurrency == second) && (toCurrency == first || toCurrency == second));

		}

		/**

		 * @return <code>true</code> if the delegate is able to convert in a given

		 * time.

		 */

		private boolean isConversionSupported(Date time) {

			boolean retVal;

			if(this.from != null && this.till != null) {

				retVal = getDateInGMT(from).getTime() <= getDateInGMT(time).getTime() && getDateInGMT(till).getTime() >= getDateInGMT(time).getTime();  

		    } else {

				retVal = true; //delegate is applicable "for eternity"				

			}

			return retVal;

		}

		private Date getDateInGMT(Date currentDate) {

			TimeZone tz = TimeZone.getTimeZone("GMT");

			Calendar mbCal = new GregorianCalendar(tz);

			mbCal.setTimeInMillis(currentDate.getTime());

			Calendar cal = Calendar.getInstance();

			cal.set(Calendar.YEAR, mbCal.get(Calendar.YEAR));

			cal.set(Calendar.MONTH, mbCal.get(Calendar.MONTH));

			cal.set(Calendar.DAY_OF_MONTH, mbCal.get(Calendar.DAY_OF_MONTH));

			cal.set(Calendar.HOUR_OF_DAY, mbCal.get(Calendar.HOUR_OF_DAY));

			cal.set(Calendar.MINUTE, mbCal.get(Calendar.MINUTE));

			cal.set(Calendar.SECOND, mbCal.get(Calendar.SECOND));

			cal.set(Calendar.MILLISECOND, mbCal.get(Calendar.MILLISECOND));

			return cal.getTime();

		}

	}

	/**

	 * A rate provider. This class represents a way how could be "static" convertor

	 * extended in order converts according to current rate.

	 */

	public static abstract class RateProvider { 

		/**

		 * @return a rate between the from currency and the to currency associated with

		 * a given convertor.

		 */

		public abstract BigDecimal getRate();

	}

	private static class StaticRateProvider extends RateProvider{

		private final BigDecimal rateValue;

		private StaticRateProvider(BigDecimal rateValue){

			this.rateValue = rateValue;

		}

		public BigDecimal getRate() {

			return this.rateValue;

		}

	}

}