/*
Research Project:   Graphical Database for Category Theory
                    J. Bradbury, Dr. R. Rosebrugh, I. Rutherford
                    Mount Allison University 2001
File:               EqualityComposites.java
Description:        This class implements a frame that tests paths in a given
                    category for equality.
*/

//import statements
import java.awt.*;
import java.awt.event.*;

public class EqualityComposites extends Frame {

  IniSettings ini = new IniSettings();
  
  Category cat = new Category();
  CategoryList l = new CategoryList();
  int check_enter = 0;

  //Objects in the Graphical User Interface(GUI)
  Button exit = new Button();
  Panel button_panel = new Panel();
  BorderLayout borderLayout1 = new BorderLayout();
  Button equalityButton = new Button();
  Button okButton = new Button();
  Label label2 = new Label();
  Label label1 = new Label();
  TextField path1Field = new TextField();
  TextField categoryName = new TextField();
  MainWindow edit;
  Label label3 = new Label();
  TextField path2Field = new TextField();
  Label label4 = new Label();
  TextArea resultArea  = new TextArea("", 10, 10, TextArea.SCROLLBARS_VERTICAL_ONLY);
  int p1[] = new int[ini.getMAXWORD()];
  int p2[] = new int[ini.getMAXWORD()];
  int redp1[] = new int[ini.getMAXWORD()];
  int redp2[] = new int[ini.getMAXWORD()];
  String path1 = new String();
  String path2 = new String();
  Label label5 = new Label();
  GridBagLayout gridBagLayout1 = new GridBagLayout();
  GBConstraintsEditor g = new GBConstraintsEditor();

