/*
Research Project:   Graphical Database for Category Theory
                    J. Bradbury, Dr. R. Rosebrugh, I. Rutherford
                    Mount Allison University 2001
File:               IsoFrame.java
Description:        This class implements a frame which allows the user to run
                    the category tool "Isomorphism" on the current category.
*/

import java.awt.*;
import java.awt.event.*;
import borland.jbcl.layout.*;
import borland.jbcl.control.*;

public class IsoFrame extends Frame
{
  Panel panel1 = new Panel();
  XYLayout xYLayout1 = new XYLayout();
  Button iso = new Button();
  Button close = new Button();
  TextArea viewbox = new TextArea("", 10, 10, TextArea.SCROLLBARS_VERTICAL_ONLY);
  Choice choice1 = new Choice();
  Choice choice2 = new Choice();
  MainWindow ed;
  CheckboxControl checkbox1 = new CheckboxControl();
  CheckboxControl checkbox2 = new CheckboxControl();
  TextField path2 = new TextField();
  TextField path1 = new TextField();
  int maxpaths = 50;
  boolean includeid = true, endopassed = false;

  public IsoFrame(MainWindow edit)
  {
    ed = edit;
    edit.enableMenus(false);
    try
    {
      jbInit();
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
    add(panel1);
    pack();
  }

  private void jbInit() throws Exception
  {
    this.setTitle("GDCT: Isomorphism");
    this.setBackground(new Color(192,192,192));
    xYLayout1.setWidth(403);
    xYLayout1.setHeight(187);
    iso.setLabel("Iso?");
    close.setLabel("Close");
    checkbox1.setLabel("Specify first path");
    checkbox1.addItemListener(new java.awt.event.ItemListener()
    {
      public void itemStateChanged(ItemEvent e)
      {
        checkbox1_itemStateChanged(e);
      }
    });
    checkbox2.setLabel("Specify second path");
    checkbox2.addItemListener(new java.awt.event.ItemListener()
    {
      public void itemStateChanged(ItemEvent e)
      {
        checkbox2_itemStateChanged(e);
      }
    });
    //this.addWindowListener(new IsoFrame_this_windowAdapter(this));
    panel1.setLayout(xYLayout1);
    panel1.add(iso, new XYConstraints(7, 152, 66, 25));
    panel1.add(close, new XYConstraints(81, 152, 61, 25));
    panel1.add(viewbox, new XYConstraints(152, 9, 242, 169));
    panel1.add(choice1, new XYConstraints(7, 65, 134, -1));
    panel1.add(choice2, new XYConstraints(7, 104, 135, -1));
    panel1.add(checkbox1, new XYConstraints(8, 9, 132, 20));
    panel1.add(checkbox2, new XYConstraints(8, 32, 131, 18));
    panel1.add(path1, new XYConstraints(7, 65, 134, 21));
    panel1.add(path2, new XYConstraints(7, 104, 134, 21));
    viewbox.setEditable(false);
    viewbox.setBackground(Color.white);

    iso.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
        iso_actionPerformed(e);
      }
    });
    close.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
        close_actionPerformed(e);
      }
    });

    choice1.addItem("Check all objects");
    choice2.addItem("Check all objects");
    for (int i=0; i<ed.cat.numobj; i++)
    {
      choice1.addItem(ed.cat.obj[i]);
      choice2.addItem(ed.cat.obj[i]);
    }
    choice1.select(0);
    choice2.select(0);
    checkbox2.setEnabled(false);
  }

  public boolean handleEvent(Event e)
  {
    if (e.id == Event.WINDOW_DESTROY || e.key == Event.ENTER)
    {
      ed.enableMenus(true);
      hide();            //hide frame
      dispose();         //free resources
      return true;
    }

    return super.handleEvent(e);
  }

  // OK
  public void iso_actionPerformed(ActionEvent e)
  {
  /*
    Action listenener which is called when the "Iso" button is pressed
    Sets up some variables and calls is_iso to check for isomorphisms
  */
    endopassed = false;
    includeid = true;

    // checkzero() is called when the user specifies both paths.
    // checkone() is called when the user specifies one path
    // checkboth() is called when the user specifies neither path
    if (checkbox1.isChecked() && checkbox2.isChecked())
    {
      checkzero();
    }
    else if (checkbox1.isChecked() && !checkbox2.isChecked())
    {
      checkone();
    }
    else
    {
      checkboth();
    }
    if (endopassed)
    {
      viewbox.append("WARNING: Endomorphism limit was passed! Results may be inaccurate!\n\n");
    }
  }

  public void checkzero()
  {
  	// both paths are specified, so this function simply has to
  	// verify both paths, make sure they have matching domains and
  	// codomains, then check if they're inverses
    int p1[], p2[];
    String str1 = path1.getText();
    String str2 = path2.getText();
    if (!ed.cat.check_string(str1))
    {
      viewbox.append("Invalid first path.\n\n");
      return;
    }
    if (!ed.cat.check_string(str2))
    {
      viewbox.append("Invalid second path.\n\n");
      return;
    }
    p1 = ed.cat.string_to_path(str1);
    p2 = ed.cat.string_to_path(str2);
    if (ed.cat.path_len(p1) == 0)
    {
      viewbox.append("Invalid first path.\n\n");
      return;
    }
    if (ed.cat.path_len(p2) == 0)
    {
      viewbox.append("Invalid second path.\n\n");
      return;
    }
    if (ed.cat.arr[p1[0]][1] != ed.cat.arr[p2[ed.cat.path_len(p2)-1]][0])
    {
      viewbox.append("The codomain of first path must equal the domain of the second path.\n\n");
      return;
    }
    if (ed.cat.arr[p2[0]][1] != ed.cat.arr[p1[ed.cat.path_len(p1)-1]][0])
    {
      viewbox.append("The domain of first path must equal the codomain of the second path.\n\n");
      return;
    }
    
    // check if the two paths are mutually inverse
    if (ed.cat.path_len(ed.cat.reduce(ed.cat.append_path(p1, p2))) == 0 &&
        ed.cat.path_len(ed.cat.reduce(ed.cat.append_path(p2, p1))) == 0)
    {
      viewbox.append(str1 + " and " + str2 + " are mutually inverse!\n\n");
    }
    else
    {
      viewbox.append(str1 + " and " + str2 + " are not mutually inverse.\n\n");
    }
  }

  public void checkone()
  {
    int i;
    int path[];
    int temp[] = new int[ed.ini.getMAXWORD()];
    int obj1, obj2, numisos = 0, numpaths;
    HomTree paths = new HomTree();
    HomTree tree = new HomTree();
    String str = path1.getText();

    if (!ed.cat.check_string(str))
    {
      viewbox.append("Invalid path.\n");
      return;
    }
    path = ed.cat.string_to_path(str);
    if (ed.cat.path_len(path) == 0)
    {
      viewbox.append("Invalid path.\n\n");
      return;
    }
    obj1 = ed.cat.arr[path[0]][1];
    obj2 = ed.cat.arr[path[ed.cat.path_len(path)-1]][0];
    temp[0] = -1;

    // get all paths from obj1 to obj2 and then check them all
    numpaths = get_all_paths(temp, paths, obj1, obj2, ed.ini.getMaxLoop(), 0, tree);

    // go through each path and see if it is an inverse
    temp = paths.getFirstPath();
    for (i=0; i<numpaths; i++)
    {
      // if temp is an inverse to path, then their two compositions (one
      // with temp first and one with path first) will be identity arrows
      if (ed.cat.path_len(ed.cat.reduce(ed.cat.append_path(path, temp))) == 0 &&
          ed.cat.path_len(ed.cat.reduce(ed.cat.append_path(temp, path))) == 0)
      {
        viewbox.append(str + " has inverse " + ed.cat.path_to_string(temp) + ".\n\n");
        numisos++;
      }
      temp = paths.getNextPath();
    }
    if (numisos == 0)
      viewbox.append(str + " has no inverse.\n\n");
  }

  public void checkboth()
  {
    int i, j, numisos = 0;
    HomTree paths = new HomTree();
    HomTree inversepaths = new HomTree();
    String str1 = choice1.getSelectedItem();
    String str2 = choice2.getSelectedItem();
    String str3;

    // if the second choice is to check all objects, then switch the two strings
    if (str2.equals("Check all objects"))
    {
      str3 = str1;
      str1 = str2;
      str2 = str3;
    }

    if (str1.equals("Check all objects"))
    {
      if (str2.equals("Check all objects"))
      {
        includeid = false;
        // do a double loop to check all objects in the category against all others
        for (i=0; i<ed.cat.numobj; i++)
        {
          for (j=i; j<ed.cat.numobj; j++)
          {
            paths = new HomTree();
            inversepaths = new HomTree();
            numisos += is_iso(i, j, paths, inversepaths);
          }
        }
        if (numisos == 0)
          viewbox.append("There are no nontrivial isomorphisms in this category.\n\n");
        else
          viewbox.append(Integer.toString(numisos) + " pairs of mutually inverse paths found.\n\n");
      }
      else
      {
        // loop through each object to see if it is isomorphic to object str2
        includeid = false;
        j = ed.cat.object_number(str2);
        for (i=0; i<ed.cat.numobj; i++)
        {
          paths = new HomTree();
          inversepaths = new HomTree();
          numisos += is_iso(i, j, paths, inversepaths);
        }
        if (numisos == 0)
          viewbox.append("There are no objects isomorphic to " + str2 + ".\n\n");
        else
          viewbox.append(Integer.toString(numisos) + " pairs of mutually inverse paths found.\n\n");
      }
    }
    else
    {
      // check if objects str1 and str2 are isomorphic
      i = ed.cat.object_number(str1);
      j = ed.cat.object_number(str2);
      numisos = is_iso(i, j, paths, inversepaths);
      if (numisos == 0)
        viewbox.append("Objects " + str1 + " and " + str2 + " are not isomorphic.\n\n");
      else
        viewbox.append(Integer.toString(numisos) + " isomorphisms found.\n\n");
    }
  }

  public int is_iso(int obj1, int obj2, HomTree paths, HomTree inversepaths)
  /*
    Parameters:
      obj1, obj2   - the objects to be checked for an isomorphism
      paths        - an array which will store all paths from obj1 to obj2
      inversepaths - an array that will store all paths from obj2 to obj1
      maxpaths     - the max number of paths to be stored
    Purpose:
      Checks for an isomorphism between two objects
    Design:
      Returns true is an isomorphism is found, and prints a message to the user
      Otherwise, returns false and prints nothing
  */
  {
    int i, j;
    int numpaths1, numpaths2;
    int path[] = new int[ed.ini.getMAXWORD()];
    int objects[] = new int[ed.cat.numobj];
    int p1[] = new int[ed.ini.getMAXWORD()];
    int p2[] = new int[ed.ini.getMAXWORD()];
    HomTree tree = new HomTree();

    // get all paths from obj1 to obj2, and then from obj2 to obj1
    path[0] = -1;
    for (i=0; i<ed.cat.numobj; i++)
      objects[i] = 0;
    numpaths1 = get_all_paths(path, paths, obj1, obj2, ed.ini.getMaxLoop(), 0, tree);
    path[0] = -1;
    for (i=0; i<ed.cat.numobj; i++)
      objects[i] = 0;
    tree = new HomTree();
    numpaths2 = get_all_paths(path, inversepaths, obj2, obj1, ed.ini.getMaxLoop(), 0, tree);
    tree = new HomTree();

    // check all paths (obj1 to obj2) against all paths (obj2 to obj1)
    // and see if any pair forms an isomorphism
    int ret = 0;
    p1 = paths.getFirstPath();
    for (i=0; i<numpaths1; i++)
    {
      p2 = inversepaths.getFirstPath();
      for (j=0; j<numpaths2; j++)
      {
        // if the two paths are inverses, then their compositions will
        // reduce to the identity
        path = ed.cat.reduce(ed.cat.append_path(p1, p2));
        if (ed.cat.path_len(path) == 0)
        {
          path = ed.cat.reduce(ed.cat.append_path(p2, p1));
          if (ed.cat.path_len(path) == 0)
          {
            if (tree.addPath(p1))
            {
              if (tree.prev.tree == null) tree.prev.tree = new HomTree();
              if (tree.prev.tree.addPath(p2))
              {
                if (includeid || ed.cat.path_len(p1) != 0 || ed.cat.path_len(p2) != 0)
                {
                  viewbox.append(ed.cat.path_to_string(p1) + " and " + ed.cat.path_to_string(p2) + " are mutually inverse.\n");
                  ret++;
                }
              }
            }
          }
        }
        p2 = inversepaths.getNextPath();
      }
      p1 = paths.getNextPath();
    }
    return ret;
  }

  public int get_all_paths(int path[], HomTree paths, int obj1, int obj2, int maxloop, int numpathssofar, HomTree tree)
  /*
    Parameters:
      path[]        - integer array containing the path followed so far
      objects[]     - integer array containing a list of all the objects visited along the path
      paths[][]     - integer array containing a list of paths found
      obj1 and obj2 - the two objects to check for an isomorphism
      maxloop       - max endomorphism limit
    Purpose:
      gets all paths from obj1 to obj2
    Design:
      returns the number of paths found
  */
  {
    int i, j, pathlen;
    int endo = 0;
    int numnewpaths = 0;
    int numpaths = numpathssofar;

    if (path[0] == -1 && obj1 == obj2)
    {
      path[0] = -2;
      path[1] = -1;
      paths.addPath(path);
      numpaths++;
      numnewpaths++;
    }

    path = ed.cat.reduce(path);
    pathlen = ed.cat.path_len(path);
    if (path[0] == -2)
      path[0] = -1;

    for (i=0; i<pathlen; i++)
    {
      if (ed.cat.arr[path[i]][0] == ed.cat.arr[path[pathlen-1]][1])
      {
        endo++;
      }
    }

    // check to see if we've passed the endomorphism limit
    if (endo >= maxloop)
    {
      endopassed = true;
    }
    else if (pathlen < ed.ini.getMAXWORD()-1 && (!tree.containsPath(path) || pathlen == 0))
    {
      // now check all paths from here, recursively
      if (pathlen != 0) tree.addPath(path);
      int arrows[] = new int[ed.cat.numarr];
      for (i = ed.cat.all_arr(obj1, arrows)-1; i>=0; i--)
      {
        // add the new arrow to the path, and the new object to the object list
        for (j=pathlen; j>=0; j--)
          path[j+1] = path[j];
        path[0] = arrows[i];

        numpaths = get_all_paths(path, paths, ed.cat.arr[arrows[i]][1], obj2, maxloop, numpaths, tree);

        // now remove the arrow and object from the path and object list
        for (j=0; j<=pathlen; j++)
          path[j] = path[j+1];
      }

      // if we're at the second object, then add the path to the list, unless
      // it's already in there
      if (pathlen > 0 && ed.cat.arr[path[0]][1] == obj2)
      {
        if (paths.addPath(path))
        {
          numpaths++;
          numnewpaths++;
        }
      }
    }
    return numpaths;
  }

  // Close the window
  void close_actionPerformed(ActionEvent e)
  {
  	ed.enableMenus(true);
  	hide();
    dispose();
  }

  void this_windowClosing(WindowEvent e)
  {
  	ed.enableMenus(true);
  	hide();
    dispose();
  }

  void checkbox1_itemStateChanged(ItemEvent e)
  {
    if (checkbox1.isChecked())
    {
      choice1.setVisible(false);
      path1.setVisible(true);
      checkbox2.setEnabled(true);
      choice2.setVisible(false);
      path2.setVisible(false);
      if (checkbox2.isChecked())
        path2.setVisible(true);
      else
        path2.setVisible(false);
    }
    else
    {
      checkbox2.setEnabled(false);
      choice1.setVisible(true);
      path1.setVisible(false);
      choice2.setVisible(true);
      path2.setVisible(false);
    }
  }

  void checkbox2_itemStateChanged(ItemEvent e)
  {
    if (checkbox2.isChecked())
    {
      path2.setVisible(true);
    }
    else
    {
      path2.setVisible(false);
    }
  }
}