/**
 * @license Highcharts JS v5.0.6 (2016-12-07)
 * Data module
 *
 * (c) 2012-2016 Torstein Honsi
 *
 * License: www.highcharts.com/license
 */
(function(factory) {
    if (typeof module === 'object' && module.exports) {
        module.exports = factory;
    } else {
        factory(Highcharts);
    }
}(function(Highcharts) {
    (function(Highcharts) {
        /**
         * Data module
         *
         * (c) 2012-2016 Torstein Honsi
         *
         * License: www.highcharts.com/license
         */

        /* global jQuery */
        'use strict';

        // Utilities
        var win = Highcharts.win,
            doc = win.document,
            each = Highcharts.each,
            pick = Highcharts.pick,
            inArray = Highcharts.inArray,
            isNumber = Highcharts.isNumber,
            splat = Highcharts.splat,
            SeriesBuilder;


        // The Data constructor
        var Data = function(dataOptions, chartOptions) {
            this.init(dataOptions, chartOptions);
        };

        // Set the prototype properties
        Highcharts.extend(Data.prototype, {

            /**
             * Initialize the Data object with the given options
             */
            init: function(options, chartOptions) {
                this.options = options;
                this.chartOptions = chartOptions;
                this.columns = options.columns || this.rowsToColumns(options.rows) || [];
                this.firstRowAsNames = pick(options.firstRowAsNames, true);
                this.decimalRegex = options.decimalPoint && new RegExp('^(-?[0-9]+)' + options.decimalPoint + '([0-9]+)$');

                // This is a two-dimensional array holding the raw, trimmed string values
                // with the same organisation as the columns array. It makes it possible
                // for example to revert from interpreted timestamps to string-based
                // categories.
                this.rawColumns = [];

                // No need to parse or interpret anything
                if (this.columns.length) {
                    this.dataFound();

                    // Parse and interpret
                } else {

                    // Parse a CSV string if options.csv is given
                    this.parseCSV();

                    // Parse a HTML table if options.table is given
                    this.parseTable();

                    // Parse a Google Spreadsheet 
                    this.parseGoogleSpreadsheet();
                }

            },

            /**
             * Get the column distribution. For example, a line series takes a single column for 
             * Y values. A range series takes two columns for low and high values respectively,
             * and an OHLC series takes four columns.
             */
            getColumnDistribution: function() {
                var chartOptions = this.chartOptions,
                    options = this.options,
                    xColumns = [],
                    getValueCount = function(type) {
                        return (Highcharts.seriesTypes[type || 'line'].prototype.pointArrayMap || [0]).length;
                    },
                    getPointArrayMap = function(type) {
                        return Highcharts.seriesTypes[type || 'line'].prototype.pointArrayMap;
                    },
                    globalType = chartOptions && chartOptions.chart && chartOptions.chart.type,
                    individualCounts = [],
                    seriesBuilders = [],
                    seriesIndex = 0,
                    i;

                each((chartOptions && chartOptions.series) || [], function(series) {
                    individualCounts.push(getValueCount(series.type || globalType));
                });

                // Collect the x-column indexes from seriesMapping
                each((options && options.seriesMapping) || [], function(mapping) {
                    xColumns.push(mapping.x || 0);
                });

                // If there are no defined series with x-columns, use the first column as x column
                if (xColumns.length === 0) {
                    xColumns.push(0);
                }

                // Loop all seriesMappings and constructs SeriesBuilders from
                // the mapping options.
                each((options && options.seriesMapping) || [], function(mapping) {
                    var builder = new SeriesBuilder(),
                        name,
                        numberOfValueColumnsNeeded = individualCounts[seriesIndex] || getValueCount(globalType),
                        seriesArr = (chartOptions && chartOptions.series) || [],
                        series = seriesArr[seriesIndex] || {},
                        pointArrayMap = getPointArrayMap(series.type || globalType) || ['y'];

                    // Add an x reader from the x property or from an undefined column
                    // if the property is not set. It will then be auto populated later.
                    builder.addColumnReader(mapping.x, 'x');

                    // Add all column mappings
                    for (name in mapping) {
                        if (mapping.hasOwnProperty(name) && name !== 'x') {
                            builder.addColumnReader(mapping[name], name);
                        }
                    }

                    // Add missing columns
                    for (i = 0; i < numberOfValueColumnsNeeded; i++) {
                        if (!builder.hasReader(pointArrayMap[i])) {
                            //builder.addNextColumnReader(pointArrayMap[i]);
                            // Create and add a column reader for the next free column index
                            builder.addColumnReader(undefined, pointArrayMap[i]);
                        }
                    }

                    seriesBuilders.push(builder);
                    seriesIndex++;
                });

                var globalPointArrayMap = getPointArrayMap(globalType);
                if (globalPointArrayMap === undefined) {
                    globalPointArrayMap = ['y'];
                }

                this.valueCount = {
                    global: getValueCount(globalType),
                    xColumns: xColumns,
                    individual: individualCounts,
                    seriesBuilders: seriesBuilders,
                    globalPointArrayMap: globalPointArrayMap
                };
            },

            /**
             * When the data is parsed into columns, either by CSV, table, GS or direct input,
             * continue with other operations.
             */
            dataFound: function() {

                if (this.options.switchRowsAndColumns) {
                    this.columns = this.rowsToColumns(this.columns);
                }

                // Interpret the info about series and columns
                this.getColumnDistribution();

                // Interpret the values into right types
                this.parseTypes();

                // Handle columns if a handleColumns callback is given
                if (this.parsed() !== false) {

                    // Complete if a complete callback is given
                    this.complete();
                }

            },

            /**
             * Parse a CSV input string
             */
            parseCSV: function() {
                var self = this,
                    options = this.options,
                    csv = options.csv,
                    columns = this.columns,
                    startRow = options.startRow || 0,
                    endRow = options.endRow || Number.MAX_VALUE,
                    startColumn = options.startColumn || 0,
                    endColumn = options.endColumn || Number.MAX_VALUE,
                    itemDelimiter,
                    lines,
                    activeRowNo = 0;

                if (csv) {

                    lines = csv
                        .replace(/\r\n/g, '\n') // Unix
                        .replace(/\r/g, '\n') // Mac
                        .split(options.lineDelimiter || '\n');

                    itemDelimiter = options.itemDelimiter || (csv.indexOf('\t') !== -1 ? '\t' : ',');

                    each(lines, function(line, rowNo) {
                        var trimmed = self.trim(line),
                            isComment = trimmed.indexOf('#') === 0,
                            isBlank = trimmed === '',
                            items;

                        if (rowNo >= startRow && rowNo <= endRow && !isComment && !isBlank) {
                            items = line.split(itemDelimiter);
                            each(items, function(item, colNo) {
                                if (colNo >= startColumn && colNo <= endColumn) {
                                    if (!columns[colNo - startColumn]) {
                                        columns[colNo - startColumn] = [];
                                    }

                                    columns[colNo - startColumn][activeRowNo] = item;
                                }
                            });
                            activeRowNo += 1;
                        }
                    });

                    this.dataFound();
                }
            },

            /**
             * Parse a HTML table
             */
            parseTable: function() {
                var options = this.options,
                    table = options.table,
                    columns = this.columns,
                    startRow = options.startRow || 0,
                    endRow = options.endRow || Number.MAX_VALUE,
                    startColumn = options.startColumn || 0,
                    endColumn = options.endColumn || Number.MAX_VALUE;

                if (table) {

                    if (typeof table === 'string') {
                        table = doc.getElementById(table);
                    }

                    each(table.getElementsByTagName('tr'), function(tr, rowNo) {
                        if (rowNo >= startRow && rowNo <= endRow) {
                            each(tr.children, function(item, colNo) {
                                if ((item.tagName === 'TD' || item.tagName === 'TH') && colNo >= startColumn && colNo <= endColumn) {
                                    if (!columns[colNo - startColumn]) {
                                        columns[colNo - startColumn] = [];
                                    }

                                    columns[colNo - startColumn][rowNo - startRow] = item.innerHTML;
                                }
                            });
                        }
                    });

                    this.dataFound(); // continue
                }
            },

            /**
             */
            parseGoogleSpreadsheet: function() {
                var self = this,
                    options = this.options,
                    googleSpreadsheetKey = options.googleSpreadsheetKey,
                    columns = this.columns,
                    startRow = options.startRow || 0,
                    endRow = options.endRow || Number.MAX_VALUE,
                    startColumn = options.startColumn || 0,
                    endColumn = options.endColumn || Number.MAX_VALUE,
                    gr, // google row
                    gc; // google column

                if (googleSpreadsheetKey) {
                    jQuery.ajax({
                        dataType: 'json',
                        url: 'https://spreadsheets.google.com/feeds/cells/' +
                            googleSpreadsheetKey + '/' + (options.googleSpreadsheetWorksheet || 'od6') +
                            '/public/values?alt=json-in-script&callback=?',
                        error: options.error,
                        success: function(json) {
                            // Prepare the data from the spreadsheat
                            var cells = json.feed.entry,
                                cell,
                                cellCount = cells.length,
                                colCount = 0,
                                rowCount = 0,
                                i;

                            // First, find the total number of columns and rows that 
                            // are actually filled with data
                            for (i = 0; i < cellCount; i++) {
                                cell = cells[i];
                                colCount = Math.max(colCount, cell.gs$cell.col);
                                rowCount = Math.max(rowCount, cell.gs$cell.row);
                            }

                            // Set up arrays containing the column data
                            for (i = 0; i < colCount; i++) {
                                if (i >= startColumn && i <= endColumn) {
                                    // Create new columns with the length of either end-start or rowCount
                                    columns[i - startColumn] = [];

                                    // Setting the length to avoid jslint warning
                                    columns[i - startColumn].length = Math.min(rowCount, endRow - startRow);
                                }
                            }

                            // Loop over the cells and assign the value to the right
                            // place in the column arrays
                            for (i = 0; i < cellCount; i++) {
                                cell = cells[i];
                                gr = cell.gs$cell.row - 1; // rows start at 1
                                gc = cell.gs$cell.col - 1; // columns start at 1

                                // If both row and col falls inside start and end
                                // set the transposed cell value in the newly created columns
                                if (gc >= startColumn && gc <= endColumn &&
                                    gr >= startRow && gr <= endRow) {
                                    columns[gc - startColumn][gr - startRow] = cell.content.$t;
                                }
                            }

                            // Insert null for empty spreadsheet cells (#5298)
                            each(columns, function(column) {
                                for (i = 0; i < column.length; i++) {
                                    if (column[i] === undefined) {
                                        column[i] = null;
                                    }
                                }
                            });

                            self.dataFound();
                        }
                    });
                }
            },

            /**
             * Trim a string from whitespace
             */
            trim: function(str, inside) {
                if (typeof str === 'string') {
                    str = str.replace(/^\s+|\s+$/g, '');

                    // Clear white space insdie the string, like thousands separators
                    if (inside && /^[0-9\s]+$/.test(str)) {
                        str = str.replace(/\s/g, '');
                    }

                    if (this.decimalRegex) {
                        str = str.replace(this.decimalRegex, '$1.$2');
                    }
                }
                return str;
            },

            /**
             * Parse numeric cells in to number types and date types in to true dates.
             */
            parseTypes: function() {
                var columns = this.columns,
                    col = columns.length;

                while (col--) {
                    this.parseColumn(columns[col], col);
                }

            },

            /**
             * Parse a single column. Set properties like .isDatetime and .isNumeric.
             */
            parseColumn: function(column, col) {
                var rawColumns = this.rawColumns,
                    columns = this.columns,
                    row = column.length,
                    val,
                    floatVal,
                    trimVal,
                    trimInsideVal,
                    firstRowAsNames = this.firstRowAsNames,
                    isXColumn = inArray(col, this.valueCount.xColumns) !== -1,
                    dateVal,
                    backup = [],
                    diff,
                    chartOptions = this.chartOptions,
                    descending,
                    columnTypes = this.options.columnTypes || [],
                    columnType = columnTypes[col],
                    forceCategory = isXColumn && ((chartOptions && chartOptions.xAxis && splat(chartOptions.xAxis)[0].type === 'category') || columnType === 'string');

                if (!rawColumns[col]) {
                    rawColumns[col] = [];
                }
                while (row--) {
                    val = backup[row] || column[row];

                    trimVal = this.trim(val);
                    trimInsideVal = this.trim(val, true);
                    floatVal = parseFloat(trimInsideVal);

                    // Set it the first time
                    if (rawColumns[col][row] === undefined) {
                        rawColumns[col][row] = trimVal;
                    }

                    // Disable number or date parsing by setting the X axis type to category
                    if (forceCategory || (row === 0 && firstRowAsNames)) {
                        column[row] = trimVal;

                    } else if (+trimInsideVal === floatVal) { // is numeric

                        column[row] = floatVal;

                        // If the number is greater than milliseconds in a year, assume datetime
                        if (floatVal > 365 * 24 * 3600 * 1000 && columnType !== 'float') {
                            column.isDatetime = true;
                        } else {
                            column.isNumeric = true;
                        }

                        if (column[row + 1] !== undefined) {
                            descending = floatVal > column[row + 1];
                        }

                        // String, continue to determine if it is a date string or really a string
                    } else {
                        dateVal = this.parseDate(val);
                        // Only allow parsing of dates if this column is an x-column
                        if (isXColumn && isNumber(dateVal) && columnType !== 'float') { // is date
                            backup[row] = val;
                            column[row] = dateVal;
                            column.isDatetime = true;

                            // Check if the dates are uniformly descending or ascending. If they 
                            // are not, chances are that they are a different time format, so check
                            // for alternative.
                            if (column[row + 1] !== undefined) {
                                diff = dateVal > column[row + 1];
                                if (diff !== descending && descending !== undefined) {
                                    if (this.alternativeFormat) {
                                        this.dateFormat = this.alternativeFormat;
                                        row = column.length;
                                        this.alternativeFormat = this.dateFormats[this.dateFormat].alternative;
                                    } else {
                                        column.unsorted = true;
                                    }
                                }
                                descending = diff;
                            }

                        } else { // string
                            column[row] = trimVal === '' ? null : trimVal;
                            if (row !== 0 && (column.isDatetime || column.isNumeric)) {
                                column.mixed = true;
                            }
                        }
                    }
                }

                // If strings are intermixed with numbers or dates in a parsed column, it is an indication
                // that parsing went wrong or the data was not intended to display as numbers or dates and 
                // parsing is too aggressive. Fall back to categories. Demonstrated in the 
                // highcharts/demo/column-drilldown sample.
                if (isXColumn && column.mixed) {
                    columns[col] = rawColumns[col];
                }

                // If the 0 column is date or number and descending, reverse all columns. 
                if (isXColumn && descending && this.options.sort) {
                    for (col = 0; col < columns.length; col++) {
                        columns[col].reverse();
                        if (firstRowAsNames) {
                            columns[col].unshift(columns[col].pop());
                        }
                    }
                }
            },

            /**
             * A collection of available date formats, extendable from the outside to support
             * custom date formats.
             */
            dateFormats: {
                'YYYY-mm-dd': {
                    regex: /^([0-9]{4})[\-\/\.]([0-9]{2})[\-\/\.]([0-9]{2})$/,
                    parser: function(match) {
                        return Date.UTC(+match[1], match[2] - 1, +match[3]);
                    }
                },
                'dd/mm/YYYY': {
                    regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{4})$/,
                    parser: function(match) {
                        return Date.UTC(+match[3], match[2] - 1, +match[1]);
                    },
                    alternative: 'mm/dd/YYYY' // different format with the same regex
                },
                'mm/dd/YYYY': {
                    regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{4})$/,
                    parser: function(match) {
                        return Date.UTC(+match[3], match[1] - 1, +match[2]);
                    }
                },
                'dd/mm/YY': {
                    regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{2})$/,
                    parser: function(match) {
                        return Date.UTC(+match[3] + 2000, match[2] - 1, +match[1]);
                    },
                    alternative: 'mm/dd/YY' // different format with the same regex
                },
                'mm/dd/YY': {
                    regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{2})$/,
                    parser: function(match) {
                        return Date.UTC(+match[3] + 2000, match[1] - 1, +match[2]);
                    }
                }
            },

            /**
             * Parse a date and return it as a number. Overridable through options.parseDate.
             */
            parseDate: function(val) {
                var parseDate = this.options.parseDate,
                    ret,
                    key,
                    format,
                    dateFormat = this.options.dateFormat || this.dateFormat,
                    match;

                if (parseDate) {
                    ret = parseDate(val);

                } else if (typeof val === 'string') {
                    // Auto-detect the date format the first time
                    if (!dateFormat) {
                        for (key in this.dateFormats) {
                            format = this.dateFormats[key];
                            match = val.match(format.regex);
                            if (match) {
                                this.dateFormat = dateFormat = key;
                                this.alternativeFormat = format.alternative;
                                ret = format.parser(match);
                                break;
                            }
                        }
                        // Next time, use the one previously found
                    } else {
                        format = this.dateFormats[dateFormat];
                        match = val.match(format.regex);
                        if (match) {
                            ret = format.parser(match);
                        }
                    }
                    // Fall back to Date.parse		
                    if (!match) {
                        match = Date.parse(val);
                        // External tools like Date.js and MooTools extend Date object and
                        // returns a date.
                        if (typeof match === 'object' && match !== null && match.getTime) {
                            ret = match.getTime() - match.getTimezoneOffset() * 60000;

                            // Timestamp
                        } else if (isNumber(match)) {
                            ret = match - (new Date(match)).getTimezoneOffset() * 60000;
                        }
                    }
                }
                return ret;
            },

            /**
             * Reorganize rows into columns
             */
            rowsToColumns: function(rows) {
                var row,
                    rowsLength,
                    col,
                    colsLength,
                    columns;

                if (rows) {
                    columns = [];
                    rowsLength = rows.length;
                    for (row = 0; row < rowsLength; row++) {
                        colsLength = rows[row].length;
                        for (col = 0; col < colsLength; col++) {
                            if (!columns[col]) {
                                columns[col] = [];
                            }
                            columns[col][row] = rows[row][col];
                        }
                    }
                }
                return columns;
            },

            /**
             * A hook for working directly on the parsed columns
             */
            parsed: function() {
                if (this.options.parsed) {
                    return this.options.parsed.call(this, this.columns);
                }
            },

            getFreeIndexes: function(numberOfColumns, seriesBuilders) {
                var s,
                    i,
                    freeIndexes = [],
                    freeIndexValues = [],
                    referencedIndexes;

                // Add all columns as free
                for (i = 0; i < numberOfColumns; i = i + 1) {
                    freeIndexes.push(true);
                }

                // Loop all defined builders and remove their referenced columns
                for (s = 0; s < seriesBuilders.length; s = s + 1) {
                    referencedIndexes = seriesBuilders[s].getReferencedColumnIndexes();

                    for (i = 0; i < referencedIndexes.length; i = i + 1) {
                        freeIndexes[referencedIndexes[i]] = false;
                    }
                }

                // Collect the values for the free indexes
                for (i = 0; i < freeIndexes.length; i = i + 1) {
                    if (freeIndexes[i]) {
                        freeIndexValues.push(i);
                    }
                }

                return freeIndexValues;
            },

            /**
             * If a complete callback function is provided in the options, interpret the 
             * columns into a Highcharts options object.
             */
            complete: function() {

                var columns = this.columns,
                    xColumns = [],
                    type,
                    options = this.options,
                    series,
                    data,
                    i,
                    j,
                    r,
                    seriesIndex,
                    chartOptions,
                    allSeriesBuilders = [],
                    builder,
                    freeIndexes,
                    typeCol,
                    index;

                xColumns.length = columns.length;
                if (options.complete || options.afterComplete) {

                    // Get the names and shift the top row
                    for (i = 0; i < columns.length; i++) {
                        if (this.firstRowAsNames) {
                            columns[i].name = columns[i].shift();
                        }
                    }

                    // Use the next columns for series
                    series = [];
                    freeIndexes = this.getFreeIndexes(columns.length, this.valueCount.seriesBuilders);

                    // Populate defined series
                    for (seriesIndex = 0; seriesIndex < this.valueCount.seriesBuilders.length; seriesIndex++) {
                        builder = this.valueCount.seriesBuilders[seriesIndex];

                        // If the builder can be populated with remaining columns, then add it to allBuilders
                        if (builder.populateColumns(freeIndexes)) {
                            allSeriesBuilders.push(builder);
                        }
                    }

                    // Populate dynamic series
                    while (freeIndexes.length > 0) {
                        builder = new SeriesBuilder();
                        builder.addColumnReader(0, 'x');

                        // Mark index as used (not free)
                        index = inArray(0, freeIndexes);
                        if (index !== -1) {
                            freeIndexes.splice(index, 1);
                        }

                        for (i = 0; i < this.valueCount.global; i++) {
                            // Create and add a column reader for the next free column index
                            builder.addColumnReader(undefined, this.valueCount.globalPointArrayMap[i]);
                        }

                        // If the builder can be populated with remaining columns, then add it to allBuilders
                        if (builder.populateColumns(freeIndexes)) {
                            allSeriesBuilders.push(builder);
                        }
                    }

                    // Get the data-type from the first series x column
                    if (allSeriesBuilders.length > 0 && allSeriesBuilders[0].readers.length > 0) {
                        typeCol = columns[allSeriesBuilders[0].readers[0].columnIndex];
                        if (typeCol !== undefined) {
                            if (typeCol.isDatetime) {
                                type = 'datetime';
                            } else if (!typeCol.isNumeric) {
                                type = 'category';
                            }
                        }
                    }
                    // Axis type is category, then the "x" column should be called "name"
                    if (type === 'category') {
                        for (seriesIndex = 0; seriesIndex < allSeriesBuilders.length; seriesIndex++) {
                            builder = allSeriesBuilders[seriesIndex];
                            for (r = 0; r < builder.readers.length; r++) {
                                if (builder.readers[r].configName === 'x') {
                                    builder.readers[r].configName = 'name';
                                }
                            }
                        }
                    }

                    // Read data for all builders
                    for (seriesIndex = 0; seriesIndex < allSeriesBuilders.length; seriesIndex++) {
                        builder = allSeriesBuilders[seriesIndex];

                        // Iterate down the cells of each column and add data to the series
                        data = [];
                        for (j = 0; j < columns[0].length; j++) {
                            data[j] = builder.read(columns, j);
                        }

                        // Add the series
                        series[seriesIndex] = {
                            data: data
                        };
                        if (builder.name) {
                            series[seriesIndex].name = builder.name;
                        }
                        if (type === 'category') {
                            series[seriesIndex].turboThreshold = 0;
                        }
                    }



                    // Do the callback
                    chartOptions = {
                        series: series
                    };
                    if (type) {
                        chartOptions.xAxis = {
                            type: type
                        };
                        if (type === 'category') {
                            chartOptions.xAxis.uniqueNames = false;
                        }
                    }

                    if (options.complete) {
                        options.complete(chartOptions);
                    }

                    // The afterComplete hook is used internally to avoid conflict with the externally
                    // available complete option.
                    if (options.afterComplete) {
                        options.afterComplete(chartOptions);
                    }
                }
            }
        });

        // Register the Data prototype and data function on Highcharts
        Highcharts.Data = Data;
        Highcharts.data = function(options, chartOptions) {
            return new Data(options, chartOptions);
        };

        // Extend Chart.init so that the Chart constructor accepts a new configuration
        // option group, data.
        Highcharts.wrap(Highcharts.Chart.prototype, 'init', function(proceed, userOptions, callback) {
            var chart = this;

            if (userOptions && userOptions.data) {
                Highcharts.data(Highcharts.extend(userOptions.data, {

                    afterComplete: function(dataOptions) {
                        var i, series;

                        // Merge series configs
                        if (userOptions.hasOwnProperty('series')) {
                            if (typeof userOptions.series === 'object') {
                                i = Math.max(userOptions.series.length, dataOptions.series.length);
                                while (i--) {
                                    series = userOptions.series[i] || {};
                                    userOptions.series[i] = Highcharts.merge(series, dataOptions.series[i]);
                                }
                            } else { // Allow merging in dataOptions.series (#2856)
                                delete userOptions.series;
                            }
                        }

                        // Do the merge
                        userOptions = Highcharts.merge(dataOptions, userOptions);

                        proceed.call(chart, userOptions, callback);
                    }
                }), userOptions);
            } else {
                proceed.call(chart, userOptions, callback);
            }
        });

        /**
         * Creates a new SeriesBuilder. A SeriesBuilder consists of a number
         * of ColumnReaders that reads columns and give them a name.
         * Ex: A series builder can be constructed to read column 3 as 'x' and
         * column 7 and 8 as 'y1' and 'y2'.
         * The output would then be points/rows of the form {x: 11, y1: 22, y2: 33}
         * 
         * The name of the builder is taken from the second column. In the above
         * example it would be the column with index 7.
         * @constructor
         */
        SeriesBuilder = function() {
            this.readers = [];
            this.pointIsArray = true;
        };

        /**
         * Populates readers with column indexes. A reader can be added without
         * a specific index and for those readers the index is taken sequentially
         * from the free columns (this is handled by the ColumnCursor instance).
         * @returns {boolean}
         */
        SeriesBuilder.prototype.populateColumns = function(freeIndexes) {
            var builder = this,
                enoughColumns = true;

            // Loop each reader and give it an index if its missing.
            // The freeIndexes.shift() will return undefined if there
            // are no more columns.
            each(builder.readers, function(reader) {
                if (reader.columnIndex === undefined) {
                    reader.columnIndex = freeIndexes.shift();
                }
            });

            // Now, all readers should have columns mapped. If not
            // then return false to signal that this series should
            // not be added.
            each(builder.readers, function(reader) {
                if (reader.columnIndex === undefined) {
                    enoughColumns = false;
                }
            });

            return enoughColumns;
        };

        /**
         * Reads a row from the dataset and returns a point or array depending
         * on the names of the readers.
         * @param columns
         * @param rowIndex
         * @returns {Array | Object}
         */
        SeriesBuilder.prototype.read = function(columns, rowIndex) {
            var builder = this,
                pointIsArray = builder.pointIsArray,
                point = pointIsArray ? [] : {},
                columnIndexes;

            // Loop each reader and ask it to read its value.
            // Then, build an array or point based on the readers names.
            each(builder.readers, function(reader) {
                var value = columns[reader.columnIndex][rowIndex];
                if (pointIsArray) {
                    point.push(value);
                } else {
                    point[reader.configName] = value;
                }
            });

            // The name comes from the first column (excluding the x column)
            if (this.name === undefined && builder.readers.length >= 2) {
                columnIndexes = builder.getReferencedColumnIndexes();
                if (columnIndexes.length >= 2) {
                    // remove the first one (x col)
                    columnIndexes.shift();

                    // Sort the remaining
                    columnIndexes.sort();

                    // Now use the lowest index as name column
                    this.name = columns[columnIndexes.shift()].name;
                }
            }

            return point;
        };

        /**
         * Creates and adds ColumnReader from the given columnIndex and configName.
         * ColumnIndex can be undefined and in that case the reader will be given
         * an index when columns are populated.
         * @param columnIndex {Number | undefined}
         * @param configName
         */
        SeriesBuilder.prototype.addColumnReader = function(columnIndex, configName) {
            this.readers.push({
                columnIndex: columnIndex,
                configName: configName
            });

            if (!(configName === 'x' || configName === 'y' || configName === undefined)) {
                this.pointIsArray = false;
            }
        };

        /**
         * Returns an array of column indexes that the builder will use when
         * reading data.
         * @returns {Array}
         */
        SeriesBuilder.prototype.getReferencedColumnIndexes = function() {
            var i,
                referencedColumnIndexes = [],
                columnReader;

            for (i = 0; i < this.readers.length; i = i + 1) {
                columnReader = this.readers[i];
                if (columnReader.columnIndex !== undefined) {
                    referencedColumnIndexes.push(columnReader.columnIndex);
                }
            }

            return referencedColumnIndexes;
        };

        /**
         * Returns true if the builder has a reader for the given configName.
         * @param configName
         * @returns {boolean}
         */
        SeriesBuilder.prototype.hasReader = function(configName) {
            var i, columnReader;
            for (i = 0; i < this.readers.length; i = i + 1) {
                columnReader = this.readers[i];
                if (columnReader.configName === configName) {
                    return true;
                }
            }
            // Else return undefined
        };

    }(Highcharts));
}));
