package abstractions;

import java.util.Iterator;

public class IntSet {
private int elems[];
private int size;
private static int initialSize=2;


public IntSet()
{
	elems=new int[initialSize];
	size=0;
}

//This exposes rep. elems
//public IntSet(int a[])
//{
//	elems = a;
//	size = a.length;
//}

/**
 * This one avoid rep. exposure. But an iterator is better.
 * @return
 */
public int[] getElements()
{
	int a[] = new int[size];
	System.arraycopy(elems,0, a, 0, size);
	return a;
}

/**
 * 
 * @return the number integers in set
 */
public int size()
{
	return size;
}

/**
 * 
 * @param x the integer to be checked
 * @return true if x is in this set
 */
public boolean isIn(int x)
{
	return getIndex(x)>-1;
}

/**
 * 
 * @param x the integer to be inserted
 * EFFECTS: if x is in the set, nothing happens;
 *          otherwise, x is added into this set.
 */
public void insert(int x)
{
	int xIndex = getIndex(x);
	if (size==0){
		//assert xIndex==-1
		}
	if (xIndex<0)
	{
		resize();
		elems[size++]=x;
	}
}
private int getIndex(int x)
{
	for (int i=0; i<size; ++i)
	{
		if (elems[i]==x)
		{
			return i;
		}
	}
	return -1;
}
private void resize()
{
	if (size==elems.length)
	{
		int tmp[]=new int[elems.length*2];
		System.arraycopy(elems,0,tmp,0,elems.length);
		elems = tmp;
	}
}

/**
 * 
 * @param x the integer to be removed
 * EFFECTS: removes x from this set if it is in it.
 */
public void remove(int x)
{
	int xIndex = getIndex(x);
	if (xIndex<0)
	{
		return;
	}
	for (int i=xIndex; i<size-1;++i)
	{
		elems[i]=elems[i+1];
	}
	--size;
}

/**
 * return this - set
 */
public IntSet diff(IntSet set){
	IntSet result = new IntSet();
	for (int i=0; i<size;++i){
		if (!set.isIn(elems[i])){
			result.insert(elems[i]);
		}
	}
	return result;
}

public static IntSet diff(IntSet set1, IntSet set2){
	IntSet result = new IntSet();
	for (int i=0; i<set1.size;++i){
		if (!set2.isIn(set1.elems[i])){
			result.insert(set1.elems[i]);
		}
	}
	return result;
}

/**
 * rep invariant:
 * elems!=null && for 0<=i,j<index, i!=j => elems[i]!=elems[j]
 * @return
 */
public boolean repOk()
{
	if (null==elems)
	{
		return false;
	}
	for (int i=0; i<size;++i)
	{
		for (int j=i+1; j<size;++j)
		{
			if (elems[i]==elems[j])
			{
				return false;
			}
		}
	}
	return true;
}

public String toString()
{
	String tmp="{";
	for (int i=0; i<size-1;++i)
	{
		tmp += elems[i]+",";
	}
	if (size>0)
	{
		tmp += elems[size-1];
	}
	tmp+="}";
	return tmp;
}

/**
 * EFFECTS: returns an iterator for IntSet.
 * REQUIRES: When one iterator is in use, do not call remove on another.
 */
public Iterator iterator()
{
//	return new IntSetIterator(this);
	return new IntSetIterator1();
}
private static class IntSetIterator implements Iterator
{
	private IntSet aSet;
	private int curr=0;

	public IntSetIterator(IntSet aSet)
	{
	  this.aSet = aSet;	
	}
	public boolean hasNext()
	{
		return (curr<aSet.size);
	}
	public Object next()
	{
		Integer tmp = new Integer(aSet.elems[curr]);
		curr++;
		return tmp;
	}
	public void remove()
	{
		int toBeRemoved = aSet.elems[curr];
		aSet.remove(toBeRemoved);
	}
}
private class IntSetIterator1 implements Iterator
{
	private int curr=0;

	public boolean hasNext()
	{
		return (curr<size);
	}
	public Object next()
	{
		Integer tmp = new Integer(elems[curr]);
		curr++;
		return tmp;
	}
	public void remove()
	{
		int toBeRemoved = elems[curr];
		IntSet.this.remove(toBeRemoved);
	}
}
}