(function() {
"use strict";

var AIREADY   = 0;
var AISUCCESS = 1;
var AIFAILURE = 2;
var AIRUNNING = 3;
var AIERROR   = 4;
var _AINEXTID = 1;

// BASE BEHAVIOR TREE =========================================================
var AIBehaviorTree = function() { this.initialize(); }

AIBehaviorTree.prototype.root = null;

AIBehaviorTree.prototype.initialize = function() {

}

AIBehaviorTree.prototype.interrupt = function(target, fdelta) {
    target.memory.tree.interrupted = true;
}

AIBehaviorTree.prototype.update = function(target, fdelta) {
    var status = AIERROR;

    target.memory.tree.executionCount++;

    if (this.root) {
        status = this.root._update(target, fdelta);
    }

    target.memory.tree.interrupted = false;

    return status;
}
// ============================================================================


// BASE NODES =================================================================
var AIBaseNode = function() { this.initialize(); }

AIBaseNode.prototype.initialize = function() {}
AIBaseNode.prototype._update = function(target, fdelta) {
    target.memory.tree.lastNode = this;
    var status = this.update(target, fdelta);
    // var text = ['READY', 'SUCCESS', 'FAILURE', 'RUNNING', 'ERROR'][status]
    // if (target.memory.tree.executionCount < 10) {
    //     console.log("["+target.name+"] "+this.name+": " + text);
    // }

    return status
}
AIBaseNode.prototype.setNodeVariable = function(target, key, value) {
    if (target.memory.tree.node[this.id] === undefined) {
        target.memory.tree.node[this.id] = {};
    }

    target.memory.tree.node[this.id][key] = value;
}

AIBaseNode.prototype.getNodeVariable = function(target, key) {
    if (target.memory.tree.node[this.id] === undefined) {
        target.memory.tree.node[this.id] = {};
    }

    return target.memory.tree.node[this.id][key];
}

// Internal Node
var AIInternalNode = function() { this.initialize(arguments); }
AIInternalNode.prototype = new AIBaseNode();
AIInternalNode.prototype.id = null;
AIInternalNode.prototype.name = 'untitled';
AIInternalNode.prototype.parent = null;
AIInternalNode.prototype.children = null;
AIInternalNode.prototype.isLeaf = false;

AIInternalNode.prototype.initialize = function(args) {
    this.id = _AINEXTID++;
    this.children = [];

    for (var i=0; i<args.length; i++) {
        this.addChild(args[i]);
    }
}

AIInternalNode.prototype.update = function(target, fdelta) {

}

AIInternalNode.prototype.start = function() {
    this.runningNode = null;
}

AIInternalNode.prototype.end = function() {
    this.runningNode = null;
}

AIInternalNode.prototype.addChild = function(node) {
    this.children.push(node);
    node.parent = this;
}

AIInternalNode.prototype.removeChild = function(node) {
    var index = this.children.indexOf(node);
    if (index >= 0) {
        this.children.splice(index, 1);
        node.parent = null;
    }
}

// Leaf Node
var AILeafNode = function() { this.initialize(arguments); }
AILeafNode.prototype = new AIBaseNode();
AILeafNode.prototype.id = null;
AILeafNode.prototype.name = 'untitled';
AILeafNode.prototype.btree = null;
AILeafNode.prototype.parent = null;
AILeafNode.prototype.isLeaf = true;

AILeafNode.prototype.initialize = function() {
    this.id = _AINEXTID++;
}

AILeafNode.prototype.update = function(target, fdelta) {

}
// ============================================================================


// INTERNAL INSTANCES =========================================================
// Sequence
var AISequence = function() { this.initialize(arguments); }

AISequence.prototype = new AIInternalNode();
AISequence.prototype.name = 'Sequence';

AISequence.prototype.update = function(target, fdelta) {
    for (var i=0; i<this.children.length; i++) {
        var status = this.children[i]._update(target, fdelta);

        if (status == AIRUNNING) {
            return status;
        } else if (status == AISUCCESS) {
            continue;
        } else {
            return status;
        }
    }

    return AISUCCESS;
}

// Priority
var AIPriority = function() { this.initialize(arguments); }

AIPriority.prototype = new AIInternalNode();
AIPriority.prototype.name = 'Priority';

AIPriority.prototype.update = function(target, fdelta) {
    for (var i=0; i<this.children.length; i++) {
        var status = this.children[i]._update(target, fdelta);

        if (status == AIRUNNING) {
            return status;
        } else if (status == AIFAILURE) {
            continue;
        } else {
            return status;
        }
    }

    return AIFAILURE;
}

// Mem Sequence (*)
var AIMemSequence = function() { this.initialize(arguments); }

AIMemSequence.prototype = new AIInternalNode();
AIMemSequence.prototype.name = 'MemSequence';

AIMemSequence.prototype.setRunningNode = function(target, i) {
    var c = target.memory.tree.executionCount;
    target.memory.tree.node[this.id] = [i, c];
}

AIMemSequence.prototype.getRunningNode = function(target, fdelta) {
    var c = target.memory.tree.executionCount;
    var r = target.memory.tree.node[this.id]

    if (r === undefined) {
        return 0;
    }

    if (c != (r[1] + 1)) {
        // it means that in the last tick, another node was activated.
        return 0;
    }
    
    return r[0];
}

AIMemSequence.prototype.update = function(target, fdelta) {
    var idx = this.getRunningNode(target);

    for (var i=idx; i<this.children.length; i++) {
        var status = this.children[i]._update(target, fdelta);

        if (status == AIRUNNING) {
            this.setRunningNode(target, i);
            return status;
        } else if (status == AISUCCESS) {
            continue;
        } else {
            target.memory.tree.node[this.id] = undefined;
            return status;
        }
    }

    target.memory.tree.node[this.id] = undefined;
    return AISUCCESS;
}

// Mem Priority (*)
var AIMemPriority = function() { this.initialize(arguments); }

AIMemPriority.prototype = new AIInternalNode();
AIMemPriority.prototype.name = 'MemPriority';

AIMemPriority.prototype.setRunningNode = function(target, i) {
    var c = target.memory.tree.executionCount;
    target.memory.tree.node[this.id] = [i, c];
}

AIMemPriority.prototype.getRunningNode = function(target, fdelta) {
    var c = target.memory.tree.executionCount;
    var r = target.memory.tree.node[this.id]

    if (r === undefined) {
        return 0;
    }

    if (c != (r[1] + 1)) {
        // it means that in the last tick, another node was activated.
        return 0;
    }
    
    return r[0];
}

AIMemPriority.prototype.update = function(target, fdelta) {
    var idx = this.getRunningNode(target);

    for (var i=idx; i<this.children.length; i++) {
        var status = this.children[i]._update(target, fdelta);

        if (status == AIRUNNING) {
            this.setRunningNode(target, i);
            return status;
        } else if (status == AIFAILURE) {
            continue;
        } else {
            target.memory.tree.node[this.id] = undefined;
            return status;
        }
    }

    target.memory.tree.node[this.id] = undefined;
    return AIFAILURE;
}

// Mem Random (*)
var AIMemRandom = function() { this.initialize(arguments); }

AIMemRandom.prototype = new AIInternalNode();
AIMemRandom.prototype.name = 'MemRandom';

AIMemRandom.prototype.setRunningNode = function(target, i) {
    var c = target.memory.tree.executionCount;
    target.memory.tree.node[this.id] = [i, c];
}

AIMemRandom.prototype.getRunningNode = function(target, fdelta) {
    var c = target.memory.tree.executionCount;
    var r = target.memory.tree.node[this.id]

    if (r === undefined) {
        return RANDINT(0, this.children.length);
    }

    if (c != (r[1] + 1)) {
        // it means that in the last tick, another node was activated.
        return RANDINT(0, this.children.length);
    }
    
    return r[0];
}

AIMemRandom.prototype.update = function(target, fdelta) {
    var idx = this.getRunningNode(target);
    // console.log(idx);

    for (var i=idx; i<this.children.length; i++) {
        var status = this.children[i]._update(target, fdelta);

        if (status == AIRUNNING) {
            this.setRunningNode(target, i);
            return status;
        } else if (status == AIFAILURE) {
            continue;
        } else {
            target.memory.tree.node[this.id] = undefined;
            return status;
        }
    }

    target.memory.tree.node[this.id] = undefined;
    return AIFAILURE;
}
// ============================================================================

// DECORATORS =================================================================
// Base
var AIDecorator = function(child) { this.initialize(child); }
AIDecorator.prototype = new AIBaseNode();
AIDecorator.prototype.name = null;
AIDecorator.prototype.parent = null;
AIDecorator.prototype.child = null;
AIDecorator.prototype.isLeaf = false;

AIDecorator.prototype.initialize = function(child) {
    this.id = _AINEXTID++;
    this.name = 'Decorator';
    this.child = child;
}

AIDecorator.prototype.update = function(target, fdelta) {

}

AIDecorator.prototype.addChild = function(node) {
    this.child = node;
    node.parent = this;
}

AIDecorator.prototype.removeChild = function(node) {
    if (this.child) {
        this.child.parent = null;
        this.child = null;
    }
}


// ============================================================================

window.AIREADY        = AIREADY;
window.AISUCCESS      = AISUCCESS;
window.AIFAILURE      = AIFAILURE;
window.AIRUNNING      = AIRUNNING;
window.AIERROR        = AIERROR;

window.AIBehaviorTree = AIBehaviorTree;

window.AIBaseNode     = AIBaseNode;
window.AIInternalNode = AIInternalNode;
window.AILeafNode     = AILeafNode;
window.AIDecorator    = AIDecorator;

window.AISequence     = AISequence;
window.AIPriority     = AIPriority;
window.AIMemSequence  = AIMemSequence;
window.AIMemPriority  = AIMemPriority;
window.AIMemRandom    = AIMemRandom;
}());