source: src/main/java/onetomany/bargainingchipsgame/Bundle.java@ 290

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

import java.util.List;

import java.util.ArrayList;
import java.util.Collections;
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.  
 * 
 * Immutable.
 */
public class Bundle implements Iterable<Stack>
{
        private final List<Stack> bundle;
        
        /**
         * Makes sure bundle remains unmodifiable.
         */
        public Bundle(List<Stack> list)
        {
        List<Stack> tmpListOfHolding = new ArrayList<Stack>();
        tmpListOfHolding.addAll(list);
        this.bundle = Collections.unmodifiableList(tmpListOfHolding);
    }

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

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

        public int size()
        {
                return getBundle().size();
        }

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


        public Double getTotalPrice()
        {
                double sum=0.0;
                for (Stack t: bundle)
                        sum += t.getTotalPrice();
                return sum;
        }
        
        /**
         * Gets the quantity of the right stack in this bundle 
         */
        public Integer getQuantity(Chip c)
        {
                for (Stack s : this)
                        if (s.getChip().equals(c))
                                return s.getQuantity();
                return null;
        }

        /**
         * Gets the unit price of the chip in the right stack in this bundle 
         */
        public double getUnitPrice(Chip c)
        {
                for (Stack s : this)
                        if (s.getChip().equals(c))
                                return s.getUnitPrice();
                return 0.0;
        }

        /**
         * 
         * 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) 
        {
                // Start with this bundle
                Bundle agg = new Bundle(this.getBundle());
                // And add all stacks from b
                for (Stack t : b)
                        agg = agg.aggregateWith(t);
                        
                return agg;
        }


        

        /**
         *      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.
         */
        public Bundle aggregateWith(Stack s)
        {
                ArrayList<Stack> agg = new ArrayList<Stack>();
                boolean sameColorFound = false;
                for (Stack t : bundle)
                        if (!t.hasSameColorAs(s)) 
                                agg.add(t);
                        else
                        {
                                agg.add(s.aggregateWith(t));
                                sameColorFound = true;
                        }
                if (!sameColorFound)
                        agg.add(s);
                return new Bundle(agg);
        }

        public static void main(String[] args) 
        {
                Bundle b = new BundleBuilder()
                                                        .addStack("Red", 7.0, 3)
                                                        .addStack("Green", 3.0, 5)
                                                        .addStack("Purple", 2.0, 7)
                                                        .build();
                
                Bundle c = new BundleBuilder()
                                .addStack("Red", 5.0, 3)
                                .addStack("Yellow", 9.0, 1)
                                .addStack("Green", 9.0, 1)
                                .build();
                
                System.out.println(b);
                System.out.println(b.aggregateWith(new Stack("Green", 3.0, 2)));
                System.out.println(b.aggregateWith(c));
        }



}