/**
 * Document ready
 */
$(document).ready(function() {

    // load scripts
    var getScript = jQuery.getScript;
    jQuery.getScript = function(resources, callback) {

        var // reference declaration & localization
            length = resources.length,
            handler = function() {
                counter++;
            },
            deferred = [],
            counter = 0;

        for (var idx = 0 ; idx < length; idx++) {
            deferred.push(
                getScript(resources[idx], handler)
            );
        }

        jQuery.when.apply(null, deferred).then(function() {
            callback && callback();
        });
    };
});

/**
 * Class Controller
 * @constructor
 */
function Controller() {

}

/**
 * Class Controller
 */
Controller.prototype = {

    // Generate level
    generateLevelType1: function (size) {

        // TODO:: take out this motherfucker iteration
        for (var i = 0; i < 1; i++) {

            // Variables
            var problem, level, actions, start, goal;
            var canStop = false;

            // Dictionary that's gonna hold the four solutions given for the four heuristics
            var solutions = {
                euclidean: [],
                euclideanMatches: [],
                manhattan: [],
                manhattanMatches: []
            };

            // Repeat until at least one of heuristics returns a solution
            do {

                // Generator objects
                var generator = new LevelGenerator(size);
                level = generator.getGeneratedLevel(true);

                // Get start and goal puzzles
                start = level[0];
                goal = level[1];

                // Euclidean distances heuristic
                console.time('A* Search using distancesHeuristic with euclidean');
                problem = new SearchProblem(start, goal, SearchAlgorithms.AStarSearch, Heuristic.euclideanDistancesHeuristic);
                problem.showResult();
                solutions.euclidean = problem.getSolution();
                console.timeEnd('A* Search using distancesHeuristic with euclidean');
                console.log("");

                if (solutions.euclidean.length > 0) {
                    canStop = true;
                }

                // Euclidean distances heuristic plus matches
                console.time('A* Search using distancesHeuristic with euclidean M');
                problem = new SearchProblem(start, goal, SearchAlgorithms.AStarSearch, Heuristic.euclideanDistancesHeuristicWithMatches);
                problem.showResult();
                solutions.euclideanMatches = problem.getSolution();
                console.timeEnd('A* Search using distancesHeuristic with euclidean M');
                console.log("");

                if (solutions.euclideanMatches.length > 0) {
                    canStop = true;
                }

                /*// Euclidean distances heuristic plus matches
                console.time('A* Search using distancesHeuristic with manhattan');
                problem = new SearchProblem(start, goal, SearchAlgorithms.AStarSearch, Heuristic.manhattanDistancesHeuristic);
                problem.showResult();
                solutions.manhattan = problem.getSolution();
                console.timeEnd('A* Search using distancesHeuristic with manhattan');
                console.log("");

                if (solutions.manhattan.length > 0) {
                    canStop = true;
                }

                // Euclidean distances heuristic plus matches
                console.time('A* Search using distancesHeuristic with manhattan M');
                problem = new SearchProblem(start, goal, SearchAlgorithms.AStarSearch, Heuristic.manhattanDistancesHeuristicWithMatches);
                problem.showResult();
                solutions.manhattanMatches = problem.getSolution();
                console.timeEnd('A* Search using distancesHeuristic with manhattan M');
                console.log("");

                if (solutions.manhattanMatches.length > 0) {
                    canStop = true;
                }*/

            } while (!canStop);
        }


        actions = generator.getBestSolution(solutions);
        console.log("Best Solution Size: " + actions.length);

        return new Level(start, goal, 1, actions, size);


        //return [level, actions];
    },

    // Generate level
    generateLevelType2: function(size) {

        // TODO:: take out this motherfucker iteration
        for (var i = 0; i < 1; i++) {

            // Variables
            var problem, level, actions, start;
            var canStop = false;

            // Dictionary that's gonna hold the four solutions given for the four heuristics
            var solutions = {
                clusteringHeuristicNormalized: [],
                clusteringHeuristic: [],
                clusteringHeuristicGraph: [],
                clusteringHeuristicGraphNormalized: []
            };

            // Repeat until at least one of heuristics returns a solution
            do {

                // Generator objects
                var generator = new LevelGenerator(size);
                level = generator.getGeneratedLevel(true);

                // Get start and goal puzzles
                start = level[0];

                // Euclidean distances heuristic
                console.time('A* Search Clustering N');
                problem = new SearchProblem(start, SearchAlgorithms.AStarSearch, Heuristic.clusteringHeuristicNormalized);
                problem.showResult();
                solutions.clusteringHeuristicNormalized = problem.getSolution();
                console.timeEnd('A* Search Clustering N');
                console.log("");

                if (solutions.clusteringHeuristicNormalized.length > 0) {
                    canStop = true;
                }

                if (!canStop && size !== "S76" && size !== "S66" && size !== "S65") {

                    // Euclidean distances heuristic plus matches
                    console.time('A* Search Clustering');
                    problem = new SearchProblem(start, SearchAlgorithms.AStarSearch, Heuristic.clusteringHeuristic);
                    problem.showResult();
                    solutions.clusteringHeuristic = problem.getSolution();
                    console.timeEnd('A* Search Clustering');
                    console.log("");

                    if (solutions.clusteringHeuristic.length > 0) {
                        canStop = true;
                    }
                }

                if (!canStop && Util.Globals.currentLevelDistribution.getBlockPercentage() > 40  && size !== "S76" && size !== "S66" && size !== "S65") {

                    // Euclidean distances heuristic plus matches
                    console.time('A* Search using graph');
                    problem = new SearchProblem(start, SearchAlgorithms.AStarSearch, Heuristic.clusteringHeuristicGraph);
                    problem.showResult();
                    solutions.clusteringHeuristicGraph = problem.getSolution();
                    console.timeEnd('A* Search using graph');
                    console.log("");
                }

                if (solutions.clusteringHeuristicGraph.length > 0) {
                    canStop = true;
                }


            } while (!canStop);
        }

        actions = generator.getBestSolution(solutions);
        console.log("Best Solution Size: " + actions.length);
        //return [level, actions];

        return new Level(start, [], 2, actions, size);
    }
};

/**
 * Prepare scripts to be loaded
 * @param levelType
 */
function getScripts(levelType) {
    var path = 'https://puzzle.pausanchezv.com/puzzle-x/assets/js/puzzle-' + levelType + '/';
    var scripts = [path + 'heuristic.js', path + 'puzzle-classes.js', path + 'search-algorithms.js', path + 'level-generator.js', path + 'animated-solver.js'];

    if (levelType === 1) {
        scripts.push(path + 'level-scrambler.js');
    }

    return scripts;
}


/**
 *
 * @param rows
 * @param cols
 */
function changeSquaresSize(rows, cols) {

    var squares = $("#left-state").find("> ul > li");

    if (rows > 6 || cols > 6) squares.addClass('size-7');
    if (rows > 5 || cols > 5) squares.addClass('size-6');
    else if (rows > 4 || cols > 4) squares.addClass('size-5');
    else if (rows > 3 || cols > 3) squares.addClass('size-4');
    else if (rows > 2 || cols > 2) squares.addClass('size-3');
    else squares.addClass('size-2');
}