window.states = {};

window.cstats = {
    numGames: {},
    numCompetitors: {},
    maxDeviation: {}
};

window.yAxisMax = [0, 0];

function formatNum(n) {
    return n.toFixed(2).replace(/(\d)(?=(\d{3})+\.)/g, '$1,');
}

function uniq(a) {
    var prims = {"boolean":{}, "number":{}, "string":{}}, objs = [];

    return a.filter(function(item) {
        var type = typeof item;
        if(type in prims)
            return prims[type].hasOwnProperty(item) ? false : (prims[type][item] = true);
        else
            return objs.indexOf(item) >= 0 ? false : objs.push(item);
    });
}

function options(start, end, step) {
    var indVars = [];
    for(var i=end; i>start; i-=step) {
        indVars.push(i);
    }
    indVars.push(start);
    indVars = uniq(indVars.reverse());
    return indVars;
}

function nextChart() {
    var minChart = false;
    var minFinished = 100000;
    for(var chart in window.states) {
        if(window.states.hasOwnProperty(chart)) {
            if(window.states[chart]['finished'].length < minFinished
                && window.states[chart]['queue'].length > 0) {
                minFinished = window.states[chart]['finished'].length;
                minChart = chart;
            }
        }
    }
    return minChart;
}

function finish(chart, indVar, suffix) {
    if(window.cstats[chart][indVar][3] < window.numCompetitions) {
        setTimeout(function() {
            finish(chart, indVar, suffix);
        }, 1000);
    } else {
        var indVar = window.states[chart]['running'].shift();
        window.states[chart]['finished'].push(indVar);
        updateGraph(chart, indVar, suffix);
        recursiveTraverseQueues(suffix);
    }
}

function dequeue(chart) {
    var indVar = window.states[chart]['queue'].shift();
    window.states[chart]['running'].push(indVar);
    return indVar;
}

function nextInQueue(chart) {
    if(window.states[chart]['queue'].length > 0) {
        return window.states[chart]['queue'][0];
    } else {
        return false;
    }
}

function setupCharts(suffix) {
    var chartOpts = {
        chart: {
            backgroundColor: null
        },
        xAxis: [{
            title: {
                text: '',
            },
            //allowDecimals: false,
            //lineWidth: 0,
            //lineColor: 'transparent',
            //gridLineColor: 'transparent',
            //gridLineWidth: 0,
            //minorGridLineWidth: 0,
            //minorGridLineColor: 'transparent',
            //minorTickLength: 0,
            //tickLength: 0,
            //plotLines: [{
            //    value: 0,
            //    width: 0,
            //    color: '#808080'
            //}]
        }],
        yAxis: [{
            //lineWidth: 0,
            //lineColor: 'transparent',
            //gridLineColor: 'transparent',
            //gridLineWidth: 0,
            //minorGridLineWidth: 0,
            //minorGridLineColor: 'transparent',
            //minorTickLength: 0,
            //tickLength: 0,
            min: 0,
            max: 1,
            maxPadding: 0,
            minPadding: 0,
            title: {
                text: 'Number of Competitions'
            },
            labels: {
                enabled: true
            },
            //plotLines: [{
            //    value: 0,
            //    width: 0,
            //    color: '#808080'
            //}]
        }, {
            min: 0,
            max: 25,
            maxPadding: 0,
            minPadding: 0,
            opposite: true,
            title: {
                text: 'Average Rank Percentile'
            },
            labels: {
                enabled: true
            },
        }],
        plotOptions: {
            series: {
                stickyTracking: false
            },
            line: {
                marker: {
                    radius: 3,
                    symbol: 'circle'
                }
            }
        },
        legend: {
            enabled: false
        },
        credits: {
            enabled: false
        },
        exporting: {
            enabled: false
        },
        series: [{
            name: 'Number of First Place Finishes',
            yAxis: 0,
            xAxis: 0,
            data: [],
            color: '#00b712',
        },{
            name: 'Number of Last Place Finishes',
            yAxis: 0,
            xAxis: 0,
            data: [],
            color: '#a50008',
        },{
            name: 'Average Percentile',
            yAxis: 1,
            xAxis: 0,
            data: [],
            color: '#ffaa00',
        }],
        title: {
            style: {
                fontSize: '14px'
            }
        }
    };

    var ngOpts = JSON.parse(JSON.stringify(chartOpts));
    ngOpts['title']['text'] = 'Number of Games per Competition';
    ngOpts['xAxis'][0]['title']['text'] = 'Number of Games per Competition';
    ngOpts['yAxis'][1]['labels']['enabled'] = false;
    ngOpts['yAxis'][1]['title']['text'] = null;
    $('#ng-results-container-' + suffix).highcharts(ngOpts);

    var ncOpts = JSON.parse(JSON.stringify(chartOpts));
    ncOpts['title']['text'] = 'Number of Competitors';
    ncOpts['xAxis'][0]['title']['text'] = 'Number of Competitors';
    ncOpts['yAxis'][0]['labels']['enabled'] = false;
    ncOpts['yAxis'][1]['labels']['enabled'] = false;
    ncOpts['yAxis'][0]['title']['text'] = null;
    ncOpts['yAxis'][1]['title']['text'] = null;
    $('#nc-results-container-' + suffix).highcharts(ncOpts);

    var mdOpts = JSON.parse(JSON.stringify(chartOpts));
    mdOpts['title']['text'] = 'Max Deviation (Uniform)';
    mdOpts['xAxis'][0]['title']['text'] = 'Max Deviation (Uniform)';
    mdOpts['yAxis'][0]['labels']['enabled'] = false;
    mdOpts['yAxis'][0]['title']['text'] = null;
    $('#md-results-container-' + suffix).highcharts(mdOpts);
}

