package mars.tools;

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.MouseInfo;
import java.awt.PointerInfo;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.font.FontRenderContext;
import java.awt.font.TextLayout;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Vector;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import mars.Globals;




import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;


class UnitAnimation extends JPanel
implements ActionListener {
/**
 * 
 */
 private static final long serialVersionUID = -2681757800180958534L;

 //config variables
 private int PERIOD = 8;    // velocity of frames in ms
 private static final int PWIDTH = 1000;     // size of this panel
 private static final int PHEIGHT = 574;
 private GraphicsConfiguration gc;
 private GraphicsDevice gd;   	// for reporting accl. memory usage
 private int accelMemory;   
 private DecimalFormat df;
 
 private int counter;			//verify then remove.
 private boolean justStarted; 	//flag to start movement


 private int indexX;	//counter of screen position
 private int indexY;
 private boolean xIsMoving, yIsMoving; 		//flag for mouse movement.

// private Vertex[][] inputGraph;
 private Vector<Vector<Vertex>>  outputGraph;
 private ArrayList<Vertex> vertexList;
 private ArrayList<Vertex> vertexTraversed;
 //Screen Label variables
 
 private HashMap<String, String> registerEquivalenceTable;

 private String instructionCode;
 
 private int countRegLabel;
 private int countALULabel;
 private int countPCLabel;
 
private int register = 1;
private int control = 2;
private int aluControl = 3;
private int alu = 4;
private int datapatTypeUsed;
  
 private Boolean cursorInIM, cursorInALU, cursorInDataMem, cursorInReg;
 
 private Graphics2D g2d;
 
 private BufferedImage datapath;

 class Vertex {
		private int numIndex;
	   	private int init;
	   	private int end;
	   	private int current;
	   	private String name;
	   	public static final int movingUpside = 1;
	   	public static final int movingDownside = 2;
	   	public static final int movingLeft = 3;
	   	public static final int movingRight = 4;
	   	public int direction;
	   	public int oppositeAxis;
	   	private boolean isMovingXaxis;
	   	private Color color;
	   	private boolean first_interaction;
	   	private boolean active;
	   	private boolean isText;
	   	private ArrayList<Integer> targetVertex;
	   	
	   	public Vertex(int index, int init, int end, String name, int oppositeAxis, boolean isMovingXaxis, 
	   			String listOfColors, String listTargetVertex, boolean isText){
	   		this.numIndex = index;
	   		this.init = init;
	   		this.current = this.init;
	   		this.end = end; 
	   		this.name = name;
	   		this.oppositeAxis = oppositeAxis;
	   		this.isMovingXaxis = isMovingXaxis;
	   		this.first_interaction = true;
	   		this.active = false;
	   		this.isText = isText;
	   		this.color = new Color(0,153,0);
	   		if(isMovingXaxis == true){
	   			if( init < end)
	   				direction = movingLeft;
	   			else 
	   				direction = movingRight;
	   			
	   		}
	   		else{
	   			if( init < end)
	   				direction = movingUpside;
	   			else 
	   				direction = movingDownside;
	   		}
	   		String[] list =  listTargetVertex.split("#");
	   		targetVertex = new ArrayList<Integer>();
	   		for(int i = 0; i < list.length; i++){
	   			targetVertex.add(Integer.parseInt(list[i]));
	   		//	System.out.println("Adding " + i + " " +  Integer.parseInt(list[i])+ " in target");
	   		}
	   		String[] listColor =  listOfColors.split("#");
	   		this.color = new Color(Integer.parseInt(listColor[0]) , Integer.parseInt(listColor[1]),  Integer.parseInt(listColor[2]) );
	   	}
	 	
	   	public int getDirection(){
	   		return direction;
	   	}
	   	
		public boolean isText(){
	   		return this.isText;
	   	}


		public ArrayList<Integer> getTargetVertex() {
			return targetVertex;
		}

		public int getNumIndex() {
			return numIndex;
		}
		public void setNumIndex(int numIndex) {
			this.numIndex = numIndex;
		}
		public int getInit() {
			return init;
		}
		public void setInit(int init) {
			this.init = init;
		}
		public int getEnd() {
			return end;
		}
		public void setEnd(int end) {
			this.end = end;
		}
		public int getCurrent() {
			return current;
		}
		public void setCurrent(int current) {
			this.current = current;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public int getOppositeAxis() {
			return oppositeAxis;
		}
		public void setOppositeAxis(int oppositeAxis) {
			this.oppositeAxis = oppositeAxis;
		}
		public boolean isMovingXaxis() {
			return isMovingXaxis;
		}
		public void setMovingXaxis(boolean isMovingXaxis) {
			this.isMovingXaxis = isMovingXaxis;
		}
		public Color getColor() {
			return color;
		}
		public void setColor(Color color) {
			this.color = color;
		}
		public boolean isFirst_interaction() {
			return first_interaction;
		}
		public void setFirst_interaction(boolean first_interaction) {
			this.first_interaction = first_interaction;
		}
		public boolean isActive() {
			return active;
		}
		public void setActive(boolean active) {
			this.active = active;
		}
	}
 
 public UnitAnimation(String instructionBinary, int datapathType)
 {
	 datapatTypeUsed = datapathType; 
	 cursorInIM = false;
	 cursorInALU = false;
	 cursorInDataMem = false;
	 df = new DecimalFormat("0.0");  // 1 dp
	 GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
	 gd = ge.getDefaultScreenDevice();
	 gc = ge.getDefaultScreenDevice().getDefaultConfiguration();

	 accelMemory = gd.getAvailableAcceleratedMemory();  // in bytes
	 setBackground(Color.white);
	 setPreferredSize( new Dimension(PWIDTH, PHEIGHT) );

	 // load and initialise the images
	 initImages();
	  
	 vertexList = new ArrayList<Vertex>();
	 counter = 0;
	 justStarted = true;
	 instructionCode = instructionBinary;
	 
	 //declaration of labels definition.
	 registerEquivalenceTable = new  HashMap<String, String>();
	 
	 countRegLabel = 400;
	 countALULabel = 380;
	 countPCLabel = 380;
	 loadHashMapValues();
	 

 } // end of ImagesTests()

 //set the binnary opcode value of the basic instructions of MIPS instruction set
 public void loadHashMapValues(){
	 if(datapatTypeUsed == register){
		 importXmlStringData("/registerDatapath.xml", registerEquivalenceTable, "register_equivalence",  "bits", "mnemonic");
 	 	 importXmlDatapathMap("/registerDatapath.xml", "datapath_map");
	 }
	 else if(datapatTypeUsed == control){
		 importXmlStringData("/controlDatapath.xml", registerEquivalenceTable, "register_equivalence",  "bits", "mnemonic");
 	 	 importXmlDatapathMap("/controlDatapath.xml", "datapath_map");
	 }
	 
	 else if(datapatTypeUsed == aluControl){
		 importXmlStringData("/ALUcontrolDatapath.xml", registerEquivalenceTable, "register_equivalence",  "bits", "mnemonic");
 	 	 importXmlDatapathMapAluControl("/ALUcontrolDatapath.xml", "datapath_map");
	 }
 }
 
 //import the list of opcodes of mips set of instructions
 public void importXmlStringData(String xmlName, HashMap table, String elementTree, String tagId, String tagData){
	 	DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		dbf.setNamespaceAware(false);
		DocumentBuilder docBuilder;
		try {
			//System.out.println();
			docBuilder = dbf.newDocumentBuilder();
			Document doc = docBuilder.parse(getClass().getResource(xmlName).toString());
			Element root = doc.getDocumentElement();
			Element equivalenceItem;
			NodeList bitsList,  mnemonic;
			NodeList equivalenceList = root.getElementsByTagName(elementTree);
			for(int i = 0; i < equivalenceList.getLength(); i++){
				equivalenceItem =  (Element)equivalenceList.item(i);
				bitsList = equivalenceItem.getElementsByTagName(tagId);
				mnemonic = equivalenceItem.getElementsByTagName(tagData);
				for(int j= 0; j < bitsList.getLength(); j++){
					table.put(bitsList.item(j).getTextContent(),mnemonic.item(j).getTextContent());
				}
			}
		}
		 catch (Exception e) {
				e.printStackTrace();
			}
 }
 
 //import the parameters of the animation on datapath
 public void importXmlDatapathMap(String xmlName, String elementTree){
	 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		dbf.setNamespaceAware(false);
		DocumentBuilder docBuilder;
		try {
			docBuilder = dbf.newDocumentBuilder();
			Document doc = docBuilder.parse(getClass().getResource(xmlName).toString());
			Element root = doc.getDocumentElement();
			Element datapath_mapItem;
			NodeList index_vertex,  name, init, end,color, other_axis, isMovingXaxis, targetVertex, sourceVertex, isText ;
				NodeList datapath_mapList = root.getElementsByTagName(elementTree);
			for(int i = 0; i < datapath_mapList.getLength(); i++){ //extract the vertex of the xml input and encapsulate into the vertex object
				datapath_mapItem =  (Element)datapath_mapList.item(i);
				index_vertex = datapath_mapItem.getElementsByTagName("num_vertex");
				name = datapath_mapItem.getElementsByTagName("name");
				init = datapath_mapItem.getElementsByTagName("init");
				end = datapath_mapItem.getElementsByTagName("end");
				//definition of colors line 
			
				if(instructionCode.substring(0,6).equals("000000")){//R-type instructions
					color = datapath_mapItem.getElementsByTagName("color_Rtype"); 
					//System.out.println("rtype");
				}
				else if(instructionCode.substring(0,6).matches("00001[0-1]")){ //J-type instructions
					color = datapath_mapItem.getElementsByTagName("color_Jtype"); 
					//System.out.println("jtype");
				}
				else if(instructionCode.substring(0,6).matches("100[0-1][0-1][0-1]")){ //LOAD type instructions
					color = datapath_mapItem.getElementsByTagName("color_LOADtype");
					//System.out.println("load type");
				}
				else if(instructionCode.substring(0,6).matches("101[0-1][0-1][0-1]")){ //LOAD type instructions
					color = datapath_mapItem.getElementsByTagName("color_STOREtype");
					//System.out.println("store type");
				}
				else if(instructionCode.substring(0,6).matches("0001[0-1][0-1]")){ //BRANCH type instructions
					color = datapath_mapItem.getElementsByTagName("color_BRANCHtype");
					//System.out.println("branch type");
				}
				else{ //BRANCH type instructions
					color = datapath_mapItem.getElementsByTagName("color_Itype");
					//System.out.println("immediate type");
				}
				
				
				other_axis = datapath_mapItem.getElementsByTagName("other_axis");
				isMovingXaxis = datapath_mapItem.getElementsByTagName("isMovingXaxis");
				targetVertex = datapath_mapItem.getElementsByTagName("target_vertex");
				isText = datapath_mapItem.getElementsByTagName("is_text");
				
				for(int j= 0; j < index_vertex.getLength(); j++){
					Vertex vert = new Vertex(Integer.parseInt(index_vertex.item(j).getTextContent()), Integer.parseInt(init.item(j).getTextContent()),
							Integer.parseInt(end.item(j).getTextContent()), name.item(j).getTextContent(), Integer.parseInt(other_axis.item(j).getTextContent()),
							Boolean.parseBoolean(isMovingXaxis.item(j).getTextContent()), color.item(j).getTextContent(), targetVertex.item(j).getTextContent(), Boolean.parseBoolean(isText.item(j).getTextContent()));
					vertexList.add(vert);
				}
			}
			//loading matrix of control of vertex.
			outputGraph = new Vector<Vector<Vertex>>();
			vertexTraversed = new ArrayList<Vertex>();
			int size = vertexList.size();
			Vertex vertex;
			ArrayList<Integer> targetList;
			for(int i = 0; i < vertexList.size(); i++){
				vertex = vertexList.get(i);
				targetList = vertex.getTargetVertex();
				Vector<Vertex> vertexOfTargets = new Vector<Vertex>();
				for(int k = 0; k < targetList.size(); k++){
					vertexOfTargets.add(vertexList.get(targetList.get(k)));
				}
				outputGraph.add(vertexOfTargets); 	
			}
			for(int i=0; i< outputGraph.size(); i++){
				Vector<Vertex> vert = outputGraph.get(i);
			}
			
			vertexList.get(0).setActive(true);
			vertexTraversed.add(vertexList.get(0));
		}
		 catch (Exception e) {
				e.printStackTrace();
			}
		
 } 
  
 
 public void importXmlDatapathMapAluControl(String xmlName, String elementTree){
	 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		dbf.setNamespaceAware(false);
		DocumentBuilder docBuilder;
		try {
			docBuilder = dbf.newDocumentBuilder();
			Document doc = docBuilder.parse(getClass().getResource(xmlName).toString());
			Element root = doc.getDocumentElement();
			Element datapath_mapItem;
			NodeList index_vertex,  name, init, end,color, other_axis, isMovingXaxis, targetVertex, sourceVertex, isText ;
				NodeList datapath_mapList = root.getElementsByTagName(elementTree);
			for(int i = 0; i < datapath_mapList.getLength(); i++){ //extract the vertex of the xml input and encapsulate into the vertex object
				datapath_mapItem =  (Element)datapath_mapList.item(i);
				index_vertex = datapath_mapItem.getElementsByTagName("num_vertex");
				name = datapath_mapItem.getElementsByTagName("name");
				init = datapath_mapItem.getElementsByTagName("init");
				end = datapath_mapItem.getElementsByTagName("end");
				//definition of colors line 
			
				if(instructionCode.substring(0,6).equals("000000")){//R-type instructions 
					if(instructionCode.substring(28,32).matches("0000")){ //BRANCH type instructions
						color = datapath_mapItem.getElementsByTagName("ALU_out010");
						System.out.println("ALU_out010 type " + instructionCode.substring(28,32));
					}
					else if(instructionCode.substring(28,32).matches("0010")){ //BRANCH type instructions
						color = datapath_mapItem.getElementsByTagName("ALU_out110");
						System.out.println("ALU_out110 type " + instructionCode.substring(28,32));
					}
					else if(instructionCode.substring(28,32).matches("0100")){ //BRANCH type instructions
						color = datapath_mapItem.getElementsByTagName("ALU_out000");
						System.out.println("ALU_out000 type " + instructionCode.substring(28,32));
					}
					else if(instructionCode.substring(28,32).matches("0101")){ //BRANCH type instructions
						color = datapath_mapItem.getElementsByTagName("ALU_out001");
						System.out.println("ALU_out001 type " + instructionCode.substring(28,32));
					}
					else{ //BRANCH type instructions
						color = datapath_mapItem.getElementsByTagName("ALU_out111");
						System.out.println("ALU_out111 type " + instructionCode.substring(28,32));
					}
				}
				else if(instructionCode.substring(0,6).matches("00001[0-1]")){ //J-type instructions
					color = datapath_mapItem.getElementsByTagName("color_Jtype"); 
					System.out.println("jtype");
				}
				else if(instructionCode.substring(0,6).matches("100[0-1][0-1][0-1]")){ //LOAD type instructions
					color = datapath_mapItem.getElementsByTagName("color_LOADtype");
					System.out.println("load type");
				}
				else if(instructionCode.substring(0,6).matches("101[0-1][0-1][0-1]")){ //LOAD type instructions
					color = datapath_mapItem.getElementsByTagName("color_STOREtype");
					System.out.println("store type");
				}
				else if(instructionCode.substring(0,6).matches("0001[0-1][0-1]")){ //BRANCH type instructions
					color = datapath_mapItem.getElementsByTagName("color_BRANCHtype");
					System.out.println("branch type");
				}
				else{
					color = datapath_mapItem.getElementsByTagName("color_Itype");
					System.out.println("immediate type");
				}
				
				
				other_axis = datapath_mapItem.getElementsByTagName("other_axis");
				isMovingXaxis = datapath_mapItem.getElementsByTagName("isMovingXaxis");
				targetVertex = datapath_mapItem.getElementsByTagName("target_vertex");
				isText = datapath_mapItem.getElementsByTagName("is_text");
				
				for(int j= 0; j < index_vertex.getLength(); j++){
					Vertex vert = new Vertex(Integer.parseInt(index_vertex.item(j).getTextContent()), Integer.parseInt(init.item(j).getTextContent()),
							Integer.parseInt(end.item(j).getTextContent()), name.item(j).getTextContent(), Integer.parseInt(other_axis.item(j).getTextContent()),
							Boolean.parseBoolean(isMovingXaxis.item(j).getTextContent()), color.item(j).getTextContent(), targetVertex.item(j).getTextContent(), Boolean.parseBoolean(isText.item(j).getTextContent()));
					vertexList.add(vert);
				}
			}
			//loading matrix of control of vertex.
			outputGraph = new Vector<Vector<Vertex>>();
			vertexTraversed = new ArrayList<Vertex>();
			int size = vertexList.size();
			Vertex vertex;
			ArrayList<Integer> targetList;
			for(int i = 0; i < vertexList.size(); i++){
				vertex = vertexList.get(i);
				targetList = vertex.getTargetVertex();
				Vector<Vertex> vertexOfTargets = new Vector<Vertex>();
				for(int k = 0; k < targetList.size(); k++){
					vertexOfTargets.add(vertexList.get(targetList.get(k)));
				}
				outputGraph.add(vertexOfTargets); 	
			}
			for(int i=0; i< outputGraph.size(); i++){
				Vector<Vertex> vert = outputGraph.get(i);
			}
			
			vertexList.get(0).setActive(true);
			vertexTraversed.add(vertexList.get(0));
		}
		 catch (Exception e) {
				e.printStackTrace();
			}
		
 } 
 
//set the initial state of the variables that controls the animation, and start the timer that triggers the animation. 
 public void startAnimation(String codeInstruction){
 	 instructionCode = codeInstruction;	 	
 	new Timer(PERIOD, this).start();    // start timer
 	this.repaint();
 }
 
 //initialize the image of datapath.
 private void initImages(){
	 try {
		 BufferedImage im;
		 if(datapatTypeUsed == register){
			 im =  ImageIO.read( 
				 getClass().getResource(Globals.imagesPath+"register.png") );
		 }
		 else if(datapatTypeUsed == control){
			 im =  ImageIO.read( 
					 getClass().getResource(Globals.imagesPath+"control.png") );
			 }
		 else if(datapatTypeUsed == aluControl){
			 im =  ImageIO.read( 
				 getClass().getResource(Globals.imagesPath+"ALUcontrol.png") );
		 }
		 else{
			 im =  ImageIO.read( 
					 getClass().getResource(Globals.imagesPath+"alu.png") );
		 }
		 
		 int transparency = im.getColorModel().getTransparency();
		 datapath =  gc.createCompatibleImage(
				 im.getWidth(), im.getHeight(),
				 transparency );
		 g2d = datapath.createGraphics();
		 g2d.drawImage(im,0,0,null);
		 g2d.dispose();
	 } 
	 catch(IOException e) {
		 System.out.println("Load Image error for " +
				 getClass().getResource(Globals.imagesPath+"register.png") + ":\n" + e); 
	 }
 } 

	public void updateDisplay(){
   		this.repaint();
   	}
	
 public void actionPerformed(ActionEvent e)
 // triggered by the timer: update, repaint
 { 
	 if (justStarted)   
		 justStarted = false;
	 if(xIsMoving)
		 indexX++;
	 if(yIsMoving)
		 indexY--;
	 repaint(); 
 } 


 public void paintComponent(Graphics g)
 {
	 super.paintComponent(g);
	 g2d = (Graphics2D)g; 
	 // use antialiasing
	 g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
			 RenderingHints.VALUE_ANTIALIAS_ON);
	 // smoother (and slower) image transformations  (e.g. for resizing)
	 g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
			 RenderingHints.VALUE_INTERPOLATION_BILINEAR);
	 g2d = (Graphics2D)g;
	 drawImage(g2d, datapath, 0,0,null);
	 executeAnimation(g);
	 counter = (counter + 1)% 100;
	 g2d.dispose();
	 
 } 

 private void drawImage(Graphics2D g2d, BufferedImage im, int x, int y,Color c){ 
	 if (im == null) {
		 g2d.setColor(c);
		 g2d.fillOval(x, y, 20, 20);
		 g2d.setColor(Color.black);
		 g2d.drawString("   ", x, y);
	 }
	 else
		 g2d.drawImage(im, x, y, this);
 } 

