/*

  * To change this template, choose Tools | Templates

  * and open the template in the editor.

  */

 package org.apidesign.apifest08.currency.anothervendor;

 import java.math.BigDecimal;

 import java.util.Currency;

 import java.util.Iterator;

 import org.apidesign.apifest08.currency.Convertor;

 import org.apidesign.apifest08.currency.IllegalRequestSubtypeException;

 import org.apidesign.apifest08.currency.MonetaryAmount;

 /**

  * A convertor that changes the rate by a step amount on every conversion it performs.

  * @author jdvorak

  */

 public class ZigZaggingBidirectionalConvertor implements Convertor {

     private final MonetaryAmount srcRateAmount;

     private final Currency tgtCurrency;

     private final Iterator<BigDecimal> rateIterator;

     /**

      * Costructor with the precise amounts.

      * @param srcRateAmount

      * @param tgtCurrency

      * @param startAmount

      * @param endAmount

      * @param stepAmount

      */

     public ZigZaggingBidirectionalConvertor( final MonetaryAmount srcRateAmount, final Currency tgtCurrency, final BigDecimal startAmount, final BigDecimal endAmount, final BigDecimal stepAmount ) {

         this.srcRateAmount = srcRateAmount;

         this.tgtCurrency = tgtCurrency;

         this.rateIterator = new ZigZaggingBigDecimalIterator( startAmount, endAmount, stepAmount );

     }

     /**

      * Do the conversion; updates the rate.

      * @param req

      * @return

      * @throws org.apidesign.apifest08.currency.IllegalRequestSubtypeException

      */

     public synchronized ConversionResult convert( ConversionRequest req ) throws IllegalRequestSubtypeException {

         if ( tgtCurrency.equals( req.getTgtCurrency() ) ) {

             if ( srcRateAmount.getCurrency().equals( req.getSrcAmount().getCurrency() ) ) {

                 final BigDecimal tgtRateAmount = rateIterator.next();

                 final BigDecimal tgtAmount = req.getSrcAmount().getAmount().multiply( tgtRateAmount ).divide( srcRateAmount.getAmount() );

                 return new ConversionResult( new MonetaryAmount( tgtAmount, tgtCurrency ) );

             }

         }

         if ( srcRateAmount.getCurrency().equals( req.getTgtCurrency() ) ) {

             if ( tgtCurrency.equals( req.getSrcAmount().getCurrency() ) ) {

                 final BigDecimal tgtRateAmount = rateIterator.next();

                 final BigDecimal tgtAmount = req.getSrcAmount().getAmount().multiply( srcRateAmount.getAmount() ).divide( tgtRateAmount );

                 return new ConversionResult( new MonetaryAmount( tgtAmount, srcRateAmount.getCurrency() ) );

             }

         }

         return new ConversionResult( null );

     }

 }

 /**

  * An iterator that goes zig first, then zag, then zig again, then zag again, ad libitum.

  * @author jdvorak

  */

 class ZigZaggingBigDecimalIterator implements Iterator<BigDecimal> {

     private BigDecimal zigBounce;

     private BigDecimal zagBounce;

     private BigDecimal step;

     private BigDecimal currentValue;

     protected ZigZaggingBigDecimalIterator( final BigDecimal zagBounce, final BigDecimal zigBounce, final BigDecimal step ) {

         this. zigBounce = zigBounce;

         this.zagBounce = zagBounce;

         this.currentValue = zagBounce;

         this.step = step;

         if (  zigBounce == null ) {

             throw new NullPointerException( "zigAmount" );

         }

         if ( zagBounce == null ) {

             throw new NullPointerException( "zagAmount" );

         }

         if ( step == null ) {

             throw new NullPointerException( "stepAmount" );

         }

         final int stepSign = step.signum();

         if ( stepSign == 0 ) {

             throw new IllegalArgumentException( "stepAmount can't be zero" );

         }

         if ( stepSign * zigBounce.compareTo( zagBounce ) < 0 ) {

             throw new IllegalArgumentException( "stepAmount shall have the same sign as endAmount - startAmount" );

         }

     }

     public boolean hasNext() {

         return true;

     }

     public BigDecimal next() {

         final BigDecimal result = currentValue;

         currentValue = currentValue.add( step );

         final int stepSign = step.signum();

         final int currentMinusZigSign = currentValue.compareTo( zigBounce );

         if ( stepSign * currentMinusZigSign >= 0 ) {

             final BigDecimal temp = zigBounce;

             zigBounce = zagBounce;

             zagBounce = temp;

             step = step.negate();

         }

         return result;

     }

     public void remove() {

         throw new UnsupportedOperationException("Removal is not supported.");

     }

 }