/*

 * 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.");

    }

}