/*
Research Project:   Graphical Database for Category Theory
                    J. Bradbury, Dr. R. Rosebrugh, I. Rutherford
                    M. Graves, J. Tweedle
                    Mount Allison University 2001
                    Updated: May 8th, 2003
File:               Sum.java
Description:        This class contains the algorithms to test a category
                    for sums.  It is used only by the SumFrame class.
*/


public class Sum
{
	private Category cat;
	private IniSettings ini;

	private int editoption;
	private int obj;
	private int alpha[]; 
	private int beta[];
	private int numsums;
	private String output;
	private String type;
	private boolean supress_output;
	private boolean endopassed;
	
	public static final int NOT_AN_OBJECT = 0;
	public static final int INVALID_FIRST_DOMAIN = -1;
	public static final int INVALID_FIRST_PATH = -2;
	public static final int INVALID_SECOND_DOMAIN = -3;
	public static final int INVALID_SECOND_PATH = -4;
	public static final int SUM	= -5;
	public static final int NOT_SUM = -6;

	public Sum(Category newCat, String newType)
	{
		cat = newCat;
		ini = cat.ini;
		output = "";
		type = newType;
		numsums = 0;
		supress_output = false;
		endopassed = false;
		alpha = new int [ini.getMAXWORD()];
		beta = new int [ini.getMAXWORD()];
	}

//----------------
//sum (product) METHODS
//----------------

	public boolean is_sum(int sumobj, int alpha[], int beta[], int maxloop)
	/*
	Parameters:
	       sumobj: the object of the sum being tested
	       alpha:  first projection of the sum
	       beta:   second projection 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 projections
	
	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;	// obj is test object
	
		// check each object in the category
		for (obj=0; obj<cat.num_objects; 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 (!cat.check_oneone(path, sumobj, obj, gamalbet, alpha, beta, gammatree, maxloop, pathtree))
			{
				if (!supress_output)
					output += "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();
	
			cat.makeHomTree(path, rhotree, dom, obj, maxloop, pathtree);	// make Hom(B, obj); this is what is in rhotree
																			// pathtree doesn't mean anything
			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();
				// check onto; makes Hom(A, obj), and checks against Hom(B, obj), to make sure that both are in the path (?);
				// or maybe that one gamma does not make two Hom(A, obj) and Hom(B, obj) that are the same (?)
			if (rhotree.root.down != null && !cat.check_onto(path, dom, obj, gamalbet, rhotree, maxloop, pathtree))
			{
				if (!supress_output)
					output += "Problem at object " + cat.obj[obj] + "\n";
				return false;
			}
		}
		return true;
	}
	
	
	public int sumAllObjects(String alphaF, String betaF, String objchr)
	/*
	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 = alphaF;
		String betapath = betaF;

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

		obj = cat.object_number(objchr);
		path[0] = -1;
		int numarrs1 = cat.makeHomTree(path, alphatree, cat.object_number(alphapath), obj, ini.getMaxLoop(), pathtree);
		pathtree = new HomTree();
		path[0] = -1;
		int numarrs2 = cat.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))
					{
						if (type.equals("sum"))
							output += cat.obj[obj] + " is a sum with injections " + cat.path_to_string(alpha) + " and " + cat.path_to_string(beta) + ".\n";
						else if (type.equals("product"))
							output += cat.obj[obj] + " is a product with projections " + cat.path_to_string(cat.reverse_path(alpha)) + " and " + cat.path_to_string(cat.reverse_path(beta)) + ".\n";
						numsums+=1;
					}
				}
				beta = betatree.getNextPath();
			}
			alpha = alphatree.getNextPath();
		}
		supress_output = false;
		return numsums;
	}

	public int sumOneObject(String alphaF, String betaF, String objchr)
	{
		String alphapath;
		String betapath;
		alphapath = alphaF;
		betapath = betaF;
		editoption = 0;
		if(!cat.check_obj(objchr))
		{
			output += objchr + " is not an object of " + cat.name + ".";
			return NOT_AN_OBJECT;
		}
		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)
					{
						output += "First path must have domain of " + cat.obj[obj] + ".";
						return INVALID_FIRST_DOMAIN; 
					}
					else
					{
						editoption = 2;
					}
				}
				else
				{
					output += "Invalid first path.";
					return INVALID_FIRST_PATH;
				}
			}
			else
			{
				output += "Invalid first path.";
				return INVALID_FIRST_PATH;
			}
		}
		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)
					{
						output += "Second path must have domain of " + cat.obj[obj] + ".";
						return INVALID_SECOND_DOMAIN; 
					}
					else
					{
						if (is_sum(obj,alpha,beta,ini.getMaxLoop()))
						{
							output += cat.obj[obj] + " is a " + type + ".";
							return SUM; 
						}
						else
						{
							output += cat.obj[obj] + " is not a " + type + ".";
							return NOT_SUM; 
						}
					}
				}
				else
				{
					output += "Invalid second path.";
					return INVALID_SECOND_PATH; 
				}
			}
			else
			{
				output += "Invalid second path.";
				return INVALID_SECOND_PATH; 
			}
		}
		return this.getNumSums();
	}

	public int getNumSums()
	{
		return numsums;
	}
	
	public void setNumSums(int newNumSums)
	{
		numsums = newNumSums;
	}
	
	public String getOutput()
	{
		return output;
	}
	
	public void setOutput(String newOutput)
	{
		output = newOutput;
	}
	
	public boolean getSupressOutput()
	{
		return supress_output;
	}
	
	public void setSupressOutput(boolean newSupressOutput)
	{
		supress_output = newSupressOutput;
	}
	
	public boolean getEndoPassed()
	{
		return endopassed;
	}
	
	public void setEndoPassed(boolean newEndoPassed)
	{
		endopassed = newEndoPassed;
	}
}