import java.util.*;
public class BinPack {

	private int[] data;           // the data to be packed
	private Bin[] bin;            // the bins to pack em into
	private int binCapacity;      // the capacity of each bin
	private int numberOfItems;    // number of items to pack
	private int numberOfBins;     // number of bins you have
	private String id;            // an idendification for the problem
	private boolean packed = false;
	
	public BinPack(int NumberOfItems, int NumberOfBins, int Capacity)
	{
		numberOfItems = NumberOfItems;
		numberOfBins = NumberOfBins;
		binCapacity = Capacity;
		id = "Unknown";
		data = new int[numberOfItems];
		bin = new Bin[numberOfBins];
		for (int i=0;i<numberOfItems;i++)
		{
			data[i] = 0;
		}
	
		for (int i=0; i<numberOfBins; i++)
		{
			bin[i] = new Bin(i,binCapacity);
		}
	}


  // default constructor
  // produce a binpacking problem, but the data is NOT specified

	public BinPack(String fname, int NumberOfItems, int NumberOfBins, int Capacity) throws Exception 
	{
		this(NumberOfItems,NumberOfBins,Capacity);
		id = fname;
		MyIo fin = new MyIo(fname);
		for (int i=0; i<NumberOfItems; i++)
		{
			data[i]=fin.getNextInt();
		}
		fin.close();
	}


  // The actual constructor.
  // reads the binpacking problem from a file, called fname


	public int binCapacity()
	{	
		return binCapacity;
	}

	public int numberOfItems()
	{	
		return numberOfItems;
	}

 	public int numberOfBins()
	{
			return numberOfBins;
	}

	public Bin[] bin()
	{
		return bin;
	}

	public int[] data()
	{
		return data;
	}

	
	public void clear()
	{
		for (int i=0; i<numberOfBins; i++)
		{
			bin[i].clear();
		}
	}	

  // clear out all the bins

	public String toString()
	{
		String s = id + "  Capacity: " + binCapacity;
    	       	s = s + " Items: " + numberOfItems +"\n";
   		for (int i=0;i<numberOfBins;i++)
		{
			if (!bin[i].isEmpty())
			{
				s = s + bin[i].toString() + "\n";
			}
		}
    		return s;
	}

  // So you can print a BinPack object

	public boolean isLegalPacking()
	{
		for (int i = 0; i < numberOfBins(); i++)
		{
			if (!bin[i].isLegal())
			{
				return false;
			}
		}
		if ((numberOfItems()>0))
		{
			return false;
		}
		return true;		
	}	
  
  // Is the packing produced legal? That is, does it
  // actually pack all the items in data into the bins
  // such that bin capacities are respected and no more than the
  // given number of bins is used?

	private void add(int binObject,int dataElemant)
	{
		bin[binObject].add(data[dataElemant]);
		data[dataElemant] = 0;
		numberOfItems--;
	}
	
	public void pack()
	{
		int itemcapacity = numberOfItems();
		for(int i = 0; i<itemcapacity; i++) 
		{	
			if (data[i]!=0)
			{
				for(int j = 0; (j<numberOfBins())&&(data[i]!=0); j++)
				{
					if(data[i]<=(binCapacity-bin[j].totalWeight()))
					{
						add(j,i);
					}
				}
			}
		}
	}
}