package jcircus.parallelism;
import java.util.*;

public class FriendshipSets {
	HashSet <HashSet <Integer>> friendshipSets = new HashSet <HashSet <Integer>> ();
	public FriendshipSets () {
		friendshipSets = new HashSet <HashSet <Integer>> ();
	}
	public FriendshipSets (HashSet <HashSet <Integer>> x) {
		this.friendshipSets = x;
	}
	
	public HashSet <HashSet <Integer>> getFriendshipSets () {
		return this.friendshipSets;
	}
	public void setFriendshipSets (HashSet <HashSet <Integer>> x) {
		this.friendshipSets = x;
	}
    public static Vector <String> intersection (Vector <String> str1, Vector <String> str2) {
    	Vector <String> intersec = new Vector <String> ();
    	for (int i = 0; i < str1.size(); i++) {
    		if (str2.contains(str1.elementAt(i))) {
    			intersec.addElement(str1.elementAt(i));
    		}
    	}
    	return intersec;
    }
    public static Vector <String> forcedInter (Vector <String> str1, Vector <String> str2, Vector <String> channelSet) {
    	Vector <String> intersec = intersection (str1, str2);
    	Vector <String> forced = new Vector <String> ();
    	for (int i = 0; i < intersec.size(); i++) {
    		if (!channelSet.contains(intersec.elementAt(i))) {
    			forced.addElement(intersec.elementAt(i));
    		}
    	}
    	return forced;
    }
	private static HashSet <Integer> union (HashSet <Integer> x, HashSet <Integer> y) {
		HashSet <Integer> z = new HashSet <Integer> ();
		z.addAll(x);
		z.addAll(y);
		return z;
	}
	public static HashSet <HashSet <Integer>> interleave (HashSet <HashSet <Integer>> x, HashSet <HashSet <Integer>> y) {
		HashSet <HashSet <Integer>> z = new HashSet <HashSet <Integer>> ();
		z.addAll(x);
		z.addAll(y);
		return z;
	}
	public static HashSet <HashSet <Integer>> cartesianProduct (HashSet <HashSet <Integer>> x, HashSet <HashSet <Integer>> y) {
		HashSet <HashSet <Integer>> setset = new HashSet <HashSet <Integer>> ();
		for (int i = 0; i < x.size(); i++) {
			for (int j = 0; j < y.size(); j++) {
				HashSet <HashSet <Integer>> z = new HashSet <HashSet <Integer>> ();
				setset.add(union ((HashSet <Integer>)x.toArray() [i], (HashSet <Integer>)y.toArray() [j]));
			}
		}
		return setset;
	}
	
	public static Vector <Integer> allIndexes (String chan, HashMap <String, FriendshipSets> map) {
		FriendshipSets fs = map.get(chan);
		Vector <Integer> all = new Vector <Integer> ();
		HashSet <HashSet <Integer>> fs2 = fs.getFriendshipSets();
		Object [] fs2Array = fs2.toArray();
		for (int i = 0; i < fs2Array.length; i++) {
			Object [] fs2ArrayArray = ((HashSet <Integer>) fs2Array [i]).toArray();
			for (int j = 0; j < fs2ArrayArray.length; j++) {
				//if (!all.contains(fs2ArrayArray [j]))
					//all.add((Integer) fs2ArrayArray [j]);
			}
			all.add(i);
		}
		return all;
	}
	public void interleave (HashSet <HashSet <Integer>> y) {
		this.friendshipSets = interleave (this.friendshipSets, y);
	}
	public void cartesianProductSync (HashSet <HashSet <Integer>> y) {
		this.friendshipSets = cartesianProduct (this.friendshipSets, y);
	}
	public static Integer [] renamingIndexes (HashSet <HashSet <Integer>> friendsSet, int index) {
		int counter = 0, aux = 0;
		Object/*HashSet <Integer>*/ [] friendsSetArray = /*(HashSet <Integer> [])*/ friendsSet.toArray();
		for (int i = 0; i < friendsSet.size(); i++) {
			if (((HashSet <Integer>)friendsSetArray [i]).contains(index)) {
				counter++;
			}
		}
		Integer [] indexes = new Integer [counter];
		for (int i = 0; i < friendsSet.size(); i++) {
			if (((HashSet <Integer>)friendsSetArray [i]).contains(index)) {
				indexes[aux] = i;
				aux++;
			}
		}
		/*if (indexes.length == 0) {
			return new Integer [] {0};
		}*/
		return indexes;
	}
	public static HashMap <String, Integer []> renamingIndexes (HashMap <String, FriendshipSets> spfemap, int index) { //Mapeia nomes de canais a indices de renomeacao.
		HashMap <String, Integer []> mapstrint = new HashMap <String, Integer []> ();										//sera usado para construir acoes renomeadas
		Object [] keys = spfemap.keySet().toArray();
		for (int i = 0; i < spfemap.size(); i++) {
			mapstrint.put((String) keys [i], ((Integer []) renamingIndexes (spfemap.get(keys[i]).getFriendshipSets(), index)));
		}
		return mapstrint;
	}

