package jcircus.parallelism;
  
  import java.util.HashMap;
  import java.util.LinkedHashMap;
  import java.util.Vector;
  
  import jcircus.complementaryenvs.ChanComplexCommEnv;
  import jcircus.complementaryenvs.ChanDimEnv;
  import jcircus.complementaryenvs.ChanTransMSEnv;
  import jcircus.complementaryenvs.Coadj2SimpleSynchTransEnv;
  import jcircus.translator.Translator2Java;
  
  public class HiddenFromGUIInfo {
  	private HashMap <String, String> map;
  	private HashMap <String, Vector <String>> reversemap;
  	private HashMap <String, Boolean> hasHidden;
  	private HashMap <String, Boolean> putChannelsDecl;
  	private HashMap <String, Boolean> putChannelsAtt;
  	private HashMap <String, Boolean> putChannelsActionPerformed;
  
  	public void putPutDecl (String chan, Boolean put) {
  		if (putChannelsDecl.containsKey(chan))
  			this.putChannelsDecl.remove(chan);
  		this.putChannelsDecl.put(chan, put);
  	}
  	public Boolean getPutDecl (String chan) {
  		if (this.putChannelsDecl.get(chan) == null) {
  			return false;
  		}
  		return this.putChannelsDecl.get(chan);
  	}
  
  	public void putPutAtt (String chan, Boolean put) {
  		if (putChannelsAtt.containsKey(chan))
  			this.putChannelsAtt.remove(chan);
  		this.putChannelsAtt.put(chan, put);
  	}
  	public Boolean getPutAtt (String chan) {
  		if (this.putChannelsAtt.get(chan) == null) {
  			return false;
  		}
  		return this.putChannelsAtt.get(chan);
  	}
  
  	public void putPutActionPerformed (String chan, Boolean put) {
  		if (putChannelsActionPerformed.containsKey(chan))
  			this.putChannelsActionPerformed.remove(chan);
  		this.putChannelsActionPerformed.put(chan, put);
  	}
  	public Boolean getPutActionPerformed (String chan) {
  		if (this.putChannelsActionPerformed.get(chan) == null) {
  			return false;
  		}
  		return this.putChannelsActionPerformed.get(chan);
  	}
  
  	private Vector <String> mainChannels = new Vector <String> ();
  	private Vector <String> coadjChannels = new Vector <String> ();
  	public HiddenFromGUIInfo () {
  		this.map = new LinkedHashMap <String, String> ();
  		this.reversemap = new LinkedHashMap <String, Vector <String>> ();
  		this.hasHidden = new LinkedHashMap <String, Boolean> ();
  		this.putChannelsDecl = new LinkedHashMap <String, Boolean> ();
  		this.putChannelsAtt = new LinkedHashMap <String, Boolean> ();
  		this.putChannelsActionPerformed = new LinkedHashMap <String, Boolean> ();
  	}
  	private void putMainChannel (String mainChannel) {
  		if (!mainChannels.contains(mainChannel))
  			mainChannels.add(mainChannel);
  	}
  	private void putCoadjChannel (String coadj) {
  		if (!coadjChannels.contains(coadj))
  			coadjChannels.add(coadj);		
  	}
  	public Vector <String> getMainChannels () {
  		return this.mainChannels;
  	}
  	public Vector <String> getCoadjChannels () {
  		return this.coadjChannels;
  	}
  	public void put (String hidden, String chan) {
  		putMainChannel (chan);
  		putCoadjChannel (hidden);
  		if (!this.map.containsKey(hidden))
  			this.map.put(hidden, chan);
  	}
  	public String get (String hidden) {
  		return this.map.get(hidden);
  	}
  	public HashMap <String, String> getMap () {
  		return this.map;
  	}
  	private void addWithoutDuplicate (Vector <String> target, Vector <String> add) {
  		for (int i = 0; i < add.size(); i++) {
  			if (!target.contains(add.elementAt(i))) {
  				target.addElement(add.elementAt(i));
  			}
  		}
  	}
  	public void reversePut (String chan, Vector <String> hidden) {
  		if (this.mainChannels.contains(chan)) {
  			Vector <String> newhid = new Vector <String> ();
  			if (this.reverseGet(chan) != null)
  				newhid.addAll(this.reverseGet(chan));
  			addWithoutDuplicate (newhid, hidden);
  			this.reversemap.remove(chan);
  			this.reversemap.put(chan, newhid);
  		}
  		else {
  			this.reversemap.put(chan, hidden);
  		}
  	}
  	public Vector <String> reverseGet (String chan) {
  		//reverseGet retorna os canais coadjuvantes do canal principal + o próprio canal principal. Ex:
  			//reverseGet ("chan") = ["chan, "chan0", "chan1", "chan2"]
  		Vector <String> reverseget = this.reversemap.get(chan);
  		if (reverseget == null) {
  			//Se reverseget for vazio, 
  				//significa que o canal não tem canais coadjuvantes, e portanto não foi renomeado. 
  				//Isso tudo significa que ele não precisou de intercalação forçada. Retornamos um vector com o seu nome por facilidade de implementação
  			Vector <String> itself = new Vector <String> ();
  			itself.addElement(chan);
  			return itself;
  		}
  		else
  			return reverseget;
  	}
  	public Vector <String> reverseGetWithoutMainChannel (String chan) {
  		//reverseGetWithoutMainChannel retorna os canais coadjuvantes do canal principal
  		//difere de reverseGet porque este não retorna o canal principal. Ex:
  			//reverseGet ("chan") = ["chan0", "chan1", "chan2"]
  		Vector <String> withoutmainchannel = new Vector <String> (this.reverseGet(chan));
  		withoutmainchannel.remove(chan);
  		return new Vector <String> (withoutmainchannel);
  	}
  	public void put (String chan, Vector <String> hidden) {
  		int vecsize = hidden.size();
  		for (int i = 0; i < vecsize; i++) {
  			this.put(hidden.elementAt (i), chan);
  			this.reversePut(chan, hidden);
  		}
  		this.hasHidden.put(chan, true);
  	}
  	public boolean hiddenGet (String chan) {
  		if (hasHidden.containsKey(chan))
  			return hasHidden.get(chan);
  		else {
  			return false;
  		}
  	}
  	public static Vector <String> toVector (String [] s) {
  		Vector <String> vec = new Vector <String> ();
  		for (int i = 0; i < s.length; i++) {
  			vec.add(s [i]);
  		}
  		return vec;
  	}
  	//readOrWrite =
  		//0, se READ
  		//1, se WRITE
  		//Se nem 0 nem 1, SYNC
  	private static String syncKind (boolean simpleSync, int readOrWrite, String chanName, int dim/*, String content*/) {
  		if (!simpleSync) {
  			return "timerSync(area, new int [] {0}, finalvaluesstr" + /*content +*/ ")/*syncKind*/";
  		}
  		else {
  			if (readOrWrite == 1)
  				//return "guiTimerSimpleWrite (values " + Translator2Java.guibracketized (dim - 1) + ", area, finalvaluesstr)/*syncKind*/";
  				return "timerSync(area, new int [] {0}, finalvaluesstr" + /*content +*/ ")/*syncKindTimerSimpleWrite*/";
  			else //if (readOrWrite == 1)
  				return "guiTimerSimpleRead (area, finalvaluesstr);";
  		}
  	}
  	public static String hiddenSyncCode (Vector <String> hiddenChans,
  			ChanComplexCommEnv cce, ChanDimEnv cde, Coadj2SimpleSynchTransEnv c2sste, 
  			int readOrWrite, HiddenFromGUIInfo hid/*, String content*/) {
  		String str = "";
  		str = str + "
  \t\tSystem.out.println (\"btn time millis: \" + System.currentTimeMillis());
  ";
  		str = str + "\t\tfinal String finalvaluesstr = valuesstr;
  ";
  		Vector <String> mainChannels = hid.getMainChannels();
  		for (int i = 0; i < hiddenChans.size(); i++) {
  			String currentChannel = hiddenChans.elementAt(i);
  			boolean isComplex = cce.get (currentChannel);
  			Integer dimension = cde.get (currentChannel);
  			boolean simpleSync = c2sste.get (currentChannel);
  			String syncKind = syncKind (simpleSync, readOrWrite, currentChannel, dimension/*, content*/);
  			String bracketizeds = (
  					isComplex?
  							Translator2Java.ccBracketizedsValues (dimension, currentChannel) :
  							Translator2Java.bracketizedsValues (dimension)
  			);
  			if (!mainChannels.contains(currentChannel)) {
  				String mainChannelOfCurrentChannel = hid.get(currentChannel);
  				Vector <String> reverseWithoutMain = hid.reverseGetWithoutMainChannel (mainChannelOfCurrentChannel);
  				if (reverseWithoutMain.size() <= 1) {
  					str = str + "\t\t/*Deprecated condition in this line...*/ 
  ";
  
  							/*"\t\tCSProcess p_" + mainChannelOfCurrentChannel
  							+ " = new CSProcess () {public void run () {"
  							+ mainChannelOfCurrentChannel + "" +
  							bracketizeds + "." +
  							syncKind + ";}};
  ";*/
  				}
  				else {
  					str = str + 
  							"\t\tCSProcess p_" + currentChannel
  							+ " = new CSProcess () {public void run () {"
  							+ currentChannel + "" +
  							bracketizeds/*dimCode*/ + "." +
  							syncKind + ";}};/*****/
  ";
  					System.out.print ("");
  				}
  			}
  			else {
  				str = str + 
  					"\t\tCSProcess p_" + currentChannel
  					+ " = new CSProcess () {public void run () {"
  					+ currentChannel + "" +
  					bracketizeds + "." +
  					syncKind + ";}};/***/
  ";
  			}
  		}
  		for (int i = 0; i < hiddenChans.size(); i++) {
  			String currentChannel = hiddenChans.elementAt(i);
  			if (!mainChannels.contains(currentChannel)) {
  				String mainChannelOfCurrentChannel = hid.get(currentChannel);
  				Vector <String> reverseWithoutMain = hid.reverseGetWithoutMainChannel (mainChannelOfCurrentChannel);
  				if (reverseWithoutMain.size() <= 1) {
  					str = str +
  						"		p_" + mainChannelOfCurrentChannel + "";
  							str = str + ".run();
  ";
  				}
  				else {
  					str = str +
  							"		p_" + currentChannel + "";
  								str = str + ".run();
  ";
  				}
  			}
  		}
  		return str;
  	}
  }