/* -------------------------------------------------------------------------- */
/*                                                                            */
/*                    W E I G H T E D   A P R I O R I   T                     */
/*                                                                            */
/*                               Frans Coenen                                 */
/*                                                                            */
/*                          Tuesday 9 September 2008                          */
/*                                                                            */
/*                       Department of Computer Science                       */
/*                        The University of Liverpool                         */
/*                                                                            */
/* -------------------------------------------------------------------------- */

/** Class that contains methods to support Weighted Association Rule Mining (WARM)
based in the Apriori-T algorithm. */

/* Structure:

AssocRuleMining
      |
      +-- TotalSupportTree
      		  |
		      +-- FuzzyAprioriT
		           		|
		           		+-- WeightedAprioriT	 */

//package lucsKDD_ARM;

// Java packages
import java.io.*;
import java.util.*;

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

public class WeightedAprioriT extends FuzzyAprioriT {

    /*------------------------------------------------------------------------*/
    /*                                                                        */
    /*                                   FIELDS                               */
    /*                                                                        */
    /*------------------------------------------------------------------------*/

    /** 2-D aray to hold input data from data file. <P>First index is row (record or
    TID) number starting from 0, and second is attribute (column) number starting from
    zero. */
    protected short[][] dataArray = null;
    /** Weightings array. */
    private double[] weightings = null;
    /** Number of weighting values, */
    private int numWeightings = 0;

    /*---------------------------------------------------------------------*/
    /*                                                                     */
    /*                           CONSTRUCTORS                              */
    /*                                                                     */
    /*---------------------------------------------------------------------*/

    /** With argument from existing instance of class AssocRuleMining.
    @param newInstance the given instance of the <TT>AssocRuleMining</TT>
    class. */

    public WeightedAprioriT(FWARMaprioriT newInstance) {
	    super(newInstance);
	    weightings = newInstance.weightings;
	    numWeightings = newInstance.numWeightings;

	    // Create data item
	    int dataLength = newInstance.dataArray.length;
	    dataArray = new short[dataLength][];
	    // copy
	    for (int index1=0;index1<newInstance.dataArray.length;index1++) {
	        dataLength = newInstance.dataArray[index1].length;
	        dataArray[index1] = new short[dataLength];
                for (int index2=0;index2<newInstance.dataArray[index1].length;
                                                                    index2++) {
                dataArray[index1][index2] =
                         newInstance.dataArray[index1][index2].getItemNumber();
                }
	    }
//outputDataArray();
       }

    /** Default constructor. */

    public WeightedAprioriT() {
        }

    /*-------------------------------------------------------------------*/
    /*                                                                   */
    /*                   T-TREE BUILDING METHODS                         */
    /*                                                                   */
    /*-------------------------------------------------------------------*/

    /** Commences start process of generating a total support tree (T-tree): GUI
    version. Min support is used in non-weighted Apriori-T and is the support in
    terms of number of records, this has no meaning with respect to fuzzy
    support as defined here. Min support therefore has the same value as the
    support field.
    @param textArea the given instance of the <TT>JTextArea</TT> class. */

    public void createTotalSupportTree(JTextArea textArea) {
        // Calculate support in terms of number of records
	double tempSup = numRows*support;
	textArea.append("Weighted Apriori-T with X-Checking\nMinimum support " +
	              "threshold = " + twoDecPlaces(support) + " (" +
                            twoDecPlaces(tempSup) + " records)\n");

	// If no data (possibly as a result of an order and pruning operation)
	// return
	if (numOneItemSets==0) return;

	// Initilise T-tree data structure and diagnostic counters. Set number
	// of t-tree nodes to zero (this is a static field so will not be reset
	// in repeat calls to the T-tree constructor).
	startTtreeRef   = null;
 	numFrequentSets = 0;
 	numUpdates      = 0l;
	TtreeNode.setNumberOfNodesFieldToZero();

        // Continue: create Ttree top level, generate level 2, and then create
        // T-tree level Ns (method contained in TotalSupportTree) class.
        contCreateTtree(textArea);
        }

    /** Adds supports to level 1 (top) of the T-tree. */

    protected void createTtreeTopLevel2() {
//System.out.println("Weighted Apriori-T: createTtreeTopLevel2: numRows = " +
//numRows);
        numLevelsInTtree = 1;

        // Loop through data set record by record and add support for each
	// 1 itemset
	for (int index1=0;index1<dataArray.length;index1++) {
	    // Non null record (if initial data set has been reordered and
	    // pruned some records may be empty!
	    if (dataArray[index1] != null) {
    	        for (int index2=0;index2<dataArray[index1].length;index2++) {
                    int attNum = dataArray[index1][index2];
		    startTtreeRef[attNum].support=
                              startTtreeRef[attNum].support+weightings[attNum];
//System.out.println("startTtreeRef[" + attNum + "].support = " + startTtreeRef[attNum].support);
		    numUpdates++;
		    }
		}
	    }
//System.out.println("numRows = " +
//numRows);
//outputTtree();
	}

    /* GENERATE LEVEL 2 */

