/*
Research Project:   Graphical Database for Category Theory
                    J. Bradbury, Dr. R. Rosebrugh, I. Rutherford
                    Mount Allison University 2001
File:               Category.java
Description:	      This class contains all of the information that is needed
                    for a category and some useful functions
*/

import java.awt.*;

class Category
{
  IniSettings ini = new IniSettings();  //IniSettings class that contains the lengths
                                        //of the arrays in the Category class
  String name;                          //Name of the category

  String[] obj = new String[ini.getMAXWORD()]; //Names of the objects in the category
  int numobj = 0;                       //Number of objects in category

  int[][] arr = new int[ini.getMAXARR()][2];   //domain and codomain of arrows
  String[] arrow = new String[ini.getMAXARR()];//Names of arrows in a category
  int numarr = 0;                       //Number of arrows in category

  Relation[] rel_set = new Relation[ini.getMAXARR()];  //Contains relations in category
  int num_rel = 0;                      //Number of relations in category

  String comment = new String();        //Comments about the category
  String filename = new String();       //Name of file that category was opened,
                                        //loaded, or saved in
  String gml = new String();            //Text version of graphical interpretation
                                        //of thecategory
  String originalGml = new String();    //Text version of the original graphical
                                        //interpretation of the category

  CategoryModified mod = new CategoryModified(); //This contains all of the information
                                                //about modifications to the original
                                                //category file

  public boolean isModified()
  //Return true if the category was not originally saved
  //or has been modified since it was last saved
  {
    if (mod.downloadCat || mod.functorCat || mod.createCat || mod.dualCat || mod.downloadCat)
      return true;
    else if (mod.dataAdded || mod.dataRemoved || (!gml.equals(originalGml) && !originalGml.equals("")) || mod.nameChanged || mod.madeConfluent)
      return true;
    else
      return false;
  }

  public void copyCategory(Category c)
  {
    if (c == null) return;
    int i, j, temp;

    name = new String(c.name);
    numobj = c.numobj;
    numarr = c.numarr;
    num_rel = c.num_rel;
    for (i=0; i<numobj; i++)
      obj[i] = new String(c.obj[i]);
    for (i=0; i<numarr; i++)
    {
      arr[i][0] = c.arr[i][0];
      arr[i][1] = c.arr[i][1];
      arrow[i] = new String(c.arrow[i]);
    }
    rel_set = new Relation[ini.getMAXARR()];
    for (i=0; i<num_rel; i++)
    {
      rel_set[i] = new Relation();
      j = -1;
      do
      {
        j++;
        rel_set[i].rhs[j] = c.rel_set[i].rhs[j];
      } while (c.rel_set[i].rhs[j] != -1 && c.rel_set[i].rhs[j] != -2);
      j = -1;
      do
      {
        j++;
        rel_set[i].lhs[j] = c.rel_set[i].lhs[j];
      } while (c.rel_set[i].lhs[j] != -1 && c.rel_set[i].lhs[j] != -2);
    }
    comment = new String(c.comment);
    filename = new String(c.filename);
    gml = new String(c.gml);
    originalGml = new String(c.originalGml);
    CategoryModified mod = new CategoryModified();
  }

  public boolean check_arr(String str)
  /*
  Parameters:
         str - the name of the arrow being checked
  Purpose:
         To determine whether an arrow is in the category
  Design:
         Returns true if the arrow is in the category and false if it is not
  */
  {
    int i;

    for(i=0; i<numarr; i++)
    {
      if (str.equals(arrow[i]))
      {
        return true;
      }
    }
    return false;
  }

  public boolean check_obj(String object)
  /*
  Parameters:
         object - the name of the object being checked
  Purpose:
         To determine whether an object is in the category
  Returns:
         Returns true if the object is in the category and false if it is not
  */
  {
    int i;

    for(i=0; i<numobj; i++)
    {
      if(object.equals(obj[i]))
      {
        return(false);
      }
    }
    return(true);
  }

  boolean check_path(int path[])
  /*
  Parameters:
         path - the path to be checked
  Purpose:
         To check that the domains and codomains of all the arrows in the path
         match up, ie. checks if the path is a valid path in this category
  Returns:
         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, cur, next;

    for (i=0; i<(path_len(path)-1); i++)
    {
       cur = path[i];
       next = path[i+1];
       if ((arr[cur][0]) != (arr[next][1]))
       {
         return(false);
       }
    }
    return(true);
  }

  public int path_len(int path[])
  /*
  Parameters:
         path - an array of integers terminated by -1 which is a path
  Returns:
         an integer specifying the length of the path
  Purpose:
         To determine the length of an array of integers terminated by -1
  */
  {
    int length = 0;
    while (path[length] != -1 && path[length] != -2)
      length++;

    return length;
  }

  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
  Returns:
        Returns the position where the subpath begins in the path being searched,
        or -1 if sub is not a subpath of target
  */
  {
    int i, j, len1, len2;
    boolean found;
    len1 = path_len(target);
    len2 = path_len(sub);

    found = false;
    for (i=start; i<=len1-len2; i++)
    {
      if (sub[0] == target[i])
      {
        found = true;
        for (j=0; j<len2; j++)
          if (target[i+j] != sub[j])
            found = false;
      }
      if (found)
        break;
    }

    if (found)
      return i;
    else
      return -1;
  }

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

    for (i=0;i<num_rel;i++)
    {
      if((spot = search(rel_set[i].lhs,reducedpath,0)) != -1)
      {
        for (j=spot;j<spot+path_len(rel_set[i].rhs);j++)
        {
          reducedpath[j] = rel_set[i].rhs[j - spot];
        }
        temp = path_len(reducedpath);
        diff = path_len(rel_set[i].lhs) - path_len(rel_set[i].rhs);
        for (j=spot+path_len(rel_set[i].lhs);j<temp;j++)
        {
          reducedpath[j - diff] = reducedpath[j];
        }
        reducedpath[j - diff] = -1;
        i = -1;
      }
    }

    j = path_len(path);
    if (reducedpath[j] == -2)
      reducedpath[j] = -1;
    if (reducedpath[0] == -1 || reducedpath[0] == -2)
    {
      reducedpath[0] = -2;
      reducedpath[1] = -1;
    }
    return(reducedpath);
  }

  public int arrow_number(String name)
  /*
  Parameters:
        name - the name of the arrow to check
  Purpose:
        To check if an arrow of a given name exists in the
        category, and to get its number if it exists
  Returns:
        the number of the named arrow, or -1 if the arrow doesn't exist
  */
  {
    int i;

    for(i=0;i < numarr;i++)
    {
      if(arrow[i].equals(name))
      {
        return(i);
      }
    }
    return(-1);
  }

  public int object_number(String name)
  /*
  Parameters:
         name:   the name of the object that we want the integer value of
  Purpose:
         To get the integer representation for the character representation
         of an object
   Design:
         Returns the integer value of an object, -1 if the object is not in the
         category
  */
  {
    int i;

    for(i=0; i<numobj; i++)
    {
      if(obj[i].equals(name))
      {
        return(i);
      }
    }
    return(-1);
  }

  int[] string_to_path(String st)
  /*
  Parameters:
        st:     the string that we want to convert to an array of integers terminated
                by -1
  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 (st.length() == 0)
    {
      temp[0] = -1;
      return temp;
    }
    else
    {
      String arr = new String();
      int arrnum = 0;
      int prev = 0;

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

      temp[arrnum] = -1;

      return temp;
    }
  }

  public String path_to_string(int path[])
  {
    int i, len = path_len(path);
    String temp = new String();

    for (i=0; i<len; i++)
    {
      temp += arrow[path[i]];
      if (i != len-1)
        temp += "*";
    }
    if (temp.length() == 0)
      return new String("1");
    return temp;
  }

  public int[] append_path(int path1[], int path2[])
  /*
  Parameters:
         dest   - an array of integers is appended to this array of integers
         source - this array of integers is appended to dest
  Purpose:
         To append one array of intgers to another array of integers,
         all terminated by -1
  Returns:
         Appends source to dest and returns dest
  */
  {
    int i, size1 = path_len(path2), size2 = path_len(path1);
    int ret[] = new int[size1 + size2 + 1];

    for(i=0; i<size1; i++)
      ret[i] = path2[i];
    for (i=0; i<=size2; i++)
      ret[i+size1] = path1[i];

    return ret;
  }

  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 the paths to check for
         equivalence - it checks for exact equality
  */
  {
    int i;
    if((path_len(path1)) == (path_len(path2)))
    {
      if (path_len(path1) == 0)
        return true;
      for(i=0; i<path_len(path1); i++)
      {
        if(path1[i] != path2[i])
        {
          return(false);
        }
      }
      return(true);
    }
    else
    {
      return(false);
    }
  }

  public int[] copy_path(int source[])
  /*
  Parameters:
        source - an array of integers which is copied
  Purpose:
        To copy one array of integers to another array of integers
  Returns:
        Copies source into a new integer array and returns it
  */
  {
    int i = path_len(source)+1;
    if (i < ini.getMAXWORD()) i = ini.getMAXWORD();
    int temp[] = new int[i];

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

  public int[] copy_path(int source[], int maxlen)
  /*
  Parameters:
        source - an array of integers which is copied
        maxlen - maximum number of arrows to copy
  Purpose:
        To copy one path to path
  Returns:
        Copies source into a new integer array and returns it
        up to a maximum length of maxlen
  */
  {
    int i, len = path_len(source);
    int temp[] = new int [ini.getMAXWORD()];

    if (len <= maxlen)
    {
      for (i=0; i<=len; i++)
      {
        temp[i] = source[i];
      }
    }
    else
    {
      for (i=len-maxlen; i<len; i++)
      {
        temp[i-len+maxlen] = source[i];
      }
      temp[maxlen] = -1;
    }
    return(temp);
  }

  public boolean check_string(String str)
  //This function is designed to verify that all arrows in the 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
  {
    if (str.length() == 0) return false;
    if (str.equals("1")) return true;
    String arr = new String();
    int prev = 0;
    int i;

    for (i=0; i<str.length(); i++)
    {
      if ((str.charAt(i) == '*'))
      {
        arr = str.substring(prev, i);
        if (!check_arr(arr))
        {
          return(false);
        }
        prev = i+1;
      }
      else if (i == (str.length()-1))
      {
        arr =  str.substring(prev, i+1);
        if (!check_arr(arr))
        {
          return(false);
        }
        prev = i+1;
      }
    }
    return(true);
  }

  public boolean greater(int path1[], int path2[])
  /*
  Parameters:
        path1:  an array of integers terminated by -1
        path2:  an array of integers terminated by -1
  Purpose:
        To determine if path1 has a greater ordering than path2
  Design:
        Returns true if path1 is of greater order than path2
  */
  {
    int j;

    if(path_len(path1) > path_len(path2))
    {
      return(true);
    }
    else
    {
      if ((path_len(path1)) == (path_len(path2)))
      {
        if ((path_len(path1) == 1) && (path1[0] == ini.getIdentityCode()))
        return(false);
        j = 0;
        while  (j < path_len(path1))
        {
          if (path2[j] > path1[j])
          {
            return(false);
          }
          else
          {
            if (path2[j] < path1[j])
            {
              return(true);
            }
          }
          j++;
        }
      }
    }
    return(false);
  }

  public Category makeDual()
  /*
  Purpose:
        To dualize a category
  Design:
        Makes a dual of the category and returns it
  */
  {
    char over, leave;
    int i, j, temp;
    int temp2[] = new int [ini.getMAXWORD()];
    int temp3[] = new int [ini.getMAXWORD()];
    boolean done;

    Category B = new Category();
    B.name = name; // + "DUAL";

    B.numobj = numobj;
    B.numarr = numarr;
    B.num_rel = num_rel;
    for(i=0;i<numobj;i++)
      B.obj[i] = obj[i];
    for(i=0;i<numarr;i++)
    {
      B.arrow[i] = arrow[i];
      B.arr[i][0] = arr[i][1];
      B.arr[i][1] = arr[i][0];
    }
    for(i=0;i<num_rel;i++)
    {
      for(j=path_len(rel_set[i].lhs)-1;j>=0;j--)
      {
        temp2[path_len(rel_set[i].lhs)-1-j] = rel_set[i].lhs[j];
      }
      temp2[path_len(rel_set[i].lhs)] = -1;
      for(j=path_len(rel_set[i].rhs)-1;j>=0;j--)
      {
        temp3[path_len(rel_set[i].rhs)-1-j] = rel_set[i].rhs[j];
      }
      temp3[path_len(rel_set[i].rhs)] = -1;
      Relation r = new Relation();
      if (greater(temp2,temp3))
      {
        r.lhs = copy_path(temp2);
        r.rhs = copy_path(temp3);
      }
      else
      {
        r.lhs = copy_path(temp3);
        r.rhs = copy_path(temp2);
      }
      B.rel_set[i] = r;
    }
    return B;
  }

  public int all_arr(int obj, int arrows[])
  /*
  Parameters:
         obj:      integer representing an object in the category
         arrows:   array containing all arrows with object obj as their domain
  Purpose:
         Returns an integer whose value is the number of arrows in the category
         with object obj as their domain.  The array is passed back containing
         all such arrows.
  */
  {
    int j, k=0;

    for (j=0;j<numarr;j++)
    {
      if (arr[j][0] == obj)
      {
        arrows[k] = j;
        k++;
      }
    }
    return k;
  }

  public int[] reverse_path(int[] path)
  {
    // reverse the array before comparing it with the relations
    int i, j = path_len(path);
    int size = ini.getMAXARR();
    if (j > size) size = j;
    int[] ret = new int[j+1];

    for (i=0; i<j; i++)
    {
      ret[i] = path[j-i-1];
    }
    ret[j] = -1;
    return ret;
  }
}