//draw lines.
 //method to draw the lines that run from left to right.
 public void printTrackLtoR(Vertex v){
	 int size;
	 int[] track;
	 size = v.getEnd() - v.getInit();
	 track =  new int[size];
	 for(int i = 0; i < size; i++)
		 track[i] = v.getInit()+i;
	 if(v.isActive() == true){
		 	v.setFirst_interaction(false);
			for(int i = 0; i < size; i++){
				if(track[i] <= v.getCurrent()){
					g2d.setColor(v.getColor());  
					g2d.fillRect(track[i], v.getOppositeAxis(), 3, 3);
				}
			}	
			if (v.getCurrent() == track[size-1])
				v.setActive(false);
			v.setCurrent(v.getCurrent()+1);	
	 }
	  else if(v.isFirst_interaction() == false){
			 for(int i = 0; i < size ; i++){
				 g2d.setColor(v.getColor());  
				 g2d.fillRect(track[i],v.getOppositeAxis(),  3, 3);
			 }	
	 }
	
 }

 //method to draw the lines that run from right to left.
 //public boolean printTrackRtoL(int init, int end ,int currentIndex, Graphics2D g2d, Color color, int otherAxis, 
//		 boolean active, boolean firstInteraction){
public void printTrackRtoL(Vertex v){
	int size;
	int[] track;
	size = v.getInit() - v.getEnd();
	track =  new int[size];
	
	for(int i = 0; i < size; i++)
		track[i] = v.getInit()-i; 

	if(v.isActive() == true){
		v.setFirst_interaction(false);
		for(int i = 0; i < size; i++){
			if(track[i] >= v.getCurrent()){
				g2d.setColor(v.getColor());  
				g2d.fillRect(track[i], v.getOppositeAxis(), 3, 3);
			}
		}
		if (v.getCurrent() == track[size-1])
			v.setActive(false);
		
		v.setCurrent(v.getCurrent()-1);	
	 }
	 else if(v.isFirst_interaction() == false){
			for(int i = 0; i < size ; i++){
				g2d.setColor(v.getColor());  
				g2d.fillRect(track[i],v.getOppositeAxis(),  3, 3);
			 }
	 }
 }

 //method to draw the lines that run from down to top.