    /** Generates level 2 of the T-tree. <P> The general
    <TT>generateLevelN</TT> method assumes we have to first find the right
    level in the T-tree, that is not necessary in this case of level 2. */

    /* protected void generateLevel2() {
//System.out.println("Generate level2: numRows = " +
//numRows);
//outputTtree();
//System.out.println("**** DONE ******");

	// Set next level flag
	nextLevelExists=false;

	// loop through top level (start at index 2 because cannot generate a
	// level from index 1 as there will be no proceeding attributes,
	// remember index 0 is unused.
	for (int index=2;index<startTtreeRef.length;index++) {
	    // If supported T-tree node (i.e. it exists)
	    if (startTtreeRef[index] != null) generateNextLevel(startTtreeRef,
	    				index,realloc2(null,(short) index));
	    }
	}



    protected void createTtreeTopLevel() {
	// Dimension and initialise top level of T-tree
	startTtreeRef = new FuzzyTtreeNode[numOneItemSets+1];
	for (int index=1;index<=numOneItemSets;index++)
	    			startTtreeRef[index] = new FuzzyTtreeNode();

        // Add support for each 1 itemset
	createTtreeTopLevel2();

	// Prune top level, setting any unsupported 1-itemsets to null
//System.out.println("createTtreeTopLevel: BEFORE PRUNING\nnumRows = " +
//numRows);
//outputTtree();
//System.out.println("**** DONE ******");
	pruneLevelN(startTtreeRef,1);
//System.out.println("createTtreeTopLevel: AFTER PRUNING");
//outputTtree();
//System.out.println("**** DONE ******");
	}              */

    /* ---------------------------- */
    /* ADD SUPPORT VALUES TO T-TREE */
    /* ---------------------------- */

    /* ADD SUPPORT VALUES TO T-TREE LEVEL N */
    /** Commences process of adding support to a given level in the T-tree
    (other than the top level).
    @param level the current level number (top level = 1). */

    protected void addSupportToTtreeLevelN(int level) {
//outputTtree();
//System.out.println("Weighted Apriori-T: addSupportToTtreeLevelN, level = " + level);
	// Loop through data set record by record
        for (int index=0;index<dataArray.length;index++) {
	    // Non null record (if initial data set has been reordered and
	    // pruned some records may be empty
	    if (dataArray[index] != null) addSupportToTtree(startTtreeRef,
	                      level,dataArray[index].length,dataArray[index],1.0);
	    }
	}

    /* ADD SUPPORT TO T-TREE FIND LEVEL */
    /** Adds support to a given level in the T-tree (other than the top level).
    <P> Operates in a recursive manner to first find the appropriate level in
    the T-tree before processing the required level (when found).
    @param linkRef the reference to the current sub-branch of T-tree (start at
    top of tree)
    @param level the level marker, set to the required level at the start and
    then decremented by 1 on each recursion.
    @param endIndex the index into the item set array at which processing
    should be stopped. This should be the index of the attribute in the item
    set that is the parent T-tree node of the current level. On start this
    will usually be the length of the input item set.
    @param itemSet the current itemset (record from data array) under
    consideration.
    @param supportSoFar the support value. */

    protected void addSupportToTtree(FuzzyTtreeNode[] linkRef, int level,
    			int endIndex, short[] itemSet, double supportSoFar) {
//System.out.print("In addSupportToTtree: level = " + level + ", endIndex = " +
//endIndex + ", itemSet = ");
//outputItemSet(itemSet);
//System.out.println(", supSoFar = " + supportSoFar);

	// At right level;
	if (level == 1) {
//System.out.println("At right level process item set upto end index (" + endIndex + ")");
	    // Step through itemSet
	    for (int index1=0;index1<endIndex;index1++) {
            short attNum = itemSet[index1];
//System.out.println("In loop: index1 = " + index1 + ", attribute = " + attNum);
		// If valid node update, i.e. a non null node
		if (linkRef[attNum] != null) {
//System.out.println("Attribute number not null reference");
		double support = supportSoFar*weightings[attNum];
//System.out.println("Old support value = " + linkRef[attNum].support);
		linkRef[attNum].support = linkRef[attNum].support+support;
//System.out.println("New support value = " + linkRef[attNum].support + "\n-------------------");
//outputTtree();
//System.out.print("+++++++++++++++++++");
		numUpdates++;
		}
//else System.out.println("Attribute number is null reference\n============");
	    }
	}

	// At wrong level
	else {
//System.out.println("At wrong level process item set child branches up to end index (" + endIndex + ")");
	    // Step through itemSet
	    for (int index=level-1;index<endIndex;index++) {
		short attNum      = itemSet[index];
//System.out.println("In loop: attNum = " + attNum);
		// If child branch step down branch exists
		if (linkRef[attNum]!=null && linkRef[attNum].childRef!=null) {
//System.out.println("In loop: child branch exists, weighting = " +  weightings[attNum]);
                    double support    = supportSoFar*weightings[attNum];
//System.out.println("New support value to be passed down = " + support + "\n-----------");
		    addSupportToTtree(linkRef[attNum].childRef,level-1,index,
                                                         itemSet,support);
		    }
else System.out.println("In loop: child branch does not exist\n=====");
		}
	    }
	}
    }