/**
 * Bundle class
 */
package onetomany.bargainingchipsgame;

import java.util.List;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

/**
 * Offers are exchanged in Bundle formats.
 * A Bundle is a set of several stacks, {s_1, ..., s_n}, where no two stacks are of the same color.
 * A stack can be aggregated into a bundle, if at the same color of one of the Bundle's stacks. 
 * Two bundles can also be aggregated into a new bundle, where every two stacks of the same colors from both bundles are aggregated into one stack in the new bundle.  
 * Aggregation of a bundle with the empty stack or empty bundle is itself.  
 * 
 * @author Faria Nassiri-Mofakham
 *
 */
public class Bundle implements Iterable<Stack>
{
	private List<Stack> bundle;

	public Bundle() 
	{
		this.bundle = new ArrayList<Stack>();
	}

	/**
	 * @return the bundle
	 */
	public List<Stack> getBundle() 
	{
		return bundle;
	}

	/**
	 * @param b the bundle to set
	 */
	public void setBundle(List<Stack> b) 
	{
		this.bundle = b;
	}

	public void addStack(Stack s) 
	{
		bundle.add(s);
	}

	@Override
	public String toString() 
	{
		return bundle.toString();
	}

	public int size()
	{
		if (bundle != null)
		{
			return getBundle().size();
		}
		else return 0;		
	}

	public Stack getStack(int i)
	{
		return getBundle().get(i);
	}

	public Iterator<Stack> iterator() 
	{
		return bundle.iterator();   
	}	


	public Double getPrice()
	{
		double sum=0.0;
		for (Stack t: bundle)
			sum += t.getPrice();
		return sum;
	}

	/**
	 * 
	 * bundle "+" bundle 
	 * 
	 * @param b, this method adds bundle b to `this' bundle
	 * @return the aggregated bundle
	 * where, any two stacks of the same colors are aggregated as a new stack into the new bundle, otherwise, they are just added into the new bundle.
	 * 
	 * This method just calls stack '+' stack aggregation operation (has no need to bundle "+" stack aggregation operation. 
	 */
	public Bundle aggregateWith(Bundle b) //This WORKED WELL although it is not in nice programming style (without calling aggregate with stack, below !
	{
		if (b!=null && this!=null)
		{
			Bundle l=new Bundle();		
			Boolean[] f1 = new Boolean[b.size()]; //flag for b bundle stack added
			Arrays.fill(f1, Boolean.FALSE);
			Boolean[] f2 = new Boolean[this.size()]; //flag for `this' bundle stack added
			Arrays.fill(f2, Boolean.FALSE);


			for (int i=0;i<b.size();i++) //loop over bundle b stacks
			{
				Stack s=b.getStack(i);

				for (int j=0; j<this.size();j++) //loop over `this' bundle stacks
				{	
					Stack t= this.getStack(j);
					if (!f1[i] && !f2[j] && t.getColor()==s.getColor())
					{
						l.addStack(t.aggregateWith(s)); //aggregate these two stacks (b's i-th and this j-th) into the new bundle l
						f1[i]=Boolean.TRUE;
						f2[j]=Boolean.TRUE;
					}
				}
				if (!f1[i])
					l.addStack(s); // so put i-th stack of bundle b directly into the new bundle
			}
			for (int j=0;j<this.size();j++)
				if (!f2[j])
					l.addStack(this.getStack(j)); // so put j-th stack of `this' bundle directly into the new bundle
			return l;
		}
		return this;
	}


	// previous try for calling two methods both with using iterators

	/**
	 * 	bundle "+" bundle       : second method (nested iterators by the other method), doesn't work correctly.
	 * 	
	 * @param b, this method adds bundle b to `this' bundle
	 * @return the aggregated bundle
	 * where, any two stacks of the same colors are aggregated as a new stack into the new bundle, otherwise, they are just added into the new bundle.
	 * 
	 * This method calls bundle "+" stack aggregation operation. 
	 */
	public Bundle aggregateWith333(Bundle b) 
	{
		if (b!=null && this!=null) 
		{
			Bundle l=new Bundle();
			for (Stack s : b) //loop over bundle b stacks
				l.aggregateWith333(s);  //aggregate stacks of b into `this' bundle by calling aggregateWith(stack), below
			return l;
		}
		return this;
	}



	/**
	 * 	bundle '+' stack
	 * 	
	 * @param s, this method adds stack s to `this' bundle
	 * @return the aggregated bundle
	 * where, stack s is aggregated with a stack of the same color in `this' bundle and the new stack is added into the new bundle;
	 * otherwise, stack s is just added into the new bundle.
	 * 
	 * This method is called by  
	 */
	public Bundle aggregateWith333(Stack s) 
	{
		if (s!=null && this!=null) 
		{
			Bundle b=new Bundle();
			Boolean f=Boolean.FALSE; //flag for stack s added

			for (Stack t : this.getBundle()) //loop over `this' bundle stacks
			{
				if (t.getColor()==s.getColor()) //if the stacks t and s are of the same colors
				{
					b.addStack(t.aggregateWith(s)); //aggregate stacks t and s and then add to the new bundle
					f=true;
				}
				else 
					b.addStack(t); // so put the stack of `this' bundle directly into the new bundle
			}
			if (!f) //s not aggregated with any stack in `this' bundle 
				b.addStack(s);  // so put stack s directly into the new bundle
			return b;
		}
		return this;	
	}



}