package org.apidesign.apifest08.currency;

 import java.math.BigDecimal;

 import java.math.MathContext;

 import java.math.RoundingMode;

 /** Convertor able to convert amount from one currency to other currency.

  * 

  * Exchange rate is provided by {@link ExchangeRateProvider}.

  */

 public class Convertor {

     boolean remainderAllowed = false; //if false, remained is not allowed (should be true ideally, but can't handle it now)

     ExchangeRateProvider exchangeRateProvider; 

     private Convertor() {

     }

     /**

      * Static method used to create convertor.

      * 

      * @param exchangeRateProvider {@link ExchangeRateProvider} used to get exchange rate.

      * 

      * @return Returns <code>Convertor</code> which can be used to convert money.

      */

     public static Convertor createConvertor(ExchangeRateProvider exchangeRateProvider) {

         Convertor c = new Convertor();

         c.exchangeRateProvider = exchangeRateProvider;

         return c;

     }

     /**

      * Convert <code>amount</code> from <code>fromCurrency</code> to <code>toCurrency</code> as specified

      * in <code>ExchangeRateProvider</code>.

      * 

      * @param amount Amount which should be converted. Can't be negative value (can be zero or positive).

      * @return Return <code>ConversionResult</code> which holds conversion result.

      */

     public ConversionResult convert(BigDecimal amount) {

         return convertValue(amount, false);

     }

     /**

      * Convert <code>amount</code> from <code>toCurrency</code> to <code>fromCurrency</code> as specified

      * in <code>ExchangeRateProvider</code>. This is <em>reverted</em> order than suggested by  names of currency fields in <code>ExchangeRate</code>.

      * 

      * @param amount Amount which should be converted. Can't be negative value (can be zero or positive).

      * @return Return <code>ConversionResult</code> which holds conversion result.

      */

     public ConversionResult convertBack(BigDecimal amount) {

         return convertValue(amount, true);

     }

     private ConversionResult convertValue(BigDecimal amount, boolean convertBack) throws RuntimeException {

         ConversionResult result = new ConversionResult();

         ExchangeRate rate = exchangeRateProvider.getExchangeRate();

         int fromFranctionDigits = exchangeRateProvider.getFromCurrency().getDefaultFractionDigits();

         int toFractionDigits = exchangeRateProvider.getToCurrency().getDefaultFractionDigits();

         if (toFractionDigits!=2) {

             throw new RuntimeException("Can't process currency with defaultFractionDigits!=2, "+exchangeRateProvider.getToCurrency()+" has "+toFractionDigits+" defaultFractionDigits");

         }

         if (fromFranctionDigits!=2) {

             throw new RuntimeException("Can't process currency with defaultFractionDigits!=2, "+exchangeRateProvider.getFromCurrency()+" has "+fromFranctionDigits+" defaultFractionDigits");

         }

         if (amount.signum()==-1) {

             throw new RuntimeException("Can convert only non-negative value, current value is "+amount);

         }

         MathContext context = new MathContext(0, RoundingMode.DOWN);

         BigDecimal from;

         BigDecimal to;

         if (convertBack) {

             //converting in reverted way

             to = rate.getFromValue();

             from = rate.getToValue();

         } else {

             //converting in mornak way

             from = rate.getFromValue();

             to = rate.getToValue();

         }

         BigDecimal amountCent = amount.movePointRight(2);

         final BigDecimal multiplied = amountCent.multiply(to,context);

         BigDecimal[] division = multiplied.divideAndRemainder(from,context);

         if (!remainderAllowed && !(BigDecimal.ZERO.equals(division[1]))) {

             throw new RuntimeException("Remained is not allowed - remaining amount is " + division[1]+ " cents");

         } else {

             result.setRemainder(BigDecimal.ZERO);

         }

         final BigDecimal converted = division[0].movePointLeft(2);        

         result.setConverted(converted);

         //result.setRemainder(...);

         return result;

     }

 }