// public boolean printTrackDtoU(int init, int end ,int currentIndex, Graphics2D g2d, Color color, int otherAxis, 
//		 boolean active, boolean firstInteraction){
 public void printTrackDtoU(Vertex v){	 
	 int size;
	 int[] track;

	 if(v.getInit() > v.getEnd()){
		 size = v.getInit() - v.getEnd();
		 track =  new int[size];
		 for(int i = 0; i < size; i++)
			 track[i] = v.getInit()-i;
	 }
	 else{
		 size = v.getEnd() - v.getInit();
		 track =  new int[size];
		 for(int i = 0; i < size; i++)
			 track[i] = v.getInit()+i;
	 }

	if(v.isActive() == true){
		 v.setFirst_interaction(false);
		 for(int i = 0; i < size; i++){
			 if(track[i] >= v.getCurrent()){
				 g2d.setColor(v.getColor());  
				 g2d.fillRect(v.getOppositeAxis(), track[i], 3, 3);	
			 }
		 }
		 if (v.getCurrent() == track[size-1])
			 v.setActive(false);
		 v.setCurrent(v.getCurrent()-1);	

	 }
	  else if(v.isFirst_interaction() == false){
			 for(int i = 0; i < size; i++){
				 g2d.setColor(v.getColor());  
				 g2d.fillRect(v.getOppositeAxis(), track[i], 3, 3);
			 }
	 }
 }
 //method to draw the lines that run from top to down.
// public boolean printTrackUtoD(int init, int end ,int currentIndex, Graphics2D g2d, Color color, int otherAxis, 
//		 boolean active,  boolean firstInteraction){
 public void printTrackUtoD(Vertex v){
	 	 
	 int size;
	 int[] track;
	 size = v.getEnd() - v.getInit();
	 track =  new int[size];
	 
	 for(int i = 0; i < size; i++)
		 track[i] = v.getInit()+i;

	 if(v.isActive() == true){
		 v.setFirst_interaction(false);
		 for(int i = 0; i < size; i++){
			 if(track[i] <= v.getCurrent()){
				 g2d.setColor(v.getColor());  
				 g2d.fillRect(v.getOppositeAxis(), track[i], 3, 3);	
			 }
			 	
		 }
		 if (v.getCurrent() == track[size-1]) 
			 v.setActive(false);
		 v.setCurrent(v.getCurrent()+1);
	 }
	  else if(v.isFirst_interaction() == false){
			 for(int i = 0; i < size; i++){
				 g2d.setColor(v.getColor());  
				 g2d.fillRect(v.getOppositeAxis(), track[i], 3, 3);
			 }
	 }
 }


 //convert binnary value to integer.
 public String parseBinToInt(String code){
	 int value = 0;

	 for(int i =code.length()-1; i >= 0; i--){
		 if("1".equals(code.substring(i,i+1))){
			 value = value + (int)Math.pow(2,code.length()-i-1);
		 }
	 }
	 
	 return Integer.toString(value);
 }
 
 //set and execute the information about the current position of each line of information in the animation,
 //verifies the previous status of the animation and increment the position of each line that interconnect the unit function.
 private void executeAnimation(Graphics g){
	 g2d = (Graphics2D)g; 
	 Vertex vert;
	 for(int i = 0; i < vertexTraversed.size(); i++){
		 vert = vertexTraversed.get(i);
		 if(vert.isMovingXaxis == true){
			 if(vert.getDirection() == vert.movingLeft){
				 printTrackLtoR(vert);
				 if(vert.isActive() == false){
					 int j = vert.getTargetVertex().size();
					 Vertex tempVertex;
					 for(int k = 0; k < j; k++){
						 tempVertex = outputGraph.get(vert.getNumIndex()).get(k);
						 Boolean hasThisVertex = false;
						 for(int m = 0 ; m < vertexTraversed.size(); m++){
							 if(tempVertex.getNumIndex() == vertexTraversed.get(m).getNumIndex())
								 hasThisVertex = true;
						 }
						 if(hasThisVertex == false){
							 outputGraph.get(vert.getNumIndex()).get(k).setActive(true);
							 vertexTraversed.add( outputGraph.get(vert.getNumIndex()).get(k));
						 } 
					 }
				 }					 
			 }
			 else{
				 printTrackRtoL(vert);
				 if(vert.isActive() == false){
					 int j = vert.getTargetVertex().size();
					 Vertex tempVertex;
					 for(int k = 0; k < j; k++){
						 tempVertex = outputGraph.get(vert.getNumIndex()).get(k);
						 Boolean hasThisVertex = false;
						 for(int m = 0 ; m < vertexTraversed.size(); m++){
							 if(tempVertex.getNumIndex() == vertexTraversed.get(m).getNumIndex())
								 hasThisVertex = true;
						 }
						 if(hasThisVertex == false){
							 outputGraph.get(vert.getNumIndex()).get(k).setActive(true);
							 vertexTraversed.add( outputGraph.get(vert.getNumIndex()).get(k));
						 } 
					 }
				 }
			 }
		 } //end of condition of X axis
		 else{
			 if(vert.getDirection() == vert.movingDownside){
				 if(vert.isText == true)
					 ;
				 else
					 printTrackDtoU(vert);
					
					 if(vert.isActive() == false){
						 int j = vert.getTargetVertex().size();
						 Vertex tempVertex;
						 for(int k = 0; k < j; k++){
							 tempVertex = outputGraph.get(vert.getNumIndex()).get(k);
							 Boolean hasThisVertex = false;
							 for(int m = 0 ; m < vertexTraversed.size(); m++){
								 if(tempVertex.getNumIndex() == vertexTraversed.get(m).getNumIndex())
									 hasThisVertex = true;
							 }
							 if(hasThisVertex == false){
								 outputGraph.get(vert.getNumIndex()).get(k).setActive(true);
								 vertexTraversed.add( outputGraph.get(vert.getNumIndex()).get(k));
							 } 
						 }
					 }
				 
			 }
			 else{
				 printTrackUtoD(vert);
				 if(vert.isActive() == false){
					 int j = vert.getTargetVertex().size();
					 Vertex tempVertex;
					 for(int k = 0; k < j; k++){
						 tempVertex = outputGraph.get(vert.getNumIndex()).get(k);
						 Boolean hasThisVertex = false;
						 for(int m = 0 ; m < vertexTraversed.size(); m++){
							 if(tempVertex.getNumIndex() == vertexTraversed.get(m).getNumIndex())
								 hasThisVertex = true;
						 }
						 if(hasThisVertex == false){
							 outputGraph.get(vert.getNumIndex()).get(k).setActive(true);
							 vertexTraversed.add( outputGraph.get(vert.getNumIndex()).get(k));
						 } 
					 }
				 }
			 }
		 }
	 }
 }

}