  public EqualityComposites(CategoryList ltemp, MainWindow ed)
  //Default Constructor with the list of categories as a parameter
  {
    l = ltemp;
    edit = ed;
    edit.enableMenus(false);
    try  {
      jbInit();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }

  public boolean handleEvent(Event e)
  {
    if ((e.id == Event.WINDOW_DESTROY) || (e.id == Event.ACTION_EVENT))
    {
      edit.enableMenus(true);
      hide();            //hide frame
      dispose();         //free resources
      return true;
    }
    else if (e.key == Event.ENTER)
    {
      if (check_enter == 0)
       check_enter++;
      else
      {
        edit.enableMenus(true);
        hide();            //hide frame
        dispose();         //free resources
      }
      return true;
    }
    return super.handleEvent(e);
  }

 public boolean action(Event e, Object o)
 {
  if ((e.target == exit) || (e.key == Event.ENTER))
  {
    edit.enableMenus(true);
    hide();            //hide frame
    dispose();         //free resources
    return true;
  }
  return false;
 }


 private void jbInit() throws Exception
 //This function intializes the GUI
 {
    this.setTitle("GDCT: Equality of Composites");
    this.setBackground(new Color(192,192,192));
    equalityButton.setLabel("Equality ?");
    equalityButton.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
        equalityButton_actionPerformed(e);
      }
    });
    okButton.setLabel("Close");
    label2.setText("Category Name:");
    label1.setText("First Path:");
    this.setLayout(gridBagLayout1);
    resultArea.setBackground(Color.white);
    categoryName.setBackground(Color.white);
    this.add(equalityButton, g.getConstraints(4, 3, 1, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(9, 0, 0, 0), 78, 8));
    this.add(okButton, g.getConstraints(4, 4, 1, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(6, 0, 5, 0), 114, 8));
    this.add(label2, g.getConstraints(0, 0, 4, 1, 0.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(9, 10, 0, 0), -8, 0));
    this.add(label1, g.getConstraints(0, 1, 2, 1, 0.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(10, 10, 0, 0), 0, 0));
    this.add(categoryName, g.getConstraints(4, 0, 1, 1, 1.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(9, 6, 0, 0), 121, 0));
    this.add(path1Field, g.getConstraints(4, 1, 1, 1, 1.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(7, 6, 0, 0), 121, 1));
    this.add(label3, g.getConstraints(0, 2, 3, 1, 0.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(11, 10, 0, 0), 0, 0));
    this.add(path2Field, g.getConstraints(4, 2, 1, 1, 1.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(9, 8, 0, 0), 122, 0));
    this.add(label4, g.getConstraints(5, 0, 1, 1, 0.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(9, 28, 0, 0), -8, -2));
    this.add(resultArea, g.getConstraints(5, 1, 2, 4, 1.0, 1.0
            ,GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0, 29, 8, 6), 141, -27));
    this.add(label5, g.getConstraints(0, 3, 1, 1, 0.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(14, 10, 0, 0), 0, 0));
    CategoryNode current = l.head;
    categoryName.setEditable(false);
    categoryName.setText(edit.categoryChoice.getSelectedItem());
    String name = edit.categoryChoice.getSelectedItem();
    cat = l.getNode(name);
    label5.setText("Controls:");
    path2Field.setBackground(Color.white);
    path1Field.setBackground(Color.white);
    label4.setText("Results:");
    label3.setText("Second Path:");
    resultArea.setEditable(false);
  }

  void equalityButton_actionPerformed(ActionEvent e)
  //Function called when OK button is pressed.
  {
    equality_test();
  }

  void equality_test()
  //This function determines if the two paths specified by the user
  //are equal or not equal.
  {
    boolean success = false;

    //If paths p1 and p2 are valid paths
    if (ask_for_paths())
    {
      //Reduce both paths
  	  redp1 = reduce(redp1, p1, cat);
	    redp2 = reduce(redp2, p2, cat);

      //If the two reduced paths are equals
  	  if ((equals(redp1, redp2)) )//&& ((cat.arr[p1[0]][1] == cat.arr[p2[0]][1]) || (p1[0] == -1) || (p2[0] == -1)))
		  {
		    resultArea.append(path1 + " and " + path2 + " are equal.\n");
      }
	    else
		  {
		    resultArea.append(path1 + " and " + path2 + " are NOT equal.\n");
      }
    }
  }

  boolean ask_for_paths()
  //This method reads in the two paths from path1Field and path2Field that
  //have been entered by the user and converts them to arrays of integers
  //terminated by -1 and then stores them in p1 and p2.
  {
    String first = new String();  //path 1 string
    String second = new String(); //path 2 string

    //Intitialize paths to -3 which means invalid
    p1[0] = p2[0] = -3;

    //Get First Path
    path1 = first = path1Field.getText();
    path1Field.setText("");

    //Check First Path for Valid Arrows
    if (check_string(first, cat))
    {
      //Convert path string to path of integers
      p1 = string_to_path(first, cat);

      //Check path for valid domains and codomains
	    if (!check_path(p1,cat))
		  {
		    p1[0] = -3;
		    return(false);
		  }

      //Get Second Path
      path2 = second = path2Field.getText();
      path2Field.setText("");

      //Check Second Path for Valid Arrows
      if (check_string(second, cat))
      {
	      //Convert path string to path of integers
        p2 = string_to_path(second, cat);

        //copy_path(p2, string_to_path(second, A));
    	  //Check path for valid domains and codomains
	      if (!check_path(p2,cat))
  		  {
	      	p2[0] = -3;
		      return(false);
		    }
      }
    }
    if ((p1[0] == -3) || (p2[0] == -3))
      return(false);
    return(true);
  }

  public int[] copy_path(int dest[], int source[])
  /*
  Parameters:
        dest:   an array of integers which will be set to equal source
        source: an array of integers which is copied into dest
  Purpose:
         To copy one array of integers to another array of integers
  Design:
        Copies source into dest
  */
  {
    int i;
    int temp[] = new int [ini.getMAXWORD()];

    for(i=0;i<=path_len(source);i++)
    {
      temp[i] = source[i];
    }
    return(temp);
  }

  public String path_to_string(int path[], Category A)
  /*
  Parameters:
        path:   the path to be converted to a string(function does not change
                path)
        A:      a category that contains the arrows of the path
  Purpose:
        To convert an array of integers, which represent arrows, terminated by -1
        into a path which is a string of characters which are arrows and the string
        is terminated by \0.
  Design:
        Returns a string which is the path represented by the integers in the
        integer array
  */
  {
    int i;
    String temp = new String();

    //If path is an identity arrow return "1"
    if (path_len(path) == 0)
    {
      return("1");
    }
    else
    {
      for(i=0;i<path_len(path);i++)
      {
        //If current arrow is not the last
        //append a * after it
        if (i < path_len(path)-1)
  		    temp = temp + A.arrow[path[i]] + "*";
        else
  		    temp = temp + A.arrow[path[i]];
      }
      //temp = temp + '\0';
      return(temp);
    }
  }

 int[] string_to_path(String st, Category c)
 /*
 Parameters:
        st:     the string that we want to convert to an array of integers terminated
                by -1
        A:      a category that contains the arrows of the string
 Purpose:
        To convert a string of characters, where the characters represent arrows, into
        an array of integers, terminated by -1, where the integers represent arrows.
 Design:
        Returns an array of integers terminated by -1, and does not change the st.
 */
 {
  int i;
  int temp[] = new int [ini.getMAXWORD()];

  //If the string does not contain anything,
  //initialize temp[0] = -1 and return it
  if(st.length() == 0)
  {
    temp[0] = -1;
    return(temp);
  }

  //If the string consists of an identity arrow
  // return path = -2
  else if ((st.length() == 1) &&  (st.charAt(0) == '1'))
  {
    temp[0] = -2;
    return(temp);
  }

  //Otherwise...
  else
  {
    String[] arr = new String[ini.getMAXARR()];
    int arrnum = 0;
    int prev = 0;

    //Parse out arrows in string
    for(i=0;i<st.length();i++)
    {
      if ((st.charAt(i) == '*'))
      {
        arr[arrnum] =  st.substring(prev, i);
        temp[arrnum]= arrow_number(arr[arrnum], c);
        prev = i+1;
        arrnum++;
      }
      else if (i == (st.length()-1))
      {
        arr[arrnum] =  st.substring(prev, i+1);
        temp[arrnum]= arrow_number(arr[arrnum], c);
        prev = i+1;
        arrnum++;
      }
    }
    temp[arrnum] = -1;

    i=0;
    while (temp[i] != -1)
    {
        i++;
    }
    return(temp);
  }
 }

  public int path_len(int path[])
  /*
  Parameters:
        path:   an array of integers terminated by -1 which is a path
  Purpose:
        To determine the length of an array of integers terminated by -1
  Design:
        Returns the number of integers in the path, does not count -1
  */
  {
    //length of path
    int length = 0;

    //If identity arrow return
    //length of 0
    if (path[0] == -2)
      return(0);
    //Otherwise determine the length
    //of the path of arrows
    else
    {
      while (path[length] != -1)
      {
        length++;
      }
      return(length);
    }
  }

  public int[] reduce(int reducedpath[], int path[], Category c)
  /*
  Parameters:
        reducedpath:    an array of integers which will be set to equal the
                        reduced path
        path:           the array of integers being reduced
        A:              a category
  Purpose:
        To reduce a path using the set of relations stored in a category
  Design:
        Reduces path and stores its reduced form in reducedpath
  */
  {
    int i,j;
    //the spot where the left side of a relation
    //begins in the path being reduced
    int spot;
    //a temporary variable used to store the length of a path
    int temp;
    //the difference in length between the left side of a relation and the
    //right side of the relation
    int diff;

    //Copy the path being reduced into reducedpath
    reducedpath = copy_path(reducedpath,path);
    //For all of the relations in the category...
    for (i=0;i<c.num_rel;i++)
    {
      //if lhs of relation is a subpath of reducedpath...
      if((spot = search(c.rel_set[i].lhs,reducedpath,0)) != -1)
      {
        //Starting at the spot where lhs of relation is in reducedpath,
        //copy the rhs of relation into the reduced path
        //NOTE-This makes sense since lhs > rhs is always true
        for (j=spot;j<spot+path_len(c.rel_set[i].rhs);j++)
        {
          reducedpath[j] = c.rel_set[i].rhs[j - spot];
        }
        //viewbox.appendText("reducedpath[i] = " + reducedpath[i]  + "\n");

        //Assign path length of reducedpath to integere temp
        temp = path_len(reducedpath);
        //Determine the difference between the lhs and the rhs
        //of the current relation
        diff = path_len(c.rel_set[i].lhs) - path_len(c.rel_set[i].rhs);
        //Move all arrows in reduced path that are located above subpath that
        //was relpaced down in the array by the value diff
        for (j=spot+path_len(c.rel_set[i].lhs);j<temp;j++)
        {
          reducedpath[j - diff] = reducedpath[j];
        }
        //Append a -1 to the end of the new reducedpath
        reducedpath[j - diff] = -1;
        i = -1;
      }
    }
    return(reducedpath);
  }

  public boolean equals(int path1[], int path2[])
  /*
  Parameters:
        path1:  an array of integers terminated by -1 which is a path
        path2:  an array of integers terminated by -1 which is a path
  Purpose:
        To determine if two paths are identical
  Design:
        Returns true if path1 is identical to path2 and false otherwise
                note:this function does not reduce them at all
  */
  {
    int i;

    if((path_len(path1)) == (path_len(path2)))
    {
      for(i=0;i<path_len(path1);i++)
      {
        if(path1[i] != path2[i])
        {
          return(false);
        }
      }
      return(true);
    }
    else
    {
      return(false);
    }
  }

   public boolean check_string(String str, Category c)
  //This function is designed to verify that all arrows in str are
  //valid arrows of the category c. For each arrow of the string checks
  //that it exists in the category c. Returns true if this is the case
  //and false otherwise. The parameter str is the string to check and the
  //parameter c is the current category
  {
    int i;
    String[] arr = new String[ini.getMAXARR()];
    int arrnum = 0;
    int prev = 0;

    //If string is empty return false
    if (str.length() == 0)
      return(false);

    //If string is identity arrow return true
    if ((str.length() == 1) && (str.charAt(0) == '1'))
      return(true);

    //For all characters in string...
    for (i=0;i<str.length();i++)
    {
      //If character equals seperator character
      //then parse our arrow before seperator
      if ((str.charAt(i) == '*'))
      {
        arr[arrnum] =  str.substring(prev, i);
        if (check_arr(arr[arrnum], c))
        {
          new MessageDialog(this, "Error", str + " is not an arrow of " + c.name, true);
          return(false);
        }
        prev = i+1;
        arrnum++;
      }
      //Parse out last arrow in string (this is a separate
      //case because there is not a seperator character following
      //the last arrow)
      else if (i == (str.length()-1))
      {
        arr[arrnum] =  str.substring(prev, i+1);
        if (check_arr(arr[arrnum], c))
        {
          new MessageDialog(this, "Error", str + " is not an arrow of " + c.name, true);
          return(false);
        }
        prev = i+1;
        arrnum++;
      }
    }
    //Return true if all arrows are in category
    return(true);
  }

    boolean check_path(int path[], Category A)
  //Checks that all the domains and codomains of the arrows in
  //the path match up and returns true if this is the case and false
  //otherwise
  {
    int i,arr,nextarr;

    //For all arrows in the path
	  for (i=0;i<(path_len(path)-1);i++)
	  {
      //Set arr to be current arrow in path
		  arr = path[i];
      //Set nextarr to be next arrow in path
		  nextarr = path[i+1];
      //Check that domain of current arrow and codomain of next arrow match
      //NOTE: Arrows in path are stored in reverse order so next arrow is
      //actually previous arrow
		  if ((A.arr[arr][0]) != (A.arr[nextarr][1]))
      {
   		  new MessageDialog(this, "Error", "Invalid Composition. Domain of " + A.arrow[arr] + " does not equal Codomain of " + A.arrow[nextarr], true);
			  return(false);
      }
		}
	  return(true);
  }

  public boolean check_arr(String arr, Category c)
 /*
 Parameters:
        arr:    the name of the arrow being checked
        A  :    the category
 Purpose:
        To determine whether an arrow is in the category
 Design:
        Returns false if the arrow is in the category and true if it is not
 */
 {
  int i;
  String temp = new String();

  //For all of the arrows in the current category...
  for(i=0;i< c.numarr;i++)
  {
    //If the arrow is in the category return
    //false
    if(arr.equals(c.arrow[i]))
    {
      return(false);
    }
  }
  //If the arrow is not in the category return true
  return(true);
 }



  public int arrow_number(String name, Category c)
  /*Parameters:
          name:     The name of the arrow that we want
                    the integer value of
          A:        the category that contains the arrow
    Purpose:
          To get the integer representation for the integer
          representation for an arrow.
  */
  {
    int i;

    //For all arrows in the current category...
    for(i=0;i < c.numarr;i++)
    {
      //If the current arrow equals the arrow
      //being search for, return its index
      if(c.arrow[i].equals(name))
      {
        return(i);
      }
    }
    //Otherwise return -1 to indicate that
    //the arrow was not found in the current category
    return(-1);
 }

  public int search(int sub[], int target[], int start)
  /*
  Parameters:
        sub:    an array of integers which is the subpath we are looking for
        target: an array of integers which is being searched for sub
        start:  The place in target where the search is to begin
  Purpose:
        To search one path, begining at some starting position, to see if another
        path is a subpath
  Design:
        Returns the position where the subpath begins in the path being searched,
         and -1 if sub is not a subpath of target
  */
  {
    int i,j;
    boolean found;  //Boolean variable to show if the subpath has been found

    //Initialize found to false
    found = false;
    //Search for subpath in target starting at start
    for (i=start;i<path_len(target);i++)
    {
      if (sub[0] == target[i])
      {
        found = true;
        for (j=0;j<path_len(sub);j++)
        {
          if (target[i+j] != sub[j])
          {
            found = false;
          }
        }
      }
      if (found)
      {
        break;
      }
    }
    //If the subpath is found, return the position
    //at which it starts in target
    if (found)
    {
      return(i);
    }
    //If the subpath is not found return -1
    else
    {
      return(-1);
    }
  }
}