/* -------------------------------------------------------------------------- */
/*                                                                            */
/*                         T-TREE CANVAS SUB_CLASS                            */
/*                                                                            */
/*                              Frans Coenen                                  */
/*                                                                            */
/*                            10 September 2008.                               */
/*                                                                            */
/*                      Department of Computer Science                        */
/*                       The University of Liverpool                          */
/*                                                                            */
/* -------------------------------------------------------------------------- */

/** Modules to paint a representation of the T-tree where the T-tree comprises 
fuzzy data. Methods place all T-tree nodes are placed in an X-Y plane which is 
then processed and output.  */

import java.awt.*;

// Java extension packages
import javax.swing.*;

public class TtreeCanvasSub extends TtreeCanvas {

    /** Referece to start of T-tree data structure. */
    private FuzzyTtreeNode[] startTtreeRef = null;
    

    /* CONSTRUCTORS */

    public TtreeCanvasSub(int numXnodes, int numYnodes, FuzzyTtreeNode[] tTreeRef,
    			double supp) {
	startTtreeRef=tTreeRef;
	minSupport = supp;
//System.out.println("TtreeCanvas: numXnodes = " + numXnodes + ", numYnodes = " +
//numYnodes);
	// Initialise node array
	nodeArray=new int[numXnodes][numYnodes][3];
	for (int colIndex=0;colIndex<nodeArray.length;colIndex++) {
	    for (int rowIndex=0;rowIndex<nodeArray[colIndex].length;rowIndex++) {
	        for (int index3=0;index3<3;index3++) {
	    	    nodeArray[colIndex][rowIndex][index3]=0;
	            }
	        }
	    }

	// Populate node array
	populateArray(0,0,startTtreeRef);
//outputNodeArray();
	}
	   
    /* --------------------------------------------------------- */
    /*                                                           */
    /*                       NODE DRAWING                        */
    /*                                                           */
    /* --------------------------------------------------------- */

    /* --------------------------------------------------------- */
    /*                                                           */
    /*                   POPULATE NODE ARRAY                     */
    /*                                                           */
    /* --------------------------------------------------------- */

    /**
    @param startColIndex the X index into the node array for the start of the
    T-tree array (0 at start).
    @rowIndex rowIndex the Y index unto the node array (current level) for the
    T-tree array (0 at start).
    @param treeRef the reference into the current level in the T-tree (top at
    start).   */

    protected void populateArray(int startColIndex, int rowIndex, FuzzyTtreeNode[] treeRef) {

	// Count number of supported nodes at current level (we do not want
	// to output unsupported nodes)
	int numSupportedNodes=0;
	for(int index=1;index<treeRef.length;index++) {
	    if (treeRef[index]!=null) numSupportedNodes++;
	    }

	// Check For room, nay have to increment row index
	rowIndex = checkForSpace(startColIndex,rowIndex,numSupportedNodes);

	// Add current level in T-tree working along T-tree level but placing
	// details in node array space in reverse.
	int colIndex=startColIndex+numSupportedNodes-1;
	boolean start=true;
	for(int index=treeRef.length-1;index>0;index--) {
	    // Check if supported
            if (treeRef[index]!=null) {
	        // Lable
                nodeArray[colIndex][rowIndex][0] = index;
	        // support
                nodeArray[colIndex][rowIndex][1] = (int)
                                                 ((treeRef[index].support+0.005)*100);
		// If strat and supported child nodes then type 2 else type 0
                if (start) {
		    if (supportedChildNodes(treeRef[index].childRef)) {
		        nodeArray[colIndex][rowIndex][2]=2;
			populateArray(colIndex,rowIndex+1,treeRef[index].childRef);
			}
		    else nodeArray[colIndex][rowIndex][2]=0;
		    }
		// If not start and supported child nodes then type 3, otherwise
		// type 1.
		else {
		    if (supportedChildNodes(treeRef[index].childRef)) {
		    	nodeArray[colIndex][rowIndex][2]=3;
			populateArray(colIndex,rowIndex+1,treeRef[index].childRef);
			}
		    else nodeArray[colIndex][rowIndex][2]=1;
		    }
		// Decrement volumn index
	        colIndex--;
	        // Set start flag to false
		start=false;
		}
	    }
	}

    /* CHECK FOR SUPPORT CHILD NODES */

    private boolean supportedChildNodes(FuzzyTtreeNode[] treeRef) {
        if (treeRef==null) return(false);

	// Loop
	for (int index=1;index<treeRef.length;index++) {
	    if (treeRef[index]!=null) return(true);
	    }

	// Default return
	return(false);
	}

    /* CHECK FOR SPACE */

    /** Checks if there is sufficient space in the node array, if so returns
    current row index, otherwise increments row index and trys again.
    @param startColIndex the curent x coordinate.
    @param rowIndex the current Y coordinate
    @param numSupportedNodes the number ofnodes to be fitted into the array.
    @return the revise Y coordinate. */

    private int checkForSpace(int startColIndex, int rowIndex,
    					int numSupportedNodes) {
    	// Step alng level
//System.out.println("checkForSpace: startColIndex = " + startColIndex +
//", rowIndex = " + rowIndex);
        for (int index=startColIndex;index<startColIndex+numSupportedNodes;
								index++) {
            // Slot occupied by node, or slot not occupied but used by vertical
	    // arc from some other node
//System.out.println("index = " + index + ", rowIndex = " + rowIndex);
//System.out.println("nodeArray.length = " + nodeArray.length +
//", nodeArray[index].length = " + nodeArray[index].length);
	    if ((nodeArray[index][rowIndex][0]!=0) ||
	    				(nodeArray[index][rowIndex][2]==4)) {
	        // Set current slot to "occupied by vertical arc"
	        nodeArray[startColIndex][rowIndex][2]=4;
	        // Increment Y (row index) and repeat
	        return(checkForSpace(startColIndex,rowIndex+1,numSupportedNodes));
	        }
	    }

        // Return
        return(rowIndex);
        }

    /* ----------------------------------------------------- */
    /*                                                       */
    /*             OUTPUT (DIAGNOSTIC PUPOSES ONLY)          */
    /*                                                       */
    /* ----------------------------------------------------- */

    }