function nothingRunning() {
    for(var chart in window.states) {
        if(window.states.hasOwnProperty(chart)) {
            if(window.states[chart]['running'].length > 0) {
                return false;
            }
        }
    }
    return true;
}

function singleCompetition(chart, numGames, numCompetitors, maxDeviation, gameProbs, numLeft) {
    var competitionStats = [0, 0, 0];

    var outcomes = [];
    for(var j=0; j<numGames; j++) {
        var outcome = Math.random() < gameProbs[j] ? 1 : 0;
        outcomes.push(outcome);
    }

    var trutherScore = 0;
    for(var j=0; j<numGames; j++) {
        var guess = Math.min(0.99, Math.max(0.01, gameProbs[j]));
        trutherScore += (-1 * outcomes[j] * Math.log(guess));
        trutherScore += (-1 * (1-outcomes[j]) * Math.log(1-guess));
    }
    trutherScore /= numGames;

    var competitorScores = [trutherScore];

    for(var j=1; j<numCompetitors; j++) {
        var score = 0;
        for(var k=0; k<numGames; k++) {
            var deviation = (Math.random() * maxDeviation * 2) - (maxDeviation / 2);
            var guess = Math.min(0.99, Math.max(0.01, deviation + gameProbs[k]));
            score += (-1 * outcomes[k] * Math.log(guess));
            score += (-1 * (1-outcomes[k]) * Math.log(1-guess));
        }
        score /= numGames;
        competitorScores.push(score);
    }

    var rank = 0;
    for(var j=1; j<numCompetitors; j++) {
        if(trutherScore > competitorScores[j]) {
            rank++;
        }
    }

    competitionStats[0] = rank == 1 ? 1 : 0;
    competitionStats[1] = rank == numCompetitors ? 1 : 0;
    competitionStats[2] = (numCompetitors - rank) / numCompetitors;

    var indVar;
    switch(chart) {
        case 'numGames':
            indVar = numGames;
            break;
        case 'numCompetitors':
            indVar = numCompetitors;
            break;
        case 'maxDeviation':
            indVar = maxDeviation;
            break;
    }

    window.cstats[chart][indVar][0] += competitionStats[0];
    window.cstats[chart][indVar][1] += competitionStats[1];
    window.cstats[chart][indVar][2] += competitionStats[2];
    window.cstats[chart][indVar][3]++;

    if(numLeft - 1 > 0) {
        setTimeout(function() {
            singleCompetition(chart, numGames, numCompetitors, maxDeviation, gameProbs, numLeft-1);
        }, 1);
    }
}

function getGameProbs(numGames) {
    var gameProbs = [];
    for(var i=0; i<numGames; i++) {
        var prob = Math.random();
        gameProbs.push(prob);
    }
    return gameProbs;
}

function simulation(chart, indVar, suffix) {
    var numGames       = chart === 'numGames'       ? indVar : window.numGames;
    var numCompetitors = chart === 'numCompetitors' ? indVar : window.numCompetitors;
    var maxDeviation   = chart === 'maxDeviation'   ? indVar : window.maxDeviation;

    gameProbs = getGameProbs(numGames);

    singleCompetition(chart, numGames, numCompetitors, maxDeviation, gameProbs, window.numCompetitions);

    finish(chart, indVar, suffix);
}

function updateExtremes(numWins, numLosses, avgPercentile, suffix) {
    window.yAxisMax[0] = Math.max(window.yAxisMax[0], numWins, numLosses);
    window.yAxisMax[1] = Math.max(window.yAxisMax[1], avgPercentile);

    var ngGraph = $('#ng-results-container-' + suffix).highcharts();
    var ncGraph = $('#nc-results-container-' + suffix).highcharts();
    var mdGraph = $('#md-results-container-' + suffix).highcharts();

    ngGraph.yAxis[0].update({ max: window.yAxisMax[0] });
    ngGraph.yAxis[1].update({ max: window.yAxisMax[1] });
    ncGraph.yAxis[0].update({ max: window.yAxisMax[0] });
    ncGraph.yAxis[1].update({ max: window.yAxisMax[1] });
    mdGraph.yAxis[0].update({ max: window.yAxisMax[0] });
    mdGraph.yAxis[1].update({ max: window.yAxisMax[1] });

    ngGraph.redraw();
    ncGraph.redraw();
    mdGraph.redraw();
}

function updateGraph(chart, indVar, suffix) {
    switch(chart) {
        case 'numGames':
            prefix = 'ng';
            break;
        case 'numCompetitors':
            prefix = 'nc';
            break;
        case 'maxDeviation':
            prefix = 'md';
            break;
    }

    var numWins   = window.cstats[chart][indVar][0];
    var numLosses = window.cstats[chart][indVar][1];

    var avgPercentile = Math.round(((window.cstats[chart][indVar][2] * 100) - 1) / window.numCompetitions);

    updateExtremes(numWins, numLosses, avgPercentile, suffix);

    var graph = $('#' + prefix + '-results-container-' + suffix).highcharts();
    graph.series[0].addPoint([indVar, numWins], false);
    graph.series[1].addPoint([indVar, numLosses], false);
    graph.series[2].addPoint([indVar, avgPercentile], false);
    graph.redraw();
}

function recursiveTraverseQueues(suffix) {
    if(nothingRunning()) {
        var chart  = nextChart();
        if(chart !== false) {
            var indVar = dequeue(chart);
            simulation(chart, indVar, suffix);
        }
        /*
    } else {
        */
    }
}

function simulate(suffix) {
    window.numCompetitions = parseInt($('#num-competitions-' + suffix).val());
    window.numGames = 100;
    window.numCompetitors = 100;
    window.maxDeviation = 0.01;

    var numGamesStart        = parseInt($('#num-games-start-' + suffix).val());
    var numCompetitorsStart  = parseInt($('#num-competitors-start-' + suffix).val());
    var maxDeviationStart    = parseFloat($('#max-deviation-start-' + suffix).val()) / 100;

    var numGamesEnd        = parseInt($('#num-games-end-' + suffix).val());
    var numCompetitorsEnd  = parseInt($('#num-competitors-end-' + suffix).val());
    var maxDeviationEnd    = parseFloat($('#max-deviation-end-' + suffix).val()) / 100;

    var numGamesStep        = parseInt($('#num-games-step-' + suffix).val());
    var numCompetitorsStep  = parseInt($('#num-competitors-step-' + suffix).val());
    var maxDeviationStep    = parseFloat($('#max-deviation-step-' + suffix).val()) / 100;

    // initialize states

    var numGamesOpts = options(numGamesStart, numGamesEnd, numGamesStep);
    var numCompetitorsOpts = options(numCompetitorsStart, numCompetitorsEnd, numCompetitorsStep);
    var maxDeviationOpts = options(maxDeviationStart, maxDeviationEnd, maxDeviationStep);

    window.states['numGames'] = {
        queue: [],
        running: [],
        finished: []
    };
    window.states['numCompetitors'] = {
        queue: [],
        running: [],
        finished: []
    };
    window.states['maxDeviation'] = {
        queue: [],
        running: [],
        finished: []
    };

    for(var i=0; i<numGamesOpts.length; i++) {
        var opt = numGamesOpts[i];
        window.states['numGames']['queue'].push(opt);
        window.cstats['numGames'][opt] = [0, 0, 0, 0];
    }
    for(var i=0; i<numCompetitorsOpts.length; i++) {
        var opt = numCompetitorsOpts[i];
        window.states['numCompetitors']['queue'].push(opt);
        window.cstats['numCompetitors'][opt] = [0, 0, 0, 0];
    }
    for(var i=0; i<maxDeviationOpts.length; i++) {
        var opt = maxDeviationOpts[i];
        window.states['maxDeviation']['queue'].push(opt);
        window.cstats['maxDeviation'][opt] = [0, 0, 0, 0];
    }

    setupCharts(suffix);

    var charts = ['numGames', 'numCompetitors', 'maxDeviation'];

    recursiveTraverseQueues(suffix);
}









































//window.cstats = {
//    'ng': {},
//    'nc': {},
//    'md': {}
//};
//window.counts = {};
//window.iters = {};
//window.precedingChart = {
//    'nc': 'ng',
//    'md': 'nc'
//};
//
//function uniq(a) {
//    var prims = {"boolean":{}, "number":{}, "string":{}}, objs = [];
//
//    return a.filter(function(item) {
//        var type = typeof item;
//        if(type in prims)
//            return prims[type].hasOwnProperty(item) ? false : (prims[type][item] = true);
//        else
//            return objs.indexOf(item) >= 0 ? false : objs.push(item);
//    });
//}
//
//function singleCompetition(numGames, numCompetitors, maxDeviation, gameProbs) {
//    var competitionStats = [0, 0, 0];
//
//    var outcomes = [];
//    for(var j=0; j<numGames; j++) {
//        var outcome = Math.random() < gameProbs[j] ? 1 : 0;
//        outcomes.push(outcome);
//    }
//
//    var trutherScore = 0;
//    for(var j=0; j<numGames; j++) {
//        var guess = Math.min(0.99, Math.max(0.01, gameProbs[j]));
//        trutherScore += (-1 * outcomes[j] * Math.log(guess));
//        trutherScore += (-1 * (1-outcomes[j]) * Math.log(1-guess));
//    }
//    trutherScore /= numGames;
//
//    var competitorScores = [trutherScore];
//
//    for(var j=1; j<numCompetitors; j++) {
//        var score = 0;
//        for(var k=0; k<numGames; k++) {
//            var deviation = (Math.random() * maxDeviation * 2) - (maxDeviation / 2);
//            var guess = Math.min(0.99, Math.max(0.01, deviation + gameProbs[k]));
//            score += (-1 * outcomes[k] * Math.log(guess));
//            score += (-1 * (1-outcomes[k]) * Math.log(1-guess));
//        }
//        score /= numGames;
//        competitorScores.push(score);
//    }
//
//    var rank = 0;
//    for(var j=1; j<numCompetitors; j++) {
//        if(trutherScore > competitorScores[j]) {
//            rank++;
//        }
//    }
//
//    competitionStats[0] = rank == 1 ? 1 : 0;
//    competitionStats[1] = rank == numCompetitors ? 1 : 0;
//    competitionStats[2] = rank;
//
//    return competitionStats;
//}
//
//function recursiveCompetitions(prefix, numCompetitions, numGames, numCompetitors, maxDeviation, gameProbs, numLeft) {
//    if(numLeft > 0) {
//        setTimeout(function() {
//            var singleStats = singleCompetition(numGames, numCompetitors, gameProbs, maxDeviation);
//            recursiveCompetitions(prefix, numCompetitions, numGames, numCompetitors, maxDeviation, gameProbs, numLeft-1);
//            window.cstats[prefix][numCompetitions][numGames][numCompetitors][maxDeviation][0] += singleStats[0];
//            window.cstats[prefix][numCompetitions][numGames][numCompetitors][maxDeviation][1] += singleStats[1];
//            window.cstats[prefix][numCompetitions][numGames][numCompetitors][maxDeviation][2] += singleStats[2];
//            window.cstats[prefix][numCompetitions][numGames][numCompetitors][maxDeviation][3]++;
//        }, 100);
//    }
//}
//
//function simulation(numCompetitions, numGames, numCompetitors, maxDeviation, prefix) {
//    var gameProbs = [];
//    var competitionStats = [0, 0, 0];
//
//    for(var i=0; i<numGames; i++) {
//        var gameProb = Math.round(Math.random()*100);
//        gameProbs.push(gameProb/100);
//    }
//
//
//    recursiveCompetitions(prefix, numCompetitions, numGames, numCompetitors, maxDeviation, gameProbs, numCompetitions);
//}
//
//function checkFinished(numCompetitions, numGames, numCompetitors, maxDeviation, prefix, suffix) {
//    console.log(prefix);
//    var tmpStats = window.cstats[prefix][numCompetitions][numGames][numCompetitors][maxDeviation];
//    if(tmpStats[3] < numCompetitions) {
//        setTimeout(function() {
//            checkFinished(numCompetitions, numGames, numCompetitors, maxDeviation, prefix, suffix);
//        }, 5000);
//    } else {
//
//        tmpStats[0] /= numCompetitions;
//        tmpStats[1] /= numCompetitions;
//        tmpStats[2] /= numCompetitions;
//        tmpStats[2] = (numCompetitors - tmpStats[2]) / numCompetitors;
//
//
//        var chart = $('#' + prefix + '-results-container-' + suffix).highcharts();
//        chart.series[0].addPoint([numGames, tmpStats[0]], false);
//        chart.series[1].addPoint([numGames, tmpStats[1]], false);
//        chart.series[2].addPoint([numGames, tmpStats[2]], false);
//        chart.redraw();
//
//        window.counts[prefix]++;
//    }
//}
//
//function recursiveSimulation(numCompetitions, numGames, numCompetitors, maxDeviation, prefix, suffix, idx) {
//    var previousChartFinished = !window.precedingChart.hasOwnProperty(prefix)
//        || window.iters[window.precedingChart[prefix]] == window.counts[window.precedingChart[prefix]];
//    var previousIterationFinished = window.counts[prefix] >= idx;
//    if(previousChartFinished && previousIterationFinished) {
//        console.log('start');
//        console.log(prefix);
//        console.log(idx);
//        if(!window.cstats[prefix].hasOwnProperty(numCompetitions))
//            window.cstats[prefix][numCompetitions] = {};
//        if(!window.cstats[prefix][numCompetitions].hasOwnProperty(numGames))
//            window.cstats[prefix][numCompetitions][numGames] = {};
//        if(!window.cstats[prefix][numCompetitions][numGames].hasOwnProperty(numCompetitors))
//            window.cstats[prefix][numCompetitions][numGames][numCompetitors] = {};
//        if(!window.cstats[prefix][numCompetitions][numGames][numCompetitors].hasOwnProperty(maxDeviation))
//            window.cstats[prefix][numCompetitions][numGames][numCompetitors][maxDeviation] = [0, 0, 0, 0];
//
//        simulation(numCompetitions, numGames, numCompetitors, maxDeviation, prefix);
//
//        checkFinished(numCompetitions, numGames, numCompetitors, maxDeviation, prefix, suffix);
//    } else {
//        setTimeout(function() {
//            recursiveSimulation(numCompetitions, numGames, numCompetitors, maxDeviation, prefix, suffix, idx);
//        }, 10000);
//    }
//}
//
//function numGamesVaried(suffix, numCompetitions, start, end, step) {
//    var numCompetitors = 10; // TODO
//    var maxDeviation   = 1;
//
//    var indVars = [];
//    for(var i=end; i>start; i-=step) {
//        indVars.push(i);
//    }
//    indVars.push(start);
//    indVars = uniq(indVars.reverse());
//
//    window.counts['ng'] = 0;
//    window.iters['ng'] = indVars.length;
//
//    for(var idx=0; idx<indVars.length; idx++) {
//        var numGames = indVars[idx];
//        
//        recursiveSimulation(numCompetitions, numGames, numCompetitors, maxDeviation, 'ng', suffix, idx);
//    }
//
//}
//
//function numCompetitorsVaried(suffix, numCompetitions, start, end, step) {
//    var numGames       = 100;
//    var maxDeviation   = 1;
//
//    var indVars = [];
//    for(var i=end; i>start; i-=step) {
//        indVars.push(i);
//    }
//    indVars.push(start);
//    indVars = uniq(indVars.reverse());
//
//    window.counts['nc'] = 0;
//    window.iters['nc'] = indVars.length;
//
//    for(var idx=0; idx<indVars.length; idx++) {
//        var numCompetitors = indVars[idx];
//
//        recursiveSimulation(numCompetitions, numGames, numCompetitors, maxDeviation, 'nc', suffix, idx);
//    }
//}
//
//function maxDeviationVaried(suffix, numCompetitions, start, end, step) {
//    var numGames       = 100;
//    var numCompetitors = 1000;
//
//    var indVars = [];
//    for(var i=end; i>start; i-=step) {
//        indVars.push(i);
//    }
//    indVars.push(start);
//    indVars = uniq(indVars.reverse());
//
//    window.counts['md'] = 0;
//    window.iters['md'] = indVars.length;
//
//    for(var idx=0; idx<indVars.length; idx++) {
//        var maxDeviation = indVars[idx];
//
//        recursiveSimulation(numCompetitions, numGames, numCompetitors, maxDeviation, 'md', suffix, idx);
//    }
//}
//
//function simulate(suffix) {
//    var numCompetitions = parseInt($('#num-competitions-' + suffix).val());
//
//    var numGamesStart        = parseInt($('#num-games-start-' + suffix).val());
//    var numCompetitorsStart  = parseInt($('#num-competitors-start-' + suffix).val());
//    var maxDeviationStart    = parseFloat($('#max-deviation-start-' + suffix).val()) / 100;
//
//    var numGamesEnd        = parseInt($('#num-games-end-' + suffix).val());
//    var numCompetitorsEnd  = parseInt($('#num-competitors-end-' + suffix).val());
//    var maxDeviationEnd    = parseFloat($('#max-deviation-end-' + suffix).val()) / 100;
//
//    var numGamesStep        = parseInt($('#num-games-step-' + suffix).val());
//    var numCompetitorsStep  = parseInt($('#num-competitors-step-' + suffix).val());
//    var maxDeviationStep    = parseFloat($('#max-deviation-step-' + suffix).val()) / 100;
//
//    var chartOpts = {
//        chart: {
//            backgroundColor: null
//        },
//        xAxis: [{
//            //allowDecimals: false,
//            //lineWidth: 0,
//            //lineColor: 'transparent',
//            //gridLineColor: 'transparent',
//            //gridLineWidth: 0,
//            //minorGridLineWidth: 0,
//            //minorGridLineColor: 'transparent',
//            //minorTickLength: 0,
//            //tickLength: 0,
//            //plotLines: [{
//            //    value: 0,
//            //    width: 0,
//            //    color: '#808080'
//            //}]
//        }],
//        yAxis: [{
//            //lineWidth: 0,
//            //lineColor: 'transparent',
//            //gridLineColor: 'transparent',
//            //gridLineWidth: 0,
//            //minorGridLineWidth: 0,
//            //minorGridLineColor: 'transparent',
//            //minorTickLength: 0,
//            //tickLength: 0,
//            min: 0,
//            //title: {
//            //    text: null
//            //},
//            //labels: {
//            //    align: 'left',
//            //    x: 2,
//            //    y: 0
//            //},
//            //plotLines: [{
//            //    value: 0,
//            //    width: 0,
//            //    color: '#808080'
//            //}]
//        }],
//        plotOptions: {
//            series: {
//                stickyTracking: false
//            }
//        },
//        tooltip: {
//            pointFormatter: function() {
//                return '<span style="color:' + this.color + '">\u25CF</span> ' + this.series.name + ': <b>' + this.y + '</b><br/>';
//            }
//        },
//        legend: {
//            enabled: false
//        },
//        credits: {
//            enabled: false
//        },
//        exporting: {
//            enabled: false
//        },
//        series: [{
//            name: 'Percent Competitions Won (First Place)',
//            yAxis: 0,
//            xAxis: 0,
//            data: [],
//            color: '#ff3300',
//            marker: {
//                enabled: false
//            }
//        },{
//            name: 'Percent Competitions Lost (Last Place)',
//            yAxis: 0,
//            xAxis: 0,
//            data: [],
//            color: '#555',
//            marker: {
//                enabled: false
//            }
//        },{
//            name: 'Average Percentile',
//            yAxis: 0,
//            xAxis: 0,
//            data: [],
//            color: '#ab1900',
//            marker: {
//                enabled: false
//            }
//        }]
//    };
//
//    chartOpts['title'] = { text: 'Number of Games per Competition' };
//    $('#ng-results-container-' + suffix).highcharts(chartOpts);
//    chartOpts['title'] = { text: 'Number of Competitors' };
//    $('#nc-results-container-' + suffix).highcharts(chartOpts);
//    chartOpts['title'] = { text: 'Max Deviation (Uniform)' };
//    $('#md-results-container-' + suffix).highcharts(chartOpts);
//
//    setTimeout(function() {
//        numGamesVaried(suffix, numCompetitions, numGamesStart, numGamesEnd, numGamesStep);
//        setTimeout(function() {
//            numCompetitorsVaried(suffix, numCompetitions, numCompetitorsStart, numCompetitorsEnd, numCompetitorsStep);
//            setTimeout(function() {
//                maxDeviationVaried(suffix, numCompetitions, maxDeviationStart, maxDeviationEnd, maxDeviationStep);
//            }, 3000);
//        }, 3000);
//    }, 3000);
//}