source: main/trunk/model-sites-dev/von-sparql/textedit-regex/js/predictionScript.js@ 29739

/*jslint browser: true, regexp: true*/
/*global $, jQuery, alert, devel, console, diff_match_patch, FileReader, Blob, saveAs */


//Print debug output to console
var DEBUG = 1;

//Whether recording a new iteration of eventLoop
var recording = 0;
var recordingCircle;

//Create new DIFF object
//Used to detect changes made to text when demonstrating
var Diff_Constructor = diff_match_patch;
var diff = new Diff_Constructor();
//Used as input to DIFF object
var previousText;

//History of previous program states
//Used for UNDO functionality
var stateHistory = [];

//State object, contains the state of a program before any execution of a hypothesis
//textboxContent: Contents of the editing textbox at this state
//cursorLocation: Location of last action performed (so we know where to start from!)
function State(textboxContent, cursorLocation) {
    "use strict";
    this.textboxContent = textboxContent;
    this.cursorLocation = cursorLocation;
}

//Event trace currently being demonstrated
var eventTrace  = [];

//History of demonstrated traces
var demonstrationHistory = [];

//The location where an insert/delete was last performed when executing a hypothesis.
//This is used so we can tell from where to execute our hypothesis next
var previousLocation = 0;

//Contains contents of read file
var fileContents = "";
var fileName = "";

//  Enum for event types
var EventNames = ["CLICK", "SELECT", "INSERT", "DELETE"];
var EventType = {
    CLICK:  0,
    SELECT: 1,
    INSERT: 2,
    DELETE: 3
};
var Key = {
    BACKSPACE: 8,
    SPACE: 32,
    RETURN: 13
};
var PositionNames = ["START", "MID", "END"];
var Position = {
    START: 0,
    MID: 1,
    END: 2
};


//Returns true if value is a number
function isNumber(value) {
    "use strict";
    return typeof value === 'number' && isFinite(value);
}

//Types of character. Indexed so that they can be easily generalized by dividing by two.
var CharType = {
    //Heirachy shown below:
    //                                                          UPPERCASE
    //                                       LETTER         <
    //                                                          LOWERCASE
    //
    //                ALPHANUMERIC     <
    //
    //                                                          -------
    //                                       NUMBER         <
    //                                                          -------
    //
    //CHARACTER   <
    //
    //                                                          -------
    //                                       PUNCTUATION    <
    //                                                          -------
    //
    //              NON-ALPHANUMERIC   <
    //
    //                                                          NEWLINE
    //                                       WHITESPACE     <
    //                                                          SPACE

    CHARACTER:          1,
    ALPHANUMERIC:       2,
    NON_ALPHANUMERIC:   3,
    LETTER:             4,
    NUMBER:             5,
    PUNCTUATION:        6,
    WHITESPACE:         7,
    UPPERCASE:          8,
    LOWERCASE:          9,
    NEWLINE:            14,
    SPACE:              15
};

//Mappings from CharType enum to string representation
var CharNames = ["UNASSIGNED",
                 "CHARACTER",
                 "ALPHANUMERIC",
                 "NON-ALPHANUMERIC",
                 "LETTER",
                 "NUMBER",
                 "PUNCTUATION",
                 "WHITESPACE",
                 "UPPERCASE",
                 "LOWERCASE",
                 "UNASSIGNED",
                 "UNASSIGNED",
                 "UNASSIGNED",
                 "UNASSIGNED",
                 "NEWLINE",
                 "SPACE"];

//Mappings from CharType enum to regexp tokens
var CharTypeTokens = [
    "",                 //UNDEFINED
    ".",                //CHARACTER
    "[a-zA-Z\\d]",      //ALPHANUMERIC
    "[^a-zA-Z\\d]",     //NON-ALPHANUMERIC
    "[a-zA-Z]",         //LETTER
    "\\d",              //NUMBER
    "[^a-zA-Z\\d\\s]",  //PUNCTUATION
    "\\s",              //WHITESPACE
    "[A-Z]",            //UPPERCASE
    "[a-z]",            //LOWERCASE
    "",                 //UNDEFINED
    "",                 //UNDEFINED
    "",                 //UNDEFINED
    "",                 //UNDEFINED
    "\\n",              //NEWLINE
    "[^\\S\\n]"         //SPACE (not non-whitespace, not newline)
];

//  Defines an event that a user has demonstrated
//  CLICK   eventType, wordPreceeding, wordFollowing, positionAttributes, distanceFromPrevious
//  SELECT  eventType, wordPreceeding, wordFollowing, positionAttributes, distanceFromPrevious
//  INSERT  eventType, data
//  DELETE  eventType, data
function Event(eventType, prefix, suffix, wordPos, linePos, data) {
    "use strict";
    this.eventType = eventType;
    this.prefix     = prefix;
    this.suffix     = suffix;
    this.wordPos    = wordPos;
    this.linePos    = linePos;
    this.data       = data;
}

//Contains data about a pattern.
//symbols    = Array containing symbols to be represented    e.g. [CharType.CHARACTER, ",", " "]
//quantifiers   = Array containing quantifiers for the symbols   e.g. ["*", ".", "."]
function Pattern(symbols, quantifiers) {
    "use strict";
    this.symbols = symbols;
    this.quantifiers = quantifiers;
    this.condense = function () {
        var i,
            tmp;

        //for every character except the last, try to merge with the character following
        for (i = 0; i < this.symbols.length - 1; i += 1) {
            //If next symbol is the same as this current one
            if (this.symbols[i] === this.symbols[i + 1]) {
                //If not already quantified, do so
                if (this.quantifiers[i] !== "+") {
                    this.quantifiers[i] = "+";
                }
                //We can now delete the repeated symbol
                this.symbols.splice(i + 1, 1);
                this.quantifiers.splice(i + 1, 1);

                //Symbol after [i] has been condensed. Retry condensing from same location now that new character is following.
                i -= 1;
            }
        }
    };

    //Generalises the most specific symbol in the pattern.
    //Loop through symbols, and find those which are the most specific. Then generalise them.
    this.generalise = function () {
        var mostSpecific = -1,
            i;

        //Find index of most specific symbol
        for (i = 0; i < this.symbols.length; i += 1) {
            if ((mostSpecific === -1 || this.symbols[mostSpecific] < this.symbols[i])
                    && isNumber(this.symbols[i])) {
                mostSpecific = i;
            }
        }

        //Generalise most specific symbol

        //If symbol is as general as possible, generalise it's quantifier, else, divide by two to move up character heirachy
        if (this.symbols[mostSpecific] === 1) {
            console.log("Cannot make symbol any more general!");

            //Attempt to generalise quantifiers
            //Find the first "+" we come across, and make into a "*"
            for (i = 0; i < this.symbols.length; i += 1) {
                if (this.quantifiers[i] === "+") {
                    this.quantifiers[i] = "*";
                    return true;
                }
            }

            //If we couldn't generalise a quantifier, return false
            return false;
        } else {
            this.symbols[mostSpecific] = Math.floor(this.symbols[mostSpecific] / 2);
            return true;
        }
    };

    //Creates a equivalent regular expression from a Pattern object
    this.getRegexp = function () {
        var symbol,
            i,
            output = "";

        for (i = 0; i < this.symbols.length; i += 1) {
            //If is a number, append corresponding regexp token
            if (isNumber(this.symbols[i])) {
                output += CharTypeTokens[this.symbols[i]];
            } else if (this.symbols[i] === ")" || this.symbols[i] === "(") {
                output += "\\" + this.symbols[i];
            } else {
                output += this.symbols[i];
            }

            if (this.quantifiers[i] !== "1") {
                if ($("#cbLazy").is(":checked")) {
                    output += this.quantifiers[i] + "?";
                } else {
                    output += this.quantifiers[i];
                }
            }
        }
        return output;
    };

    //Prints a pattern's details to the console
    this.printPattern = function () {
        var i,
            tmp = "";
        for (i = 0; i < this.symbols.length; i += 1) {
            if (!isNumber(this.symbols[i])) {
                tmp += this.symbols[i] + ",";
            } else {
                tmp += CharNames[this.symbols[i]] + ",";
            }
        }
        //remove trailing comma from output
        tmp = tmp.substr(0, tmp.length - 1);

        console.log("Pattern: [" + tmp + "]");
        console.log("Quantifiers: [" + this.quantifiers + "]");
        console.log("Regular Expression: " + this.getRegexp());
    };
}

// Adds an event to current point in event trace
function addToTrace(event) {
    "use strict";
    var tail,
        replace;
    //If no previous events, add to trace and return
    if (eventTrace.length === 0) {
        eventTrace.push(event);
        return;
    }

    tail = eventTrace[eventTrace.length - 1];

    //If there were previous events, we need to see if we are able to merge this new event with the one directly before it
    //Click/select events can be replaced if performed concurrently
    if ((tail.eventType === EventType.CLICK && event.eventType === EventType.SELECT)
            || (tail.eventType === EventType.SELECT && event.eventType === EventType.CLICK)
            || (tail.eventType === EventType.SELECT && event.eventType === EventType.SELECT)
            || (tail.eventType === EventType.CLICK && event.eventType === EventType.CLICK)) {
        replace = true;
    }

    //If events are the same type, and are INSERT/DELETE events, merge their contents and return
    if ((tail.eventType === event.eventType)
            && ((tail.eventType === (EventType.INSERT))
            || tail.eventType === EventType.DELETE)) {
        if (tail.eventType === EventType.INSERT) {
            tail.data += event.data;
        } else {
            tail.data = event.data + tail.data;
        }
        return;
    }

    //Replace event, or add to end of trace
    if (replace) {
        eventTrace.pop();
        eventTrace.push(event);
    } else {
        //Else, just add a new event to the trace
        eventTrace.push(event);
    }
}

function printEventTrace() {
    "use strict";
    var i = 0;
    console.log("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
    console.log("////// EVENT TRACE //////");
    console.log(eventTrace.length + " EVENTS IN TOTAL");
    for (i = 0; i < eventTrace.length; i += 1) {
        console.log("Trace[" + i + "] >> " +  EventNames[eventTrace[i].eventType]);
        console.log(eventTrace[i]);
    }
}

// Returns index of the start of the line that the user has clicked
function getStartOfLine(element) {
    "use strict";
    return element.val().substr(0, element[0].selectionStart).lastIndexOf("\n") + 1;
}

// Returns position of the caret in line
// [start, end]
function getCaretPos(element) {
    "use strict";
    var offset = getStartOfLine(element);
    return [element[0].selectionStart - offset, element[0].selectionEnd - offset];
}

// Returns the word preceeding where the user has clicked
function getWordPreceeding(element, caretPos) {
    "use strict";
    var line,
        preceedingWord;

    //Select from start of line to where caret is placed
    line = element.val().substr(getStartOfLine(element), caretPos[0]);

    //Match regex
    preceedingWord = line.match(/(\S){0,12}\s*$/g);

    //Return either empty string or preceeding word
    return preceedingWord === null ? "" : preceedingWord;
}

// Returns the word following where the user has clicked
function getWordFollowing(element, caretPos) {
    "use strict";
    var lineStartIndex = element.val().substr(0, element[0].selectionStart).lastIndexOf("\n") + 1,
        line,
        followingWord;

    //Select from caret until end of line
    //If caretPos[0] !== caterPos[1], user selected text. hence use word after end of selection.
    if (caretPos[0] === caretPos[1]) {
        line = element.val().substr(lineStartIndex + caretPos[0]);
    } else {
        line = element.val().substr(lineStartIndex + caretPos[1]);
    }

    //Match Regex (any amount of spaces, then any amount of non-whitespace characters
    followingWord = line.match(/^[ \t\f]*(\S){0,12}/g);
    return followingWord === null ? "" : followingWord;
}

// Gets position in word that user has clicked
function getWordPosition(element, caretPos) {
    "use strict";
    var line,
        character;

    //if getWordPosition has been called when a word was selected (should return nothing)
    if (caretPos[0] !== caretPos[1]) {
        return null;
    }

    //Select entire line 
    line = element.val().substr(getStartOfLine(element));
    line = line.match(/.*/g);

    //Test if start of word
    character = line[0].charCodeAt(caretPos[0] - 1);
    //If Character before click is NaN (newline)
    if (isNaN(character) || character === Key.SPACE) {
        return Position.START;
    }

    //Test if end of word
    character = line[0].charCodeAt(caretPos[0]);
    if (isNaN(character) || character === Key.SPACE) {
        return Position.END;
    }

    //If not start or end, must be middle
    return Position.MID;
}

// Gets position in line that user has clicked
function getLinePosition(element, caretPos) {
    "use strict";
    var line,
        character;


    //if getWordPosition has been called when a word was selected (should return nothing)
    if (caretPos[0] !== caretPos[1]) {
        return null;
    }

    //Select entire line
    line = element.val().substr(getStartOfLine(element));
    line = line.match(/.*/g);

    //Test if start of word
    character = line[0].charCodeAt(caretPos[0] - 1);
    //If Character before click is NaN (newline)
    if (isNaN(character)) {
        return Position.START;
    }

    //Test if end of word
    character = line[0].charCodeAt(caretPos[0]);
    if (isNaN(character)) {
        return Position.END;
    }

    //If not start or end, must be middle
    return Position.MID;
}

//Returns Longest Common Subsequence of two strings.
//Dynamic programming approach using code similar to Java implementation at following url
//http://rosettacode.org/wiki/Longest_common_subsequence#Dynamic_Programming_2
//Biased toward returning subsequence that contain punctuation.

function lcsFAST(string1, string2) {
    "use strict";
    var lengths = new Array(string1.length + 1),
        i,
        j,
        tmp,
        strOut = "";

    //Create array of correct size
    for (i = 0; i < lengths.length; i += 1) {
        lengths[i] = new Array(string2.length + 1);
    }

    //Initialise first column/row of array to zero
    for (i = 0; i < string1.length + 1; i += 1) {
        lengths[i][0] = 0;
    }
    for (i = 0; i < string2.length + 1; i += 1) {
        lengths[0][i] = 0;
    }

    //Fill in array
    for (i = 0; i < string1.length; i += 1) {
        for (j = 0; j < string2.length; j += 1) {
            if (string1.charAt(i) === string2.charAt(j)) {
                tmp = string1.charCodeAt(i);
                if ((tmp >= 33 && tmp <= 47)
                        || (tmp >= 58 && tmp <= 64)
                        || (tmp >= 91 && tmp <= 96)
                        || (tmp >= 123 && tmp <= 126)) {
                    lengths[i + 1][j + 1] = lengths[i][j] + 2;
                } else {
                    lengths[i + 1][j + 1] = lengths[i][j] + 1;
                }
            } else {
                lengths[i + 1][j + 1] = Math.max(lengths[i + 1][j], lengths[i][j + 1]);
            }
        }
    }

    //Read back substring from array
    i = string1.length;
    j = string2.length;
    while (i !== 0 && j !== 0) {
        if (lengths[i][j] === lengths[i - 1][j]) {
            i -= 1;
        } else if (lengths[i][j] === lengths[i][j - 1]) {
            j -= 1;
        } else {
            strOut = string1.charAt(i - 1) + strOut;
            i -= 1;
            j -= 1;
        }
    }
    return strOut;
}

//Flashes the circle div a specified color and time, then it returns to the color previously used.
function flashCircle(color, time) {
    "use strict";
    var beforeColor = $("#divRecordingCircle").css("backgroundColor");

    $("#divRecordingCircle").animate({backgroundColor: color}, time, function () {
        $("#divRecordingCircle").animate({backgroundColor: beforeColor}, time);
    });
}

//Returns Pattern representing a input string
function generatePattern(str, lcs) {
    "use strict";
    var i = 0,
        j = 0,
        k = 0,
        tmp,
        mask = "",
        output = [],
        quantifiers = [];
    //For each position in string, try to apply longest common subsequence
    for (i = 0; i < str.length; i += 1) {
        for (j = 0; j < str.length - i; j += 1) {
            //if character in string matches lcs, move along LCS
            if (str.charAt(i + j) === lcs.charAt(k)) {
                mask += lcs.charAt(k);
                k += 1;
            } else {
                mask += "*";
            }
            //if whole subsequence has matched
            if (k === lcs.length) {
                for (k = 0; k < str.length - i - j - 1; k += 1) {
                    mask += "*";
                }
                k = lcs.length;
                break;
            }
        }
        if (k === lcs.length) {
            break;
        }
        mask = "";
    }

    console.log("'" + mask + "'");
    // mask now contains text along the lines of:
    // 2***22*** , for example, when str = 266622666, and LCS was 222.

    //Now we want to generalise the characters that were not a part of the LCS.
    //Loop through the characters in 'mask'
    //Copy characters that are in LCS to output array directly
    //When a '*'  is come across, look at this position in original string,
    //and find most specific class in character heirachy that matches

    for (i = 0; i < str.length; i += 1) {
        //literal from LCS, copy directly to output
        if (mask.charAt(i) !== "*") {
            output.push(mask.charAt(i));
        } else {
            //Come across a '*', get original character and find most general representation
            tmp = str.charCodeAt(i);

            //Check each leaf node on tree to see which applies to this character
            if (tmp >= 65 && tmp <= 90) {
                //If uppercase character
                output.push(CharType.UPPERCASE);

            } else if (tmp >= 97 && tmp <= 122) {
                //If lowercase character
                output.push(CharType.LOWERCASE);

            } else if (tmp >= 48 && tmp <= 57) {
                //If numeric
                output.push(CharType.NUMBER);

            } else if ((tmp >= 33 && tmp <= 47)
                       || (tmp >= 58 && tmp <= 64)
                       || (tmp >= 91 && tmp <= 96)
                       || (tmp >= 123 && tmp <= 126)) {
                //If punctuation
                output.push(CharType.PUNCTUATION);
            } else if ((tmp === 32)
                       || (tmp === 9)) {
                //If whitespace
                output.push(CharType.SPACE);
            } else {
                //NEWLINE? NOT SURE, DON'T DO THIS LOL
                output.push(CharType.NEWLINE);
            }
        }
    }

    //Construct a Pattern object to contain this pattern.
    //Quantifiers default to "1" because the pattern has not been condensed yet.
    for (i = 0; i < output.length; i += 1) {
        quantifiers.push("1");
    }
    return new Pattern(output, quantifiers);
}

//Gets a regular expression satisfying all input strings
function getGeneralRegExp(strings) {
    "use strict";
    var LCS = "",
        i,
        j,
        match,
        temp,
        tempRegexp,
        patterns = [];

    if (strings.length === 1) {
        return strings[0];
    }
    LCS = lcsFAST(strings[0], strings[1]);

    //Find LCS of all strings
    for (i = 2; i < strings.length; i += 1) {
        LCS = lcsFAST(LCS, strings[i]);
    }

    //Create a Pattern object for each string
    for (i = 0; i < strings.length; i += 1) {
        patterns.push(generatePattern(strings[i], LCS));
        patterns[i].condense();
        patterns[i].printPattern();
    }

    //Try to generalize each pattern to match with the others, stop when a general pattern is found

    for (i = 0; i < patterns.length; i += 1) {
        for (j = 0; j < strings.length; j += 1) {
            //Keep generalising pattern until it matches with this string
            while ((match = strings[j].match(new RegExp("^" + patterns[i].getRegexp() + "$"))) === null) {
                console.log("Generalising/condensing pattern " + i);
                tempRegexp = patterns[i].getRegexp();
                temp = patterns[i].generalise();

                //If cannot generalise any more
                if (temp !== true || tempRegexp === patterns[i].getRegexp()) {
                    console.log("Can't generalise pattern further to cover string");
                    break;
                }

                patterns[i].condense();
                patterns[i].printPattern();
            }

            //If we were unable to generalise this pattern enough to match string, this pattern is useless, try the next one
            if (match === null) {
                console.log("Can't generalise string further to cover both strings");
                break;
            } else if (j === strings.length - i - 1) {
                console.log("Found a pattern that covers all strings!");
                patterns[i].printPattern();
                return patterns[i].getRegexp();
            }
        }
    }
}

//returns true if event trace is consistent will all past traces
function validateEventTrace() {
    "use strict";
    var i,
        j;

    if (eventTrace.length === 0) {
        return false;
    }

    if (demonstrationHistory.length === 0) {
        return true;
    }



    for (i = 0; i < demonstrationHistory.length; i += 1) {
        if (demonstrationHistory[i].length !== eventTrace.length) {
            return false;
        }
        for (j = 0; j < demonstrationHistory[i].length; j += 1) {
            if (demonstrationHistory[i][j].eventType !== eventTrace[j].eventType) {
                return false;
            }
        }
    }
    return true;
}

function executeHypothesis(hypothesis, string, undoEnabled) {
    "use strict";
    var i,
        regex,
        regexString = "",
        result,
        location,
        temp,
        temp2;

    location = 0;
    previousLocation = 0;

    if (hypothesis === undefined
            || hypothesis.length === 0) {
        alert("You haven't taught me anything yet...");
        return -1;
    }

    //For each event in hypothesis
    for (i = 0; i < hypothesis.length; i += 1) {
        if (hypothesis[i].eventType === EventType.CLICK) {

            if (hypothesis[i].prefix !== undefined) {
                regexString += hypothesis[i].prefix;
            }

            if (hypothesis[i].suffix !== undefined) {
                regexString += hypothesis[i].suffix;
            }

            //Find next occurence of regex
            regex = new RegExp(regexString, "g");
            regex.lastIndex = previousLocation;
            //console.log("last regex match at index = " + regex.lastIndex);
            location = (string.substr(previousLocation, string.length - previousLocation).search(regex));

            //If no more matches occur
            if (location === -1) {
                return -1;
            }

            location += previousLocation;
            //console.log("next occurence of regex = " + location);
            result = regex.exec(string);

            result = result[0];

            if (undoEnabled === true) {
                //Back up our current state, for UNDO functionality
                stateHistory.push(new State($("#textMain").val(), location - 1));
            }

            //If a prefix has been identified,
            //move cursor position to the middle of the matching parts
            if (hypothesis[i].prefix !== null) {
                //Find out length of prefix match, and move along that far so we are in-between prefix and suffix
                regex = new RegExp(hypothesis[i].prefix);
                temp2 = regex.exec(result);
                location += temp2[0].length;

            } else if (hypothesis[i].suffix === null) {
                location = location + result.length;
            }

        } else if (hypothesis[i].eventType === EventType.DELETE) {
            //If a CLICK action has been performed earlier we want to delete the words leading up to 'location'
            if (location !== null) {
                //Get previous characters leading up to location
                temp = string.substr(0, location);
                //console.log("Text before: " + temp);
                temp2 = temp;
                temp = temp.replace(new RegExp(hypothesis[i].data + "$"), "");
                //console.log("Text after: " + temp);

                //Update text box
                string = (temp + string.substr(location, string.length));

                //Because we just deleted text, move the match location back some characters to compensate
                location -= temp2.length - temp.length;
            }
        } else if (hypothesis[i].eventType === EventType.INSERT) {
            if (location !== null) {
                //Insert text where next click would be
                string = (string.substr(0, location) + hypothesis[i].data + string.substr(location, string.length - location));
                //Because we just inserted text, move the match location along to compensate
                location += hypothesis[i].data.length;
            }
        }

        previousLocation = location;
    }

    return string;
}

function generaliseTrace() {
    "use strict";
    var hypothesisTrace = [],
        prefixes = [],
        suffixes = [],
        datas = [],
        wordPositions = [],
        linePositions = [],
        i,
        j;
    //Construct a new Event Trace.
    //To start, trace must contain same amount of events, of the same type,
    //and in the same order as those that the user has demonstrated.
    if (demonstrationHistory.length === 0) {
        return;
    }

    //Create empty events of same type that has been recorded
    for (i = 0; i < demonstrationHistory[0].length; i += 1) {
        hypothesisTrace.push(new Event(demonstrationHistory[0][i].eventType, null, null, null, null, null));
    }

    //For each hypothesis event, explore demonstrated events to generalise attributes
    for (i = 0; i < hypothesisTrace.length; i += 1) {

        //For each previously demonstrated instance of this event
        for (j = 0; j < demonstrationHistory.length; j += 1) {
            //If INSERT, collect these attributes
            if (hypothesisTrace[i].eventType === EventType.INSERT || hypothesisTrace[i].eventType === EventType.DELETE) {
                datas.push(demonstrationHistory[j][i].data);
            } else if (hypothesisTrace[i].eventType === EventType.CLICK || hypothesisTrace[i].eventType === EventType.SELECT) {
                //If CLICK, collect these attributes
                prefixes.push(demonstrationHistory[j][i].prefix);
                suffixes.push(demonstrationHistory[j][i].suffix);
                wordPositions.push(demonstrationHistory[j][i].wordPos);
                linePositions.push(demonstrationHistory[j][i].linePos);
            }
        }

        //Once, for this particular action, all demonstration data has been collected, generalise!
        //console.log(datas);
        //console.log(prefixes);
        //console.log(suffixes);

        if (datas.length !== 0) {
            hypothesisTrace[i].data = getGeneralRegExp(datas);
        }

        if (prefixes.length !== 0) {
            hypothesisTrace[i].prefix = getGeneralRegExp(prefixes);
        }

        if (suffixes.length !== 0) {
            hypothesisTrace[i].suffix = getGeneralRegExp(suffixes);
        }

        //Loop through word positions. If all are the same, use this in hypothesis.
        for (j = 0; j < wordPositions.length; j += 1) {
            //If different to the first wordpos, we don't use this property!
            if (wordPositions[j] !==  wordPositions[0]) {
                hypothesisTrace[i].wordPos = null;
                break;
            } else {
                //If the same, use it!
                hypothesisTrace[i].wordPos = wordPositions[i];
            }
        }
        //Loop through line positions. If all are the same, use this in hypothesis.
        for (j = 0; j < linePositions.length; j += 1) {
            //If different to the first line position, we don't use this property!
            if (linePositions[j] !==  linePositions[0]) {
                hypothesisTrace[i].linePos = null;
                break;
            } else {
                //If the same, use it!
                hypothesisTrace[i].linePos = linePositions[i];
            }
        }


        datas = [];
        suffixes = [];
        prefixes = [];
        wordPositions = [];
        linePositions = [];
    }

    console.log("");
    console.log("Generalised trace:");
    console.log(hypothesisTrace);
    return hypothesisTrace;
}
//Prints out details about an event
function debug(event) {
    "use strict";
    if (DEBUG === 1) {
        console.log(event);
    }
}

function handleFileSelect(event) {
    "use strict";
    var files = event.target.files,
        reader = new FileReader();

    reader.onload = function (event) {
        // NOTE: event.target point to FileReader
        if (files[0].size > 100000) {
            alert("LARGE FILE WARNING\nMay take a very long time to process...\nSuggested maximum size: 100KB");
        }
        var contents = event.target.result;
        fileName = files[0].name;
        fileContents = contents;
        //////
    };

    reader.readAsText(files[0]);
}

//Sets up onclick events, etc on page
window.onload = function setupPage() {
    "use strict";
    var hypothesis,
        i,
        str = "";

    document.getElementById("fileSelector").addEventListener('change', handleFileSelect, false);

    $("#btnDemonstrate").click(function () {
        if (!recording) {

            recording = true;

            //Set previousText to be the starting contents of the textbox
            previousText = $("#textMain").val();

            $("#divRecordingCircle").animate({backgroundColor: "#FF758F"}, 300);

            $("#btnDemonstrate").text("End Demonstration");
        } else {

            recording = false;
            clearInterval(recordingCircle);
            $("#btnDemonstrate").text("Demonstrate");

            $("#divRecordingCircle").css("backgroundColor", "#FFE7E3");

            //Add demonstration to demonstration history
            if (validateEventTrace()) {

                flashCircle("green", 300);
                demonstrationHistory.push(eventTrace);
                previousLocation = 0;
            } else {

                flashCircle("0E0604", 300);
            }

            //clear event trace
            eventTrace = [];

            hypothesis = generaliseTrace();
            str = "";
            str += "Demonstration count: " + demonstrationHistory.length + "\n";
            for (i = 0; i < hypothesis.length; i += 1) {
                str += "\nEvent Type: " + EventNames[hypothesis[i].eventType] + "\n";
                if (hypothesis[i].prefix !== null) {
                    str += "Prefix: " + hypothesis[i].prefix + "\n";
                }
                if (hypothesis[i].suffix !== null) {
                    str += "Suffix: " + hypothesis[i].suffix + "\n";
                }
                if (hypothesis[i].data !== null) {
                    str += "Data: " + hypothesis[i].data + "\n";
                }
            }

            $("#divOutput").text(str).wrap('<pre />');
        }
    });

    $("#cbLazy").click(function () {
        var str = "";
        hypothesis = generaliseTrace();

        if (hypothesis === undefined) {
            return;
        }

        str += "Demonstration count: " + demonstrationHistory.length + "\n";
        for (i = 0; i < hypothesis.length; i += 1) {
            str += "\nEvent Type: " + EventNames[hypothesis[i].eventType] + "\n";
            if (hypothesis[i].prefix !== null) {
                str += "Prefix: " + hypothesis[i].prefix + "\n";
            }
            if (hypothesis[i].suffix !== null) {
                str += "Suffix: " + hypothesis[i].suffix + "\n";
            }
            if (hypothesis[i].data !== null) {
                str += "Data: " + hypothesis[i].data + "\n";
            }
        }

        $("#divOutput").text(str).wrap('<pre />');
    });
    $("#btnDoSomething").click(function () {
        var hypothesisTrace,
            text,
            temp;
        console.log(demonstrationHistory);

        hypothesisTrace = generaliseTrace();

        //Look through hypothesised trace, and execute!
        temp = executeHypothesis(hypothesisTrace, $("#textMain").val(), true);

        if (temp !== -1) {
            $("#textMain").val(temp);
            $("#btnUndo").removeAttr("disabled");
        }

    });

    $("#btnTest").click(function () {

        console.log("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
        var text1 = $("#textTest1").val(),
            text2 = $("#textTest2").val(),
            text3 = $("#textTest3").val(),
            temp;

        temp = getGeneralRegExp([text1, text2, text3]);
        $("#divOutput").text(temp);
    });

    $("#btnUndo").click(function () {

        if (stateHistory.length === 0) {
            alert("Cannot go any further back than here");
            return;
        }

        $("#textMain").val(stateHistory[stateHistory.length - 1].textboxContent);
        previousLocation = stateHistory[stateHistory.length - 1].cursorLocation;
        stateHistory.pop();
        if (stateHistory.length === 0) {
            $("#btnUndo").attr("disabled", "disabled");
            previousLocation = 0;
        }
    });

    $("#btnClear").click(function () {
        demonstrationHistory = [];
        previousLocation = 0;
        stateHistory = [];
        $("#divOutput").text("");
        alert("Cleared demonstration history");
    });

    $("#btnExecuteFile").click(function () {
        var hypothesisTrace,
            output,
            blob;

        if (fileContents === "") {
            alert("Select a file first!");
            return;
        }

        hypothesisTrace = generaliseTrace();

        while ((output = executeHypothesis(hypothesisTrace, fileContents, false)) !== -1) {
            fileContents = output;
        }

        blob = new Blob([fileContents], {type: "text/plain;charset=utf-8"});
        saveAs(blob, fileName + "-modified.txt");
    });

    //Mouse clicked on text box
    $("#textMain").click(function () {
        var event,
            pos = getCaretPos($(this));

        if (!recording) {
            return;
        }

        //When clicked, it is assumed that the user has finished an edit event, so current state of text is saved
        previousText = $("#textMain").val();

        console.log("New Event:");
        if (pos[0] === pos[1]) {
            console.log("   Type: CLICK");
            event = new Event(EventType.CLICK,
                              getWordPreceeding($(this), pos)[0],
                              getWordFollowing($(this), pos)[0],
                              getWordPosition($(this), pos),
                              getLinePosition($(this), pos),
                              null
                             );

        } else {
            console.log("   Type: SELECT");
            event = new Event(EventType.SELECT,
                              getWordPreceeding($(this), pos)[0],
                              getWordFollowing($(this), pos)[0],
                              getWordPosition($(this), pos),
                              getLinePosition($(this), pos),
                              null
                             );
        }

        addToTrace(event);
        debug(event);
    });

    //Key typed into textbox
    $("#textMain").keyup(function (e) {
        var event,
            //lineNumber = $(this)[0].value.substr(0, $(this)[0].selectionStart).split("\n").length,
            newText = $("#textMain").val(),
            i = 0,
            changes,
            diffText,
            eventType;

        if (!recording) {
            return;
        }

        changes = diff.diff_main(previousText, newText);

        for (i = 0; i < changes.length; i += 1) {
            if (changes[i][0] === 1) {
                diffText = changes[i][1];
                eventType = EventType.INSERT;
                break;
            }
            if (changes[i][0] === -1) {
                diffText = changes[i][1];
                eventType = EventType.DELETE;
                break;
            }
        }

        if (eventType === undefined) {
            return;
        }
        event = new Event(eventType, null, null, null, null, diffText);
        addToTrace(event);
        debug(event);
        previousText = $("#textMain").val();
    });
};