"use strict";

var ai = {};

// Each strategy is a function that except current board position as 2d array and context from

// previous call to share state/precomputed values between calls.

////////////////////////////////////////////////////////////////

// Random AI.

////////////////////////////////////////////////////////////////

ai.random = function(brdEngine) {

    this.brdEngine = brdEngine;

}

ai.random.prototype.analyse = function(brd) {

    var origBrd = new this.brdEngine(brd);

    while (true) {

        var rnd = Math.floor(Math.random()*4);

        if (origBrd[["canUp", "canDown", "canLeft", "canRight"][rnd]]())

            return ["up", "down", "left", "right"][rnd];

    }

}

/* Mark that next board will be unrelated to previous, so any stored precompution can be cleared. */

ai.random.prototype.cleanup = function() { }

////////////////////////////////////////////////////////////////

// 1 level deep on max scores.

////////////////////////////////////////////////////////////////

ai.nextMaxScore = function(brdEngine) {

    this.brdEngine = brdEngine;

}

ai.nextMaxScore.prototype.analyse = function(brd) {

    var origBrd = new this.brdEngine(brd);

    var nextBrd = new this.brdEngine();

    var maxScore = -1;

    var action;

    if (origBrd.up(nextBrd)) {

        maxScore = nextBrd.score();

        action = "up";

    }

    if (origBrd.left(nextBrd)) {

        var score = nextBrd.score();

        if (maxScore < score) {

            action = "left";

            maxScore = score;

        }

    }

    if (origBrd.down(nextBrd)) {

        var score = nextBrd.score();

        if (maxScore < score) {

            action = "down";

            maxScore = score;

        }

    }

    if (origBrd.right(nextBrd)) {

        var score = nextBrd.score();

        if (maxScore < score) {

            action = "right";

            maxScore = score;

        }

    }

    return action;

}

/* Mark that next board will be unrelated to previous, so any stored precompution can be cleared. */

ai.nextMaxScore.prototype.cleanup = function() { }

////////////////////////////////////////////////////////////////

// 1 level deep on max value.

////////////////////////////////////////////////////////////////

ai.nextMaxValue = function(brdEngine) {

    this.brdEngine = brdEngine;

}

ai.nextMaxValue.prototype.analyse = function(brd) {

    var origBrd = new this.brdEngine(brd);

    var nextBrd = new this.brdEngine();

    var maxMax = -1;

    var action;

    if (origBrd.up(nextBrd)) {

        maxMax = nextBrd.max();

        action = "up";

    }

    if (origBrd.left(nextBrd)) {

        var max = nextBrd.score();

        if (maxMax < max) {

            action = "left";

            maxMax = max;

        }

    }

    if (origBrd.down(nextBrd)) {

        var max = nextBrd.max();

        if (maxMax < max) {

            action = "down";

            maxMax = max;

        }

    }

    if (origBrd.right(nextBrd)) {

        var max = nextBrd.max();

        if (maxMax < max) {

            action = "right";

            maxMax = max;

        }

    }

    return action;

}

/* Mark that next board will be unrelated to previous, so any stored precompution can be cleared. */

ai.nextMaxScore.prototype.cleanup = function() { }

////////////////////////////////////////////////////////////////

// N level deep on score value without random.

////////////////////////////////////////////////////////////////

ai.deepMaxScore = function(brdEngine) {

    this.brdEngine = brdEngine;

}

ai.deepMaxScore.prototype.analyse = function(brd) {

    var origBrd = new this.brdEngine(brd);

    var nextBrd = new this.brdEngine();

    var maxScore = -1;

    var action;

    if (origBrd.up(nextBrd)) {

        maxScore = this.bestScore(nextBrd);

        action = "up";

    }

    if (origBrd.left(nextBrd)) {

        var score = this.bestScore(nextBrd);

        if (maxScore < score) {

            action = "left";

            maxScore = score;

        }

    }

    if (origBrd.down(nextBrd)) {

        var score = this.bestScore(nextBrd);

        if (maxScore < score) {

            action = "down";

            maxScore = score;

        }

    }

    if (origBrd.right(nextBrd)) {

        var score = this.bestScore(nextBrd);

        if (maxScore < score) {

            action = "right";

            maxScore = score;

        }

    }

    return action;

}

ai.deepMaxScore.prototype.bestScore = function(brd, seenBrds) {

    if (seenBrds) {

        for (var i = 0; i < seenBrds.length; i++)

            if (brd.equals(seenBrds[i]))

                return 0;

    } else {

        seenBrds = [];

    }

    seenBrds.push(brd);

    var maxScore = brd.score();

    var nextBrd = new this.brdEngine();

    if (brd.up(nextBrd))

        maxScore = Math.max(maxScore, this.bestScore(nextBrd, seenBrds) - 1);

    if (brd.down(nextBrd))

        maxScore = Math.max(maxScore, this.bestScore(nextBrd, seenBrds) - 1);

    if (brd.left(nextBrd))

        maxScore = Math.max(maxScore, this.bestScore(nextBrd, seenBrds) - 1);

    if (brd.right(nextBrd))

        maxScore = Math.max(maxScore, this.bestScore(nextBrd, seenBrds) - 1);

    return maxScore;

}