/*******************************************************************************
 * Copyright (c) 2001, 2008 Oracle Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     Oracle Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.jsf.common.internal.strategy;

import java.util.Iterator;

import org.eclipse.jst.jsf.common.JSFCommonPlugin;

/**
 * A composite strategy whos role is to iterate through a number of child
 * stategies until one returns a valid value for an input.
 * 
 * @author cbateman
 * 
 * @param <INPUT>
 * @param <OUTPUT>
 * @param <RESULTOUTPUT> 
 * @param <IDTYPE>
 * @param <STRATEGYTYPE>
 */
public abstract class StrategyComposite<INPUT, OUTPUT, RESULTOUTPUT, IDTYPE, STRATEGYTYPE extends IIdentifiableStrategy<INPUT, OUTPUT, IDTYPE>>
implements ISimpleStrategy<INPUT, RESULTOUTPUT>
{
    private final AbstractCompositionStrategy<INPUT, OUTPUT, RESULTOUTPUT, STRATEGYTYPE> _compositionStrategy;

    /**
     * @param compositionStrategy
     */
    protected StrategyComposite(
            final AbstractCompositionStrategy<INPUT, OUTPUT, RESULTOUTPUT, STRATEGYTYPE> compositionStrategy)
    {
        _compositionStrategy = compositionStrategy;
    }

    /**
     * Default constructor: composite returns the first value found.
     */
    protected StrategyComposite()
    {
        // by default, the composition strategy selects the first value
        this(
                new DefaultCompositionStrategy<INPUT, OUTPUT, RESULTOUTPUT, STRATEGYTYPE>());
    }

    public final RESULTOUTPUT perform(final INPUT input)
    {
        final Iterator<STRATEGYTYPE> sIt = getIterator();

        RESULTOUTPUT result = getNoResult();
        boolean finishedComposing = false;

        EXECUTE_LOOP: while (sIt.hasNext())
        {
            final STRATEGYTYPE strategy = sIt.next();
            try
            {
                finishedComposing = _compositionStrategy
                        .compose(new CompositionArguments<INPUT, OUTPUT, STRATEGYTYPE>(
                                strategy, input));
                // returns true if we are done composing
                if (finishedComposing)
                {
                    result = _compositionStrategy.getComposedResult();
                    break EXECUTE_LOOP;
                }
            } catch (final Exception e)
            {
                JSFCommonPlugin.log(e);
            }
        }

        if (finishedComposing)
        {
            return result;
        }
        return getNoResult();
    }

    /*
     * (non-Javadoc)
     * 
     * @see
     * org.eclipse.jst.jsf.common.internal.strategy.ISimpleStrategy#getNoResult
     * ()
     */
    public abstract RESULTOUTPUT getNoResult();

    /**
     * @return an iterator that will return the next strategy to be executed
     */
    public abstract Iterator<STRATEGYTYPE> getIterator();

    /**
     * @author cbateman
     * @param <INPUT>
     * @param <OUTPUT>
     * @param <RESULTOUTPUT> 
     * @param <STRATEGY>
     */
    public abstract static class AbstractCompositionStrategy<INPUT, OUTPUT, RESULTOUTPUT, STRATEGY extends ISimpleStrategy<INPUT, OUTPUT>>
    implements ISimpleStrategy<CompositionArguments<INPUT, OUTPUT, STRATEGY>, Boolean>
    {
        private final Boolean _noResultValue;

        /**
         * 
         */
        protected AbstractCompositionStrategy()
        {
            _noResultValue = null;
            reset();
        }

        /**
         * @param input
         * @return true if composing is finished based on the input, false
         *         otherwise
         * @throws Exception 
         */
        public abstract boolean compose(CompositionArguments<INPUT, OUTPUT, STRATEGY> input) throws Exception;

        @SuppressWarnings("boxing")
        public final Boolean perform(final CompositionArguments<INPUT, OUTPUT, STRATEGY> input) throws Exception
        {
            return compose(input);
        }

        /**
         * @return the result of composing.
         */
        public abstract RESULTOUTPUT getComposedResult();

        public Boolean getNoResult()
        {
            return _noResultValue;
        }

        /**
         * Clear any composed result and make strategy reusable as if it were
         * newly constructed.  This method is only called automatically at construction.
         * 
         * Owners should call to control the contents of their result list.
         */
        public abstract void reset();
    }

    /**
     * The default composition strategy.  This causes the first strategy that returns
     * a non-NoResult value to have it's value returned.
     *
     * @param <INPUT>
     * @param <OUTPUT>
     * @param <RESULTOUTPUT> 
     * @param <STRATEGY>
     */
    public final static class DefaultCompositionStrategy<INPUT, OUTPUT, RESULTOUTPUT, STRATEGY extends ISimpleStrategy<INPUT, OUTPUT>>
    extends AbstractCompositionStrategy<INPUT, OUTPUT, RESULTOUTPUT, STRATEGY>
    {
        private RESULTOUTPUT _result;

        /**
         * 
         */
        public DefaultCompositionStrategy()
        {
            super();
        }

        @Override
        public boolean compose(final CompositionArguments<INPUT, OUTPUT, STRATEGY> arg) throws Exception
        {
            final OUTPUT result = arg.getStrategy().perform(arg.getInput());
            if (result != arg.getStrategy().getNoResult())
            {
                _result = (RESULTOUTPUT)result;
                return true;
            }
            return false;
        }

        @Override
        public RESULTOUTPUT getComposedResult()
        {
            return _result;
        }

        @Override
        public void reset()
        {
            _result = null;
        }
    }

    /**
     * Bundle values needed by the composing strategies into a single arg object.
     *
     * @param <INPUT>
     * @param <OUTPUT>
     * @param <STRATEGY>
     */
    public final static class CompositionArguments<INPUT, OUTPUT, STRATEGY extends ISimpleStrategy<INPUT, OUTPUT>>
    {
        private final STRATEGY _strategy;
        private final INPUT _input;

        /**
         * @param strategy
         * @param input
         */
        public CompositionArguments(final STRATEGY strategy, final INPUT input)
        {
            _strategy = strategy;
            _input = input;
        }

        /**
         * @return the strategy
         */
        public STRATEGY getStrategy()
        {
            return _strategy;
        }

        /**
         * @return the input
         */
        public INPUT getInput()
        {
            return _input;
        }
    }
}