	public static void printSetOfSets (FriendshipSets pfe) {
		if (pfe != null)
			printSetOfSets (pfe.getFriendshipSets());
	}
	public static String printMap (HashMap <String, FriendshipSets> map) {
		String str = "";
		Object [] keys = map.keySet().toArray();
		for (int i = 0; i < keys.length; i++) {
			str = str + (String)keys [i] + " -> " + printSetOfSets (map.get((String)keys [i]).getFriendshipSets());
			str = str + "\n";
		}
		return str;
	}
	public static String printSetOfSets (HashSet <HashSet <Integer>> setofsets) {
		String str = "";
		str = str + "{";
		for (int i = 0; i < setofsets.size(); i++) {
			if (i != 0) {
				str = str + ", ";
			}
			str = str + "{";
			Set <Integer> set = (Set <Integer>) setofsets.toArray()[i];
			for (int j = 0; j < set.size(); j++) {
				if (j != 0) {
					str = str + ", ";
				}
				Integer x = (Integer) set.toArray() [j];
				str = str + x;
			}
			str = str + "}";
		}
		str = str + "}";
		return str;
	}
	
	public static void main (String args []) {
/**ABAIXO TRECHO DE C�DIGO USADO PARA TESTAR OS M�TODOS DE PRODUTO CARTESIANO E INTERLEAVE**/		
		HashSet <HashSet <Integer>> h0;
		HashSet <HashSet <Integer>> h1;
		HashSet <HashSet <Integer>> h2;
		HashSet <HashSet <Integer>> h3;
		HashSet <HashSet <Integer>> h4;
		HashSet <HashSet <Integer>> h5;
		HashSet <HashSet <Integer>> h6;
		HashSet <HashSet <Integer>> h7;
		HashSet <HashSet <Integer>> h8;
		HashSet <HashSet <Integer>> h9;
		
		HashSet <Integer> zero = new HashSet <Integer> ();
		zero.add(0);
		HashSet <HashSet <Integer>> zeroset = new HashSet <HashSet <Integer>> ();
		zeroset.add(zero);

		HashSet <Integer> um = new HashSet <Integer> ();
		um.add(1);
		HashSet <HashSet <Integer>> umset = new HashSet <HashSet <Integer>> ();
		umset.add(um);

		HashSet <Integer> dois = new HashSet <Integer> ();
		dois.add(2);
		HashSet <HashSet <Integer>> doisset = new HashSet <HashSet <Integer>> ();
		doisset.add(dois);

		HashSet <Integer> tres = new HashSet <Integer> ();
		tres.add(3);
		HashSet <HashSet <Integer>> tresset = new HashSet <HashSet <Integer>> ();
		tresset.add(tres);

		HashSet <Integer> quatro = new HashSet <Integer> ();
		quatro.add(4);
		HashSet <HashSet <Integer>> quatroset = new HashSet <HashSet <Integer>> ();
		quatroset.add(quatro);

		HashSet <Integer> cinco = new HashSet <Integer> ();
		cinco.add(5);
		HashSet <HashSet <Integer>> cincoset = new HashSet <HashSet <Integer>> ();
		cincoset.add(cinco);

		HashSet <HashSet <Integer>> seisset = interleave (doisset, tresset);
		HashSet <HashSet <Integer>> seteset = interleave (quatroset, cincoset);
		HashSet <HashSet <Integer>> oitoset = cartesianProduct (seisset, seteset);
		HashSet <HashSet <Integer>> noveset = interleave (oitoset, umset);
		HashSet <HashSet <Integer>> dezset = cartesianProduct (zeroset, noveset);

		printSetOfSets (dezset);
/**ACIMA TRECHO DE C�DIGO USADO PARA TESTAR OS M�TODOS DE PRODUTO CARTESIANO E INTERLEAVE**/		
	}

