"use strict";

var ai = {};

ai.dirs = ["up", "down", "left", "right"];

// 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 bestDir;

    for (var i = 0; i < ai.dirs.length; i++) {

        var dir = ai.dirs[i];

        if (origBrd[dir](nextBrd)) {

            var score = nextBrd.score();

            if (maxScore < score) {

                bestDir = dir;

                maxScore = score;

            }

        }

    }

    return bestDir;

}

/* 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 bestDir;

    for (var i = 0; i < ai.dirs.length; i++) {

        var dir = ai.dirs[i];

        if (origBrd[dir](nextBrd)) {

            var max = nextBrd.score();

            if (maxMax < max) {

                maxMax = max;

                bestDir = dir;

            }

        }

    }

    return bestDir;

}

/* 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 simulation.

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

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 prevScore = -1, nextScore = -1;

    var maxScore = -1;

    var bestDir;

    for (var i = 0; i < ai.dirs.length; i++) {

        var dir = ai.dirs[i];

        if (origBrd[dir](nextBrd)) {

            nextScore = nextBrd.score();

            var score = this.bestScore(nextBrd);

            // console.log("dir: %o, prevScore: %o, nextScore: %o, maxScore: %o, score: %o", dir, prevScore, nextScore, maxScore, score);

            if (maxScore < score || (maxScore === score && prevScore < nextScore)) {

                prevScore = nextScore;

                maxScore = score;

                bestDir = dir;

            }

        }

    }

    return bestDir;

}

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 currScore = brd.score();

    var maxScore = currScore;

    var nextBrd = new this.brdEngine();

    for (var i = 0; i < ai.dirs.length; i++) {

        if (brd[ai.dirs[i]](nextBrd)) {

            var score = nextBrd.score();

            if (score > currScore)

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

        }

    }

    return maxScore;

}

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

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

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

// N level deep on score value + max value prefer corner,

// without random simulation.

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

/* cfg.cornerBonus - value to add if max value at corner. */

/* cfg.edgeBonus - value to add if max value at edge. */

ai.deepMaxScoreCorner = function(brdEngine, cfg) {

    this.brdEngine = brdEngine;

    this.cfg = cfg || {};

    this.cfg.cornerBonus = this.cfg.cornerBonus || 20000;

    this.cfg.edgeBonus = this.cfg.edgeBonus || 100;

    this.cfg.freeBonus = this.cfg.edgeBonus || 100;

}

ai.deepMaxScoreCorner.prototype.scoreCorner = function(brd) {

    var score = brd.score();

    var max = brd.max();

    if (brd.atCorner(max))

        score += this.cfg.cornerBonus;

    else if (brd.atEdge(max))

        score += this.cfg.edgeBonus;

    score += brd.free() * this.cfg.freeBonus;

    return score;

}

ai.deepMaxScoreCorner.prototype.scoreEdge = function(brd) {

    var score = brd.score();

    var max = brd.max();

    if (brd.atEdge(max))

        score += this.cfg.edgeBonus;

    score += brd.free() * this.cfg.freeBonus;

    return score;

}

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

    var origBrd = new this.brdEngine(brd);

    var nextBrd = new this.brdEngine();

    var prevScore = -1, nextScore = -1;

    var maxScore = -1;

    var bestDir;

    for (var i = 0; i < ai.dirs.length; i++) {

        var dir = ai.dirs[i];

        if (origBrd[dir](nextBrd)) {

            nextScore = this.scoreCorner(nextBrd);

            var score = this.bestScore(nextBrd);

            // console.log("dir: %o, prevScore: %o, nextScore: %o, maxScore: %o, score: %o", dir, prevScore, nextScore, maxScore, score);

            if (maxScore < score || (maxScore === score && prevScore < nextScore)) {

                prevScore = nextScore;

                maxScore = score;

                bestDir = dir;

            }

        }

    }

    return bestDir;

}

ai.deepMaxScoreCorner.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 currScore = this.scoreEdge(brd);

    var maxScore = currScore;

    var nextBrd = new this.brdEngine();

    for (var i = 0; i < ai.dirs.length; i++) {

        if (brd[ai.dirs[i]](nextBrd)) {

            var score = this.scoreEdge(nextBrd);

            if (score > currScore)

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

        }

    }

    return maxScore;

}

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

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