/**
 * @license Map plugin v0.1 for Highcharts
 *
 * (c) 2011-2013 Torstein Hønsi
 *
 * License: www.highcharts.com/license
 */

/*
 * See www.highcharts.com/studies/world-map.htm for use case.
 *
 * To do:
 * - Optimize long variable names and alias adapter methods and Highcharts namespace variables
 * - Zoom and pan GUI
 */
(function (Highcharts) {
    var UNDEFINED,
        Axis = Highcharts.Axis,
        Chart = Highcharts.Chart,
        Point = Highcharts.Point,
        Pointer = Highcharts.Pointer,
        each = Highcharts.each,
        extend = Highcharts.extend,
        merge = Highcharts.merge,
        pick = Highcharts.pick,
        numberFormat = Highcharts.numberFormat,
        defaultOptions = Highcharts.getOptions(),
        seriesTypes = Highcharts.seriesTypes,
        plotOptions = defaultOptions.plotOptions,
        wrap = Highcharts.wrap,
        Color = Highcharts.Color,
        noop = function () { };

	/*
	 * Return an intermediate color between two colors, according to pos where 0
	 * is the from color and 1 is the to color
	 */
    function tweenColors(from, to, pos) {
        var i = 4,
            rgba = [];

        while (i--) {
            rgba[i] = Math.round(
                to.rgba[i] + (from.rgba[i] - to.rgba[i]) * (1 - pos)
            );
        }
        return 'rgba(' + rgba.join(',') + ')';
    }

    // Set the default map navigation options
    defaultOptions.mapNavigation = {
        buttonOptions: {
            align: 'right',
            verticalAlign: 'bottom',
            x: 0,
            width: 18,
            height: 18,
            style: {
                fontSize: '15px',
                fontWeight: 'bold',
                textAlign: 'center'
            }
        },
        buttons: {
            zoomIn: {
                onclick: function () {
                    this.mapZoom(0.5);
                },
                text: '+',
                y: -32
            },
            zoomOut: {
                onclick: function () {
                    this.mapZoom(2);
                },
                text: '-',
                y: 0
            }
        }
        // enableButtons: false,
        // enableTouchZoom: false,
        // zoomOnDoubleClick: false,
        // zoomOnMouseWheel: false
    };

	/**
	 * Utility for reading SVG paths directly.
	 */
    Highcharts.splitPath = function (path) {
        var i;

        // Move letters apart
        path = path.replace(/([A-Za-z])/g, ' $1 ');
        // Trim
        path = path.replace(/^\s*/, "").replace(/\s*$/, "");

        // Split on spaces and commas
        path = path.split(/[ ,]+/);

        // Parse numbers
        for (i = 0; i < path.length; i++) {
            if (!/[a-zA-Z]/.test(path[i])) {
                path[i] = parseFloat(path[i]);
            }
        }
        return path;
    };

    // A placeholder for map definitions
    Highcharts.maps = {};

	/**
	 * Override to use the extreme coordinates from the SVG shape, not the
	 * data values
	 */
    wrap(Axis.prototype, 'getSeriesExtremes', function (proceed) {
        var isXAxis = this.isXAxis,
            dataMin,
            dataMax,
            xData = [];

        // Remove the xData array and cache it locally so that the proceed method doesn't use it
        each(this.series, function (series, i) {
            if (series.useMapGeometry) {
                xData[i] = series.xData;
                series.xData = [];
            }
        });

        // Call base to reach normal cartesian series (like mappoint)
        proceed.call(this);

        // Run extremes logic for map and mapline
        dataMin = pick(this.dataMin, Number.MAX_VALUE);
        dataMax = pick(this.dataMax, Number.MIN_VALUE);
        each(this.series, function (series, i) {
            if (series.useMapGeometry) {
                dataMin = Math.min(dataMin, series[isXAxis ? 'minX' : 'minY']);
                dataMax = Math.max(dataMax, series[isXAxis ? 'maxX' : 'maxY']);
                series.xData = xData[i]; // Reset xData array
            }
        });

        this.dataMin = dataMin;
        this.dataMax = dataMax;
    });

	/**
	 * Override axis translation to make sure the aspect ratio is always kept
	 */
    wrap(Axis.prototype, 'setAxisTranslation', function (proceed) {
        var chart = this.chart,
            mapRatio,
            plotRatio = chart.plotWidth / chart.plotHeight,
            isXAxis = this.isXAxis,
            adjustedAxisLength,
            xAxis = chart.xAxis[0],
            padAxis;

        // Run the parent method
        proceed.call(this);

        // On Y axis, handle both
        if (chart.options.chart.type === 'map' && !isXAxis && xAxis.transA !== UNDEFINED) {
            // Use the same translation for both axes
            this.transA = xAxis.transA = Math.min(this.transA, xAxis.transA);

            mapRatio = (xAxis.max - xAxis.min) / (this.max - this.min);

            // What axis to pad to put the map in the middle
            padAxis = mapRatio > plotRatio ? this : xAxis;

            // Pad it
            adjustedAxisLength = (padAxis.max - padAxis.min) * padAxis.transA;
            padAxis.minPixelPadding = (padAxis.len - adjustedAxisLength) / 2;
        }
    });

    //--- Start zooming and panning features

    wrap(Chart.prototype, 'render', function (proceed) {
        var chart = this,
            mapNavigation = chart.options.mapNavigation;

        proceed.call(chart);

        // Render the plus and minus buttons
        chart.renderMapNavigation();

        // Add the double click event
        if (mapNavigation.zoomOnDoubleClick) {
            Highcharts.addEvent(chart.container, 'dblclick', function (e) {
                chart.pointer.onContainerDblClick(e);
            });
        }

        // Add the mousewheel event
        if (mapNavigation.zoomOnMouseWheel) {
            Highcharts.addEvent(chart.container, document.onmousewheel === undefined ? 'DOMMouseScroll' : 'mousewheel', function (e) {
                chart.pointer.onContainerMouseWheel(e);
            });
        }
    });

    // Extend the Pointer
    extend(Pointer.prototype, {
		/**
		 * The event handler for the doubleclick event
		 */
        onContainerDblClick: function (e) {
            var chart = this.chart;

            e = this.normalize(e);

            if (chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) {
                chart.mapZoom(
                    0.5,
                    chart.xAxis[0].toValue(e.chartX),
                    chart.yAxis[0].toValue(e.chartY)
                );
            }
        },

		/**
		 * The event handler for the mouse scroll event
		 */
        onContainerMouseWheel: function (e) {
            var chart = this.chart,
                delta;

            e = this.normalize(e);

            // Firefox uses e.detail, WebKit and IE uses wheelDelta
            delta = e.detail || -(e.wheelDelta / 120);
            if (chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) {
                chart.mapZoom(
                    delta > 0 ? 2 : 0.5,
                    chart.xAxis[0].toValue(e.chartX),
                    chart.yAxis[0].toValue(e.chartY)
                );
            }
        }
    });
    // Implement the pinchType option
    wrap(Pointer.prototype, 'init', function (proceed, chart, options) {
        proceed.call(this, chart, options);

        // Pinch status
        if (options.mapNavigation.enableTouchZoom) {
            this.pinchX = this.pinchHor =
                this.pinchY = this.pinchVert = true;
        }
    });

    // Add events to the Chart object itself
    extend(Chart.prototype, {
        renderMapNavigation: function () {
            var chart = this,
                options = this.options.mapNavigation,
                buttons = options.buttons,
                n,
                button,
                buttonOptions,
                outerHandler = function () {
                    this.handler.call(chart);
                };

            if (options.enableButtons) {
                for (n in buttons) {
                    if (buttons.hasOwnProperty(n)) {
                        buttonOptions = merge(options.buttonOptions, buttons[n]);

                        button = chart.renderer.button(buttonOptions.text, 0, 0, outerHandler)
                            .attr({
                                width: buttonOptions.width,
                                height: buttonOptions.height
                            })
                            .css(buttonOptions.style)
                            .add();
                        button.handler = buttonOptions.onclick;
                        button.align(extend(buttonOptions, { width: button.width, height: button.height }), null, 'spacingBox');
                    }
                }
            }
        },

		/**
		 * Fit an inner box to an outer. If the inner box overflows left or right, align it to the sides of the
		 * outer. If it overflows both sides, fit it within the outer. This is a pattern that occurs more places
		 * in Highcharts, perhaps it should be elevated to a common utility function.
		 */
        fitToBox: function (inner, outer) {
            each([['x', 'width'], ['y', 'height']], function (dim) {
                var pos = dim[0],
                    size = dim[1];
                if (inner[pos] + inner[size] > outer[pos] + outer[size]) { // right overflow
                    if (inner[size] > outer[size]) { // the general size is greater, fit fully to outer
                        inner[size] = outer[size];
                        inner[pos] = outer[pos];
                    } else { // align right
                        inner[pos] = outer[pos] + outer[size] - inner[size];
                    }
                }
                if (inner[size] > outer[size]) {
                    inner[size] = outer[size];
                }
                if (inner[pos] < outer[pos]) {
                    inner[pos] = outer[pos];
                }
            });

            return inner;
        },

		/**
		 * Zoom the map in or out by a certain amount. Less than 1 zooms in, greater than 1 zooms out.
		 */
        mapZoom: function (howMuch, centerXArg, centerYArg) {
            if (this.isMapZooming) {
                return;
            }

            var chart = this,
                xAxis = chart.xAxis[0],
                xRange = xAxis.max - xAxis.min,
                centerX = pick(centerXArg, xAxis.min + xRange / 2),
                newXRange = xRange * howMuch,
                yAxis = chart.yAxis[0],
                yRange = yAxis.max - yAxis.min,
                centerY = pick(centerYArg, yAxis.min + yRange / 2),
                newYRange = yRange * howMuch,
                newXMin = centerX - newXRange / 2,
                newYMin = centerY - newYRange / 2,
                animation = pick(chart.options.chart.animation, true),
                delay,
                newExt = chart.fitToBox({
                    x: newXMin,
                    y: newYMin,
                    width: newXRange,
                    height: newYRange
                }, {
                        x: xAxis.dataMin,
                        y: yAxis.dataMin,
                        width: xAxis.dataMax - xAxis.dataMin,
                        height: yAxis.dataMax - yAxis.dataMin
                    });

            xAxis.setExtremes(newExt.x, newExt.x + newExt.width, false);
            yAxis.setExtremes(newExt.y, newExt.y + newExt.height, false);

            // Prevent zooming until this one is finished animating
            delay = animation ? animation.duration || 500 : 0;
            if (delay) {
                chart.isMapZooming = true;
                setTimeout(function () {
                    chart.isMapZooming = false;
                }, delay);
            }

            chart.redraw();
        }
    });

	/**
	 * Extend the default options with map options
	 */
    plotOptions.map = merge(plotOptions.scatter, {
        animation: false, // makes the complex shapes slow
        nullColor: '#F8F8F8',
        borderColor: 'silver',
        borderWidth: 1,
        marker: null,
        stickyTracking: false,
        dataLabels: {
            verticalAlign: 'middle'
        },
        turboThreshold: 0,
        tooltip: {
            followPointer: true,
            pointFormat: '{point.name}: {point.y}<br/>'
        },
        states: {
            normal: {
                animation: true
            }
        }
    });

    var MapAreaPoint = Highcharts.extendClass(Point, {
		/**
		 * Extend the Point object to split paths
		 */
        applyOptions: function (options, x) {
            var point = Point.prototype.applyOptions.call(this, options, x);

            if (point.path && typeof point.path === 'string') {
                point.path = point.options.path = Highcharts.splitPath(point.path);
            }

            return point;
        },
		/**
		 * Stop the fade-out
		 */
        onMouseOver: function () {
            clearTimeout(this.colorInterval);
            Point.prototype.onMouseOver.call(this);
        },
		/**
		 * Custom animation for tweening out the colors. Animation reduces blinking when hovering
		 * over islands and coast lines. We run a custom implementation of animation becuase we
		 * need to be able to run this independently from other animations like zoom redraw. Also,
		 * adding color animation to the adapters would introduce almost the same amount of code.
		 */
        onMouseOut: function () {
            var point = this,
                start = +new Date(),
                normalColor = Color(point.options.color),
                hoverColor = Color(point.pointAttr.hover.fill),
                animation = point.series.options.states.normal.animation,
                duration = animation && (animation.duration || 500);

            if (duration && normalColor.rgba.length === 4 && hoverColor.rgba.length === 4) {
                delete point.pointAttr[''].fill; // avoid resetting it in Point.setState

                clearTimeout(point.colorInterval);
                point.colorInterval = setInterval(function () {
                    var pos = (new Date() - start) / duration,
                        graphic = point.graphic;
                    if (pos > 1) {
                        pos = 1;
                    }
                    if (graphic) {
                        graphic.attr('fill', tweenColors(hoverColor, normalColor, pos));
                    }
                    if (pos >= 1) {
                        clearTimeout(point.colorInterval);
                    }
                }, 13);
            }
            Point.prototype.onMouseOut.call(point);
        }
    });

	/**
	 * Add the series type
	 */
    seriesTypes.map = Highcharts.extendClass(seriesTypes.scatter, {
        type: 'map',
        pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
            stroke: 'borderColor',
            'stroke-width': 'borderWidth',
            fill: 'color'
        },
        colorKey: 'y',
        pointClass: MapAreaPoint,
        trackerGroups: ['group', 'markerGroup', 'dataLabelsGroup'],
        getSymbol: noop,
        supportsDrilldown: true,
        getExtremesFromAll: true,
        useMapGeometry: true, // get axis extremes from paths, not values
        init: function (chart) {
            var series = this,
                valueDecimals = chart.options.legend.valueDecimals,
                legendItems = [],
                name,
                from,
                to,
                fromLabel,
                toLabel,
                colorRange,
                valueRanges,
                gradientColor,
                grad,
                tmpLabel,
                horizontal = chart.options.legend.layout === 'horizontal';

            Highcharts.Series.prototype.init.apply(this, arguments);
            colorRange = series.options.colorRange;
            valueRanges = series.options.valueRanges;

            if (valueRanges) {
                each(valueRanges, function (range) {
                    from = range.from;
                    to = range.to;

                    // Assemble the default name. This can be overridden by legend.options.labelFormatter
                    name = '';
                    if (from === UNDEFINED) {
                        name = '< ';
                    } else if (to === UNDEFINED) {
                        name = '> ';
                    }
                    if (from !== UNDEFINED) {
                        name += numberFormat(from, valueDecimals);
                    }
                    if (from !== UNDEFINED && to !== UNDEFINED) {
                        name += ' - ';
                    }
                    if (to !== UNDEFINED) {
                        name += numberFormat(to, valueDecimals);
                    }

                    // Add a mock object to the legend items
                    legendItems.push(Highcharts.extend({
                        chart: series.chart,
                        name: name,
                        options: {},
                        drawLegendSymbol: seriesTypes.area.prototype.drawLegendSymbol,
                        visible: true,
                        setState: function () { },
                        setVisible: function () { }
                    }, range));
                });
                series.legendItems = legendItems;
            } else if (colorRange) {
                from = colorRange.from;
                to = colorRange.to;
                fromLabel = colorRange.fromLabel;
                toLabel = colorRange.toLabel;

                // Flips linearGradient variables and label text.
                grad = horizontal ? [0, 0, 1, 0] : [0, 1, 0, 0];
                if (!horizontal) {
                    tmpLabel = fromLabel;
                    fromLabel = toLabel;
                    toLabel = tmpLabel;
                }

                // Creates color gradient.
                gradientColor = {
                    linearGradient: { x1: grad[0], y1: grad[1], x2: grad[2], y2: grad[3] },
                    stops:
                        [
                            [0, from],
                            [1, to]
                        ]
                };

                // Add a mock object to the legend items.
                legendItems = [{
                    chart: series.chart,
                    options: {},
                    fromLabel: fromLabel,
                    toLabel: toLabel,
                    color: gradientColor,
                    drawLegendSymbol: this.drawLegendSymbolGradient,
                    visible: true,
                    setState: function () { },
                    setVisible: function () { }
                }];

                series.legendItems = legendItems;
            }
        },

		/**
		 * If neither valueRanges nor colorRanges are defined, use basic area symbol.
		 */
        drawLegendSymbol: seriesTypes.area.prototype.drawLegendSymbol,

		/**
		 * Gets the series' symbol in the legend and extended legend with more information.
		 *
		 * @param {Object} legend The legend object
		 * @param {Object} item The series (this) or point
		 */
        drawLegendSymbolGradient: function (legend, item) {
            var spacing = legend.options.symbolPadding,
                padding = pick(legend.options.padding, 8),
                positionY,
                positionX,
                gradientSize = this.chart.renderer.fontMetrics(legend.options.itemStyle.fontSize).h,
                horizontal = legend.options.layout === 'horizontal',
                box1,
                box2,
                box3,
                rectangleLength = pick(legend.options.rectangleLength, 200);

            // Set local variables based on option.
            if (horizontal) {
                positionY = -(spacing / 2);
                positionX = 0;
            } else {
                positionY = -rectangleLength + legend.baseline - (spacing / 2);
                positionX = padding + gradientSize;
            }

            // Creates the from text.
            item.fromText = this.chart.renderer.text(
                item.fromLabel,	// Text.
                positionX,		// Lower left x.
                positionY		// Lower left y.
            ).attr({
                zIndex: 2
            }).add(item.legendGroup);
            box1 = item.fromText.getBBox();

            // Creates legend symbol.
            // Ternary changes variables based on option.
            item.legendSymbol = this.chart.renderer.rect(
                horizontal ? box1.x + box1.width + spacing : box1.x - gradientSize - spacing,		// Upper left x.
                box1.y,																				// Upper left y.
                horizontal ? rectangleLength : gradientSize,											// Width.
                horizontal ? gradientSize : rectangleLength,										// Height.
                2																					// Corner radius.
            ).attr({
                zIndex: 1
            }).add(item.legendGroup);
            box2 = item.legendSymbol.getBBox();

            // Creates the to text.
            // Vertical coordinate changed based on option.
            item.toText = this.chart.renderer.text(
                item.toLabel,
                box2.x + box2.width + spacing,
                horizontal ? positionY : box2.y + box2.height - spacing
            ).attr({
                zIndex: 2
            }).add(item.legendGroup);
            box3 = item.toText.getBBox();

            // Changes legend box settings based on option.
            if (horizontal) {
                legend.offsetWidth = box1.width + box2.width + box3.width + (spacing * 2) + padding;
                legend.itemY = gradientSize + padding;
            } else {
                legend.offsetWidth = Math.max(box1.width, box3.width) + (spacing) + box2.width + padding;
                legend.itemY = box2.height + padding;
                legend.itemX = spacing;
            }
        },

		/**
		 * Get the bounding box of all paths in the map combined.
		 */
        getBox: function (paths) {
            var maxX = Number.MIN_VALUE,
                minX = Number.MAX_VALUE,
                maxY = Number.MIN_VALUE,
                minY = Number.MAX_VALUE;

            // Find the bounding box
            each(paths || this.options.data, function (point) {
                var path = point.path,
                    i = path.length,
                    even = false, // while loop reads from the end
                    pointMaxX = Number.MIN_VALUE,
                    pointMinX = Number.MAX_VALUE,
                    pointMaxY = Number.MIN_VALUE,
                    pointMinY = Number.MAX_VALUE;

                while (i--) {
                    if (typeof path[i] === 'number' && !isNaN(path[i])) {
                        if (even) { // even = x
                            pointMaxX = Math.max(pointMaxX, path[i]);
                            pointMinX = Math.min(pointMinX, path[i]);
                        } else { // odd = Y
                            pointMaxY = Math.max(pointMaxY, path[i]);
                            pointMinY = Math.min(pointMinY, path[i]);
                        }
                        even = !even;
                    }
                }
                // Cache point bounding box for use to position data labels
                point._maxX = pointMaxX;
                point._minX = pointMinX;
                point._maxY = pointMaxY;
                point._minY = pointMinY;

                maxX = Math.max(maxX, pointMaxX);
                minX = Math.min(minX, pointMinX);
                maxY = Math.max(maxY, pointMaxY);
                minY = Math.min(minY, pointMinY);
            });
            this.minY = minY;
            this.maxY = maxY;
            this.minX = minX;
            this.maxX = maxX;
        },

		/**
		 * Translate the path so that it automatically fits into the plot area box
		 * @param {Object} path
		 */
        translatePath: function (path) {
            var series = this,
                even = false, // while loop reads from the end
                xAxis = series.xAxis,
                yAxis = series.yAxis,
                i;

            // Preserve the original
            path = [].concat(path);

            // Do the translation
            i = path.length;
            while (i--) {
                if (typeof path[i] === 'number') {
                    if (even) { // even = x
                        path[i] = Math.round(xAxis.translate(path[i]));
                    } else { // odd = Y
                        path[i] = Math.round(yAxis.len - yAxis.translate(path[i]));
                    }
                    even = !even;
                }
            }
            return path;
        },

        setData: function () {
            Highcharts.Series.prototype.setData.apply(this, arguments);
            this.getBox();
        },

		/**
		 * Add the path option for data points. Find the max value for color calculation.
		 */
        translate: function () {
            var series = this,
                dataMin = Number.MAX_VALUE,
                dataMax = Number.MIN_VALUE;

            series.generatePoints();

            each(series.data, function (point) {
                point.shapeType = 'path';
                point.shapeArgs = {
                    d: series.translatePath(point.path)
                };

                // TODO: do point colors in drawPoints instead of point.init
                if (typeof point.y === 'number') {
                    if (point.y > dataMax) {
                        dataMax = point.y;
                    } else if (point.y < dataMin) {
                        dataMin = point.y;
                    }
                }
            });

            series.translateColors(dataMin, dataMax);
        },

		/**
		 * In choropleth maps, the color is a result of the value, so this needs translation too
		 */
        translateColors: function (dataMin, dataMax) {
            var seriesOptions = this.options,
                valueRanges = seriesOptions.valueRanges,
                colorRange = seriesOptions.colorRange,
                colorKey = this.colorKey,
                from,
                to;

            if (colorRange) {
                from = Color(colorRange.from);
                to = Color(colorRange.to);
            }

            each(this.data, function (point) {
                var value = point[colorKey],
                    range,
                    color,
                    i,
                    pos;

                if (valueRanges) {
                    i = valueRanges.length;
                    while (i--) {
                        range = valueRanges[i];
                        from = range.from;
                        to = range.to;
                        if ((from === UNDEFINED || value >= from) && (to === UNDEFINED || value <= to)) {
                            color = range.color;
                            break;
                        }
                    }
                } else if (colorRange && value !== undefined) {
                    pos = 1 - ((dataMax - value) / (dataMax - dataMin));
                    color = value === null ? seriesOptions.nullColor : tweenColors(from, to, pos);
                }

                if (color) {
                    point.color = null; // reset from previous drilldowns, use of the same data options
                    point.options.color = color;
                }
            });
        },

        drawGraph: noop,

		/**
		 * We need the points' bounding boxes in order to draw the data labels, so
		 * we skip it now and call if from drawPoints instead.
		 */
        drawDataLabels: noop,

		/**
		 * Use the drawPoints method of column, that is able to handle simple shapeArgs.
		 * Extend it by assigning the tooltip position.
		 */
        drawPoints: function () {
            var series = this,
                xAxis = series.xAxis,
                yAxis = series.yAxis,
                colorKey = series.colorKey;

            // Make points pass test in drawing
            each(series.data, function (point) {
                point.plotY = 1; // pass null test in column.drawPoints
                if (point[colorKey] === null) {
                    point[colorKey] = 0;
                    point.isNull = true;
                }
            });

            // Draw them
            seriesTypes.column.prototype.drawPoints.apply(series);

            each(series.data, function (point) {
                var dataLabels = point.dataLabels,
                    minX = xAxis.toPixels(point._minX, true),
                    maxX = xAxis.toPixels(point._maxX, true),
                    minY = yAxis.toPixels(point._minY, true),
                    maxY = yAxis.toPixels(point._maxY, true);

                point.plotX = Math.round(minX + (maxX - minX) * pick(dataLabels && dataLabels.anchorX, 0.5));
                point.plotY = Math.round(minY + (maxY - minY) * pick(dataLabels && dataLabels.anchorY, 0.5));

                // Reset escaped null points
                if (point.isNull) {
                    point[colorKey] = null;
                }
            });

            // Now draw the data labels
            Highcharts.Series.prototype.drawDataLabels.call(series);
        },

		/**
		 * Animate in the new series from the clicked point in the old series.
		 * Depends on the drilldown.js module
		 */
        animateDrilldown: function (init) {
            var toBox = this.chart.plotBox,
                level = this.chart.drilldownLevels[this.chart.drilldownLevels.length - 1],
                fromBox = level.bBox,
                animationOptions = this.chart.options.drilldown.animation,
                scale;

            if (!init) {
                scale = Math.min(fromBox.width / toBox.width, fromBox.height / toBox.height);
                level.shapeArgs = {
                    scaleX: scale,
                    scaleY: scale,
                    translateX: fromBox.x,
                    translateY: fromBox.y
                };

                // TODO: Animate this.group instead
                each(this.points, function (point) {
                    point.graphic
                        .attr(level.shapeArgs)
                        .animate({
                            scaleX: 1,
                            scaleY: 1,
                            translateX: 0,
                            translateY: 0
                        }, animationOptions);
                });

                delete this.animate;
            }
        },

		/**
		 * When drilling up, pull out the individual point graphics from the lower series
		 * and animate them into the origin point in the upper series.
		 */
        animateDrillupFrom: function (level) {
            seriesTypes.column.prototype.animateDrillupFrom.call(this, level);
        },

		/**
		 * When drilling up, keep the upper series invisible until the lower series has
		 * moved into place
		 */
        animateDrillupTo: function (init) {
            seriesTypes.column.prototype.animateDrillupTo.call(this, init);
        }
    });

    // The mapline series type
    plotOptions.mapline = merge(plotOptions.map, {
        lineWidth: 1,
        backgroundColor: 'none'
    });
    seriesTypes.mapline = Highcharts.extendClass(seriesTypes.map, {
        type: 'mapline',
        pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
            stroke: 'color',
            'stroke-width': 'lineWidth',
            fill: 'backgroundColor'
        },
        drawLegendSymbol: seriesTypes.line.prototype.drawLegendSymbol
    });

    // The mappoint series type
    plotOptions.mappoint = merge(plotOptions.scatter, {
        dataLabels: {
            enabled: true,
            format: '{point.name}',
            color: 'black',
            style: {
                textShadow: '0 0 5px white'
            }
        }
    });
    seriesTypes.mappoint = Highcharts.extendClass(seriesTypes.scatter, {
        type: 'mappoint'
    });

	/**
	 * A wrapper for Chart with all the default values for a Map
	 */
    Highcharts.Map = function (options, callback) {
        var hiddenAxis = {
            endOnTick: false,
            gridLineWidth: 0,
            labels: {
                enabled: false
            },
            lineWidth: 0,
            minPadding: 0,
            maxPadding: 0,
            startOnTick: false,
            tickWidth: 0,
            title: null
        },
            seriesOptions;

        // Don't merge the data
        seriesOptions = options.series;
        options.series = null;

        options = merge({
            chart: {
                type: 'map',
                panning: 'xy'
            },
            xAxis: hiddenAxis,
            yAxis: merge(hiddenAxis, { reversed: true })
        },
            options, // user's options

            { // forced options
                chart: {
                    inverted: false
                }
            });

        options.series = seriesOptions;

        return new Highcharts.Chart(options, callback);
    };
}(Highcharts));