	/*public static HashSet <HashSet <Integer>> miniDispute (HashSet <Integer> set1, HashSet <Integer> set2) throws Exception {
		HashSet <Integer> set = new HashSet ();
		HashSet <HashSet <Integer>> setofsets = new HashSet <HashSet <Integer>> ();
		if (set1.size() == 1 && set2.size () == 1) {
			Integer x = (Integer) set1.toArray()[0];
			Integer y = (Integer) set2.toArray()[0];
			set.add(x);
			set.add(y);
			setofsets.add(set);
			return setofsets;
		}
		else if (set1.size () == 1 && set2.size() == 2) {
			Integer x = (Integer) set1.toArray()[0];
			Integer y = (Integer) set2.toArray()[0];
			Integer z = (Integer) set2.toArray()[1];
			HashSet <Integer> s1 = new HashSet <Integer> ();
			HashSet <Integer> s2 = new HashSet <Integer> ();
			HashSet <Integer> s3 = new HashSet <Integer> ();
			s1.add(x); s1.add(y);
			s2.add(x); s2.add(z);
			s3.add(y); s3.add(z);
			setofsets.add(s1);
			setofsets.add(s2);
			setofsets.add(s3);
			return setofsets;
		}
		else if (set1.size () == 2 && set2.size() == 1) {
			Integer x = (Integer) set1.toArray()[0];
			Integer y = (Integer) set1.toArray()[1];
			Integer z = (Integer) set2.toArray()[0];
			HashSet <Integer> s1 = new HashSet <Integer> ();
			HashSet <Integer> s2 = new HashSet <Integer> ();
			HashSet <Integer> s3 = new HashSet <Integer> ();
			s1.add(x); s1.add(y);
			s2.add(x); s2.add(z);
			s3.add(y); s3.add(z);
			setofsets.add(s1);
			setofsets.add(s2);
			setofsets.add(s3);
			return setofsets;
		}
		else if (set1.size () == 2 && set2.size() == 2) {
			Integer x = (Integer) set1.toArray()[0];
			Integer y = (Integer) set1.toArray()[1];
			Integer z = (Integer) set2.toArray()[0];
			Integer w = (Integer) set2.toArray()[1];
			System.out.println ("Dispute: " + x + ", " + y + ", " + z + ", " + w);
			HashSet <Integer> s1 = new HashSet <Integer> ();
			HashSet <Integer> s2 = new HashSet <Integer> ();
			HashSet <Integer> s3 = new HashSet <Integer> ();
			HashSet <Integer> s4 = new HashSet <Integer> ();
			HashSet <Integer> s5 = new HashSet <Integer> ();
			HashSet <Integer> s6 = new HashSet <Integer> ();
			s1.add(x); s1.add(z);
			s2.add(x); s2.add(w);
			s3.add(y); s3.add(z);
			s4.add(y); s4.add(w);
			s5.add(x); s5.add(y);
			s6.add(z); s6.add(w);
			setofsets.add(s1);
			setofsets.add(s2);
			setofsets.add(s3);
			setofsets.add(s4);
			setofsets.add(s5);
			setofsets.add(s6);
			return setofsets;
		}
		else {
			throw new Exception ("Wrong combination of sets");
		}
	}
	public static HashSet <HashSet <Integer>> disputeMerge (HashSet <HashSet <Integer>> set1, HashSet <HashSet <Integer>> set2) throws Exception { //N�O TESTADA AINDA
		HashSet <HashSet <Integer>> set = new HashSet <HashSet <Integer>> ();
		for (int i = 0; i < set1.size(); i++) {
			for (int j = 0; j < set2.size(); j++) {
				set.addAll(miniDispute((HashSet <Integer>) set1.toArray()[i], (HashSet <Integer>) set2.toArray()[i]));
			}
		}
		return set;
	}
	public static void printMiniDispute (HashSet <HashSet <Integer>> setofsets) {
		System.out.print ("{");
		for (int i = 0; i < setofsets.size(); i++) {
			if (i != 0) {
				System.out.print (", ");
			}
			System.out.print ("{");
			Set <Integer> set = (Set <Integer>) setofsets.toArray()[i];
			for (int j = 0; j < set.size(); j++) {
				if (j != 0) {
					System.out.print (", ");
				}
				Integer x = (Integer) set.toArray()[j];
				System.out.print (x);
			}
			System.out.print ("}");
		}
		System.out.print ("}");
	}
	public static void main (String args []) {
		HashSet <Integer> set1 = new HashSet <Integer> ();
		HashSet <Integer> set2 = new HashSet <Integer> ();
		set1.add(1);
		set1.add(2);
		set2.add(3);
		set2.add(4);
		try {
			printMiniDispute (miniDispute (set1, set2));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}*/
}