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

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

public class SumFrame extends Frame
{
  CategoryList l = new CategoryList();
  int check_enter = 0;
  int editoption = 0;
  boolean supress_output = false;
  boolean endopassed = false;

  IniSettings ini = new IniSettings();
  //Objects in the Graphical User Interface(GUI)
  Button exit = new Button();
  Panel button_panel = new Panel();
  BorderLayout borderLayout1 = new BorderLayout();
  Button okButton = new Button();
  MainWindow ed;
  Category cat = new Category();

  Label objectLabel = new Label();
  Label alphaLabel = new Label();
  Label betaLabel = new Label();
  Choice objectChoice = new Choice();

  public SumFrame(MainWindow edit)
  //Default Constructor with the parent frame as a parameter
  {
    ed = edit;
    cat.copyCategory(ed.cat);
    ed.enableMenus(false);
    try  {
      jbInit();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }

  public boolean handleEvent(Event e)
  {
    if ((e.id == Event.WINDOW_DESTROY))
    {
     ed.enableMenus(true);
     hide();            //hide frame
     dispose();         //free resources
     return true;
    }
    else if (e.key == Event.ENTER)
    {
      if (check_enter == 0)
        check_enter++;
      else
      {
        ed.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))
  {
   ed.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: Sum Category");
    this.setBackground(new Color(192,192,192));
    okButton.setLabel("Close");
    objectLabel.setText("Object of Sum:");
    alphaLabel.setText("First injection:");
    betaLabel.setText("Second injection:");
    objectChoice.setBackground(Color.white);

    categoryLabel.setText("Current Category:");
    viewbox.setEditable(false);
    viewbox.setBackground(Color.white);
    sumButton.setLabel("Sum?");
    alphaField.setBackground(Color.white);
    betaField.setBackground(Color.white);

    sumButton.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
        sumButton_actionPerformed(e);
      }
    });

    objectChoice.addItemListener(new java.awt.event.ItemListener() {
      public void itemStateChanged(ItemEvent e) {
        objectChoice_itemStateChanged(e);
      }
    });

    okButton.addActionListener(new java.awt.event.ActionListener() {
      public void actionPerformed(ActionEvent e) {
        okButton_actionPerformed(e);
      }
    });

    this.setLayout(gridBagLayout1);
    categoryField.setBackground(Color.white);
    this.add(okButton, g.getConstraints(2, 4, 1, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(7, 10, 8, 0), 70, 8));
    this.add(betaLabel, g.getConstraints(0, 3, 2, 1, 0.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(0, 2, 0, 0), -14, 2));
    this.add(alphaLabel, g.getConstraints(0, 2, 1, 1, 0.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(0, 2, 0, 0), -5, 8));
    this.add(objectLabel, g.getConstraints(0, 1, 1, 1, 0.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(9, 2, 0, 0), -5, 4));

    this.add(objectChoice, g.getConstraints(2, 1, 1, 1, 1.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.HORIZONTAL, new Insets(7, 8, 0, 0), 77, 0));
    this.add(categoryField, g.getConstraints(2, 0, 1, 1, 1.0, 0.0
            ,GridBagConstraints.SOUTHWEST, GridBagConstraints.HORIZONTAL, new Insets(9, 8, 0, 1), 79, 2));
    this.add(categoryLabel, g.getConstraints(0, 0, 2, 1, 0.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(15, 2, 0, 0), -10, 0));
    this.add(viewbox, g.getConstraints(3, 0, 1, 5, 1.0, 1.0
            ,GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(9, 17, 8, 6), 177, -9));
    this.add(sumButton, g.getConstraints(0, 4, 2, 1, 0.0, 0.0
            ,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(7, 2, 8, 0), 48, 8));
    this.add(alphaField, g.getConstraints(2, 2, 1, 1, 1.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(0, 7, 0, 0), 82, 3));
    this.add(betaField, g.getConstraints(2, 3, 1, 1, 1.0, 0.0
            ,GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(0, 7, 0, 0), 83, 3));

    categoryField.setEditable(false);
    categoryField.setText(cat.name);
    objectChoice.addItem("Check all objects");
    for (int i = 0; i < cat.numobj; i++)
      objectChoice.addItem(cat.obj[i]);
    objectChoice.select(1);
    if (objectChoice.getItemCount() == 0)
    {
      new MessageDialog(this, "Error", "Can not perform sum, category has 0 Objects", true);
    }
  }

  void sumButton_actionPerformed(ActionEvent e)
  //Determine the sum of the current object given
  //an alpha and beta value
  {
    endopassed = false;
    int numsums = 0;
    objchr = objectChoice.getSelectedItem();
    if (objchr.equals("Check all objects"))
    {
       if (cat.check_obj(alphaField.getText()))
       {
          viewbox.append("\n********ERROR********\n");
          viewbox.append(alphaField.getText() + " is not an object of " + cat.name + ".\n");
          viewbox.append("***********************\n\n");
       }
       else if (cat.check_obj(betaField.getText()))
       {
          viewbox.append("\n********ERROR********\n");
          viewbox.append(betaField.getText() + " is not an object of " + cat.name + ".\n");
          viewbox.append("***********************\n\n");
       }
       else
       {
          for (int i=0; i<cat.numobj; i++)
          {
             objchr = objectChoice.getItem(i+1);
             numsums += sum();
          }
          if (numsums == 0)
             viewbox.append("There is no sum of objects " + alphaField.getText() + " and " + betaField.getText() + ".\n");
          else if (numsums == 1)
             viewbox.append("1 sum was found.\n");
          else
             viewbox.append(Integer.toString(numsums) + " sums were found.\n");
       }
    }
    else
 	    sum();
    if (endopassed)
      viewbox.append("WARNING: Endomorpmism limit reached! Results may be inaccurate!\n\n");
    else
      viewbox.append("\n");
  }

  void okButton_actionPerformed(ActionEvent e)
  //Exit sum frame and return to main frame
  {
    ed.enableMenus(true);
    hide();
    dispose();
  }

//----------------
//SUM METHODS
//----------------

 public boolean check_oneone(int path[], int domain, int codomain, HomTree gamalbet, int alpha[], int beta[], HomTree gammatree, int maxloop, HomTree pathtree)
 /*
 Parameters:
        path:      the current path
        domain:    the current object of the path
        codomain:  the object we are trying to find all arrows to
        objects:   an array of integers which keeps the function from exceeding
                      the maximum number of loops
        gamalbet:  a tree returned with all gamma-alphas and gamma-betas
        alpha:     first injection to the sumobj being tested
        beta:      second injection to the sumobj being tested
        gammatree: the tree of all arrows from sumobj to codomain
        maxloop :  endomorphism limit

 Purpose:
        To generate the reduced hom set from one object to another and check 1-1

 Design:
        Creates a tree gamalbet containing the reduced form
        of all the gamma-alphas and each gamma-alpha having a subtree which contains
        all of the gamma-betas paired with it. Also creates a tree gammatree with all
        the gamma paths
 */
 {
  int i, j, len, number, codom, endo = 0;
  int arrow_array[] = new int [cat.numarr];
  int reducedGammaBeta[] = new int[ini.getMAXWORD()];
  int reducedGammaAlpha[] = new int[ini.getMAXWORD()];

  path = cat.reduce(path);
  len = cat.path_len(path);
  if (path[0] == -2)
    path[0] = -1;
  for (i=0; i<len; i++)
  {
    if (cat.arr[path[i]][1] == cat.arr[path[len-1]][0])
    {
      endo++;
    }
  }

  if (endo < maxloop && len < ed.ini.getMAXWORD()-1)
  {
    if (!pathtree.containsPath(path) || len == 0)
    {
      if (len == 0)
        codom = -1;
      else
      {
        pathtree.addPath(path);
        codom = cat.arr[path[0]][1];
      }
      if (codom == codomain)
      {
        int newpath[] = cat.reduce(path);
        if (gammatree.addPath(newpath))
        {
          reducedGammaAlpha = cat.reduce(cat.append_path(alpha, path));
          reducedGammaBeta = cat.reduce(cat.append_path(beta, path));
          if (cat.path_len(reducedGammaAlpha) == 0)
          {
            reducedGammaAlpha[0] = -2;
            reducedGammaAlpha[1] = -1;
          }
          if (cat.path_len(reducedGammaBeta) == 0)
          {
            reducedGammaBeta[0] = -2;
            reducedGammaBeta[1] = -1;
          }
          gamalbet.addPath(reducedGammaAlpha);
          if (gamalbet.prev.tree == null)
            gamalbet.prev.tree = new HomTree();
          if (!gamalbet.prev.tree.addPath(reducedGammaBeta))
          {
            return false;
          }
        }
      }

      number = cat.all_arr(domain, arrow_array);
      for (i=0; i<number; i++)
      {
        domain = cat.arr[arrow_array[i]][1];
        for (j=len; j>=0; j--)
          path[j+1] = path[j];
        path[0] = arrow_array[i];

        if (!check_oneone(path, domain, codomain, gamalbet, alpha, beta, gammatree, maxloop, pathtree))
          return false;

        len = cat.path_len(path);
        for (j=0; j<len; j++)
          path[j] = path[j+1];
      }
      return true;
    }
  }
  else
  {
    endopassed = true;
  }
  return true;
 }

 public int makeHomTree(int path[], HomTree homtree, int obj1, int obj2, int maxloop, HomTree pathtree)
  /*
    Parameters:
      path[]        - integer array containing the path followed so far
      objects[]     - integer array containing a list of all the objects visited along the path
      homtree       - the tree to contain the paths
      obj1 and obj2 - check for paths from obj1 to obj2
      maxloop       - max endomorphism limit
    Purpose:
      To generate the reduced hom set from one object to another as a tree
    Design:
      Creates a tree homtree of all the reduced paths from one object to another.
  */
  {
    int i, j;
    int endo = 0;
    path = cat.reduce(path);
    int pathlen = cat.path_len(path);
    int numpaths = 0;

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

    if (endo < maxloop && pathlen < ed.ini.getMAXWORD()-1)
    {
      int newpath[] = cat.reduce(path);
      if ((!pathtree.containsPath(newpath) || pathlen == 0))
      {
        if (pathlen != 0) pathtree.addPath(newpath);
        // now check all paths from here, recursively
        int arrows[] = new int[cat.numarr];
        if (pathlen < ed.ini.getMAXWORD()-1)
        for (i = 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=cat.path_len(path); j>=0; j--)
            path[j+1] = path[j];
          path[0] = arrows[i];

          numpaths += makeHomTree(path, homtree, cat.arr[arrows[i]][1], obj2, maxloop, pathtree);

          // 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 tree
        if (obj1 == obj2 && pathlen != 0)
        {
          numpaths++;
          homtree.addPath(newpath);
        }
      }
    }
    else
    {
      endopassed = true;
    }
    return numpaths;
  }

 public boolean check_onto(int path[], int domain, int codomain, HomTree gamalbet, HomTree rhotree, int maxloop, HomTree pathtree)
 /*
 Parameters:
        path:   the current path
        domain: the current object of the path
        codomain:       the object we are trying to find all arrows to
        objects:        an array of integers which keeps the function from exceeding
                                the maximum number of loops
        gamalbet: the tree of gamma alphas with gamma betas
        rho_tree:       a tree of all the rhos
 Local Variables:
        number: stores the number of arrows from an object
        current_arrow:  stores the number of the current arrow in the path
        codom:  stores the codomain of the current arrow
        arrow_array:    contains all of the arrows from an object
 Purpose:
        To check that a sum is onto
 Design:
        Generates all of the lambdas from one object to another and uses the rho tree
        it is passed to check that all of the pairs <lambda,rho> are in our tree.
 */
 {
   int i, j, len, number, codom, endo = 0;
   int arrow_array[] = new int[cat.numarr];
   path = cat.reduce(path);
   if (path[0] == -2)
     path[0] = -1;

   // check to see if we've passed the endomorphism limit
   len = cat.path_len(path);
   for (i=0; i<len; i++)
   {
     if (cat.arr[path[i]][1] == cat.arr[path[len-1]][0])
     {
       endo++;
     }
   }

   if (endo < maxloop && len < ed.ini.getMAXWORD()-1)
   {
     if (!pathtree.containsPath(path) || len == 0)
     {
       if (len == 0)
         codom = domain;
       else
       {
         pathtree.addPath(path);
         codom = cat.arr[path[0]][1];
       }
       if (codom == codomain)
       {
         int newpath[] = cat.reduce(path);
         if (path[0] == -1)
         {
         	path[0] = -2;
         	path[1] = -1;
         }
         if (!gamalbet.containsPath(newpath))
         {
           return false;
         }
         else
         {
           if (!rhotree.isEqual(gamalbet.prev.tree))
           {
             return false;
           }
         }
         if (path[0] == -2) path[0] = -1;
       }

       number = cat.all_arr(domain, arrow_array);
       if (number > 0)
       for (i=0; i<number; i++)
       {
         domain = cat.arr[arrow_array[i]][1];
         for (j=len; j>=0; j--)
           path[j+1] = path[j];
         path[0] = arrow_array[i];

         if (!check_onto(path, domain, codomain, gamalbet, rhotree, maxloop, pathtree))
           return false;

         for (j=0; j<=len; j++)
           path[j] = path[j+1];
       }
     }
   }
   else
   {
     endopassed = true;
     return false;
   }
   return true;
 }

 public boolean is_sum(int sumobj, int alpha[], int beta[], int maxloop)
 /*
 Parameters:
        A:      pointer to the category being tested
        sumobj: the object of the sum being tested
        alpha:  first injection of the sum
        beta:   second injection of the sum
 Local Variables:
        testobj: is currently being tested for sum property
        path:    keeps track of the current path to testobj from sumobj
        objects: array of integers storing the number of times each object has
           been visited in current path
        id:      a path that has a value of -2 and represents the identity arrow
        gammatree: tree of all arrows from sumobj to testobj
        gamalbet: tree of gamma alphas with gamma beta subtrees
        rhotree: tree of all arrows from domain of beta to testobj
        p, tp:   temporary pointers
  reduced_alpha, reduced_beta : normalized versions of the injections

 Purpose:
        To check each object in the category for 1-1 and onto.
 Design:
        Returns true if object is a sum, and false if not.
 */
 {
   int path[] = new int[ini.getMAXWORD()];
   int id[] = new int[2];
   int reducedAlpha[] = new int[ini.getMAXWORD()];
   int reducedBeta[] = new int[ini.getMAXWORD()];
   HomTree gamalbet; // all paths from all Paths A to C composed with gamma(C->D)
   HomTree gammatree;//all paths from C -> D
   HomTree rhotree;//all paths from B to D (will be bigger than gammalbet)
   HomTree pathtree;
   int obj, i, dom;

   // check each object in the category
   for (obj=0; obj<cat.numobj; obj++)
   {
     gamalbet = new HomTree();
     gammatree = new HomTree();
     rhotree = new HomTree();
     pathtree = new HomTree();
     path[0] = -1;
     id[0] = -2;
     id[1] = -1;

     // if testing the sum object, then the identity is a gamma, so
     // we must add alpha and beta to gamalbet
     if (obj == sumobj)
     {
       reducedAlpha = cat.reduce(alpha);
       reducedBeta = cat.reduce(beta);
       gamalbet.addPath(reducedAlpha);
       gamalbet.prev.tree = new HomTree();
       gamalbet.prev.tree.addPath(reducedBeta);
       gammatree.addPath(id);
     }

     if (!check_oneone(path, sumobj, obj, gamalbet, alpha, beta, gammatree, maxloop, pathtree))
     {
       if (!supress_output) viewbox.append("Problem at object " + cat.obj[obj] + "\n");
       return false;
     }

     // if beta is the identity, domain of beta is sum object
     if(cat.path_len(beta) == 0)
       dom = sumobj;
     // domain of beta is domain of first arrow in path
     else
       dom = cat.arr[beta[cat.path_len(beta)-1]][0];

     path[0] = -1;
     pathtree = new HomTree();

     makeHomTree(path, rhotree, dom, obj, maxloop, pathtree);

     if (dom == obj)
       rhotree.addPath(id);  // add identity to rhotree

     // if alpha is identity, domain of alpha is sum object
     if (cat.path_len(alpha) == 0)
       dom = sumobj;
     // domain of alpha is domain of first arrow in alpha
     else
       dom = cat.arr[alpha[cat.path_len(alpha)-1]][0];
       
     path[0] = -1;
     pathtree = new HomTree();

     if (rhotree.root.down != null && !check_onto(path, dom, obj, gamalbet, rhotree, maxloop, pathtree))
     {
       if (!supress_output) viewbox.append("Problem at object " + cat.obj[obj] + "\n");
       return false;
     }
   }
   return true;
 }

  // Global Variables needed for Sum option in category Tools
  String objchr;
  int alpha[] = new int [ini.getMAXWORD()];
  int beta[] = new int [ini.getMAXWORD()];
  int obj;
  TextField categoryField = new TextField();
  Label categoryLabel = new Label();
  TextArea viewbox = new TextArea("", 10, 10, TextArea.SCROLLBARS_VERTICAL_ONLY);
  Button sumButton = new Button();
  TextField alphaField = new TextField();
  TextField betaField = new TextField();
  GridBagLayout gridBagLayout1 = new GridBagLayout();
  GBConstraintsEditor g = new GBConstraintsEditor();

  public int sum()
  /*
  Purpose:
         To get user input about sum to be tested.
  Design:
         Gets user input and then calls function is_sum to test sum
  */
  {
    String alphapath, betapath;
    alphapath = alphaField.getText();
    betapath = betaField.getText();
    editoption = 0;
    int numsums = 0;

    // NOTE: if the user selected "check all objects", then
    // alphapath and betapath are actually objects, not paths
    if (objectChoice.getSelectedItem().equals("Check all objects"))
    {
      HomTree alphatree = new HomTree();
      HomTree betatree = new HomTree();
      HomTree pathtree = new HomTree();
      int path[] = new int[ini.getMAXARR()];
      int arrows1[] = new int[cat.numarr];
      int arrows2[] = new int[cat.numarr];
      int alpha[] = new int[2];
      int beta[] = new int[2];

      obj = cat.object_number(objchr);
      path[0] = -1;
      int numarrs1 = makeHomTree(path, alphatree, cat.object_number(alphapath), obj, ini.getMaxLoop(), pathtree);
      pathtree = new HomTree();
      path[0] = -1;
      int numarrs2 = makeHomTree(path, betatree, cat.object_number(betapath), obj, ini.getMaxLoop(), pathtree);
      pathtree = new HomTree();
      path[0] = -2;
      path[1] = -1;

      if (cat.object_number(alphapath) == obj)
      {
        alphatree.addPath(path);
        numarrs1++;
      }
      if (cat.object_number(betapath) == obj)
      {
        betatree.addPath(path);
        numarrs2++;
      }

      // we don't want the is_sum function telling the user which objects
      // aren't sums, so we supress that output
      supress_output = true;

      // now loop through each pair of arrows from the first object to the sum object
      alpha = alphatree.getFirstPath();
      for (int i=0; i<numarrs1; i++)
      {
      	beta = betatree.getFirstPath();
        for (int j=0; j<numarrs2; j++)
        {
          if (is_sum(obj,alpha,beta,ini.getMaxLoop()))
          {
          	 pathtree.addPath(alpha);
          	 if (pathtree.prev.tree == null) pathtree.prev.tree = new HomTree();
       	     if (pathtree.prev.tree.addPath(beta))
       	     {
               viewbox.append(cat.obj[obj] + " is a sum with injections " + cat.path_to_string(alpha) + " and " + cat.path_to_string(beta) + ".\n");
               numsums++;
             }
          }
          beta = betatree.getNextPath();
        }
        alpha = alphatree.getNextPath();
      }
      supress_output = false;
    }
    else
    {
      if(cat.check_obj(objchr))
      {
        viewbox.append("\n********ERROR********\n");
        viewbox.append(objchr + " is not an object of " + cat.name + ".\n");
        viewbox.append("***********************\n\n");
      }
      else
      {
        editoption = 1;
        obj = cat.object_number(objchr);
      }
      if (editoption == 1)
      {
        if (cat.check_string(alphapath))
        {
          alpha = cat.string_to_path(alphapath);
          if (cat.check_path(alpha))
          {
            if (alpha[0] >= 0 && cat.arr[alpha[0]][1] != obj)
            {
              viewbox.append("\nFirst path must have codomain of " + cat.obj[obj] + "\n\n");
            }
            else
            {
              editoption = 2;
            }
          }
          else
          {
            viewbox.append("Invalid first path\n");
          }
        }
        else
        {
          viewbox.append("Invalid first path\n");
        }
      }
      if (editoption == 2)
      {
        if ((cat.check_string(betapath)))
        {
          beta = cat.copy_path(cat.string_to_path(betapath));
          if (cat.check_path(beta))
          {
            if (beta[0] >= 0 && cat.arr[beta[0]][1] != obj)
            {
              viewbox.append("\nSecond path must have codomain of " + cat.obj[obj] + "\n");
            }
            else
            {
              if (is_sum(obj,alpha,beta,ini.getMaxLoop()))
              {
                viewbox.append(cat.obj[obj] + " is a sum.\n");
              }
              else
              {
                viewbox.append(cat.obj[obj] + " is not a sum.\n");
              }
            }
          }
          else
          {
            viewbox.append("Invalid second path\n");
          }
        }
        else
        {
          viewbox.append("Invalid second path\n");
        }
      }
    }
    return numsums;
  }

  public void objectChoice_itemStateChanged (ItemEvent e)
  {
    if (objectChoice.getSelectedItem().equals("Check all objects"))
    {
      alphaLabel.setText("First object:");
      betaLabel.setText("Second object:");
    }
    else
    {
      alphaLabel.setText("First injection:");
      betaLabel.setText("Second injection:");
    }
  }
}