/**
 * @license Highcharts JS v3.0.6 (2013-10-04)
 * Exporting module
 *
 * (c) 2010-2013 Torstein Hønsi
 *
 * License: www.highcharts.com/license
 */

// JSLint options:
/*global Highcharts, document, window, Math, setTimeout */

(function (Highcharts) {
  // encapsulate

  // create shortcuts
  var Chart = Highcharts.Chart,
    addEvent = Highcharts.addEvent,
    removeEvent = Highcharts.removeEvent,
    createElement = Highcharts.createElement,
    discardElement = Highcharts.discardElement,
    css = Highcharts.css,
    merge = Highcharts.merge,
    each = Highcharts.each,
    extend = Highcharts.extend,
    math = Math,
    mathMax = math.max,
    doc = document,
    win = window,
    isTouchDevice = Highcharts.isTouchDevice,
    M = 'M',
    L = 'L',
    DIV = 'div',
    HIDDEN = 'hidden',
    NONE = 'none',
    PREFIX = 'highcharts-',
    ABSOLUTE = 'absolute',
    PX = 'px',
    UNDEFINED,
    symbols = Highcharts.Renderer.prototype.symbols,
    defaultOptions = Highcharts.getOptions(),
    buttonOffset;

  // Add language
  extend(defaultOptions.lang, {
    printChart: 'Print chart',
    downloadPNG: 'Download PNG image',
    downloadJPEG: 'Download JPEG image',
    downloadPDF: 'Download PDF document',
    downloadSVG: 'Download SVG vector image',
    contextButtonTitle: 'Chart context menu',
  });

  // Buttons and menus are collected in a separate config option set called 'navigation'.
  // This can be extended later to add control buttons like zoom and pan right click menus.
  defaultOptions.navigation = {
    menuStyle: {
      border: '1px solid #A0A0A0',
      background: '#FFFFFF',
      padding: '5px 0',
    },
    menuItemStyle: {
      padding: '0 10px',
      background: NONE,
      color: '#303030',
      fontSize: isTouchDevice ? '14px' : '11px',
    },
    menuItemHoverStyle: {
      background: '#4572A5',
      color: '#FFFFFF',
    },

    buttonOptions: {
      symbolFill: '#E0E0E0',
      symbolSize: 14,
      symbolStroke: '#666',
      symbolStrokeWidth: 3,
      symbolX: 12.5,
      symbolY: 10.5,
      align: 'right',
      buttonSpacing: 3,
      height: 22,
      // text: null,
      theme: {
        fill: 'white', // capture hover
        stroke: 'none',
      },
      verticalAlign: 'top',
      width: 24,
    },
  };

  // Add the export related options
  defaultOptions.exporting = {
    //enabled: true,
    //filename: 'chart',
    type: 'image/png',
    url: 'http://export.highcharts.com/',
    //width: undefined,
    //scale: 2
    buttons: {
      contextButton: {
        menuClassName: PREFIX + 'contextmenu',
        //x: -10,
        symbol: 'menu',
        _titleKey: 'contextButtonTitle',
        menuItems: [
          {
            textKey: 'printChart',
            onclick: function () {
              this.print();
            },
          },
          {
            separator: true,
          },
          {
            textKey: 'downloadPNG',
            onclick: function () {
              this.exportChart();
            },
          },
          {
            textKey: 'downloadJPEG',
            onclick: function () {
              this.exportChart({
                type: 'image/jpeg',
              });
            },
          },
          {
            textKey: 'downloadPDF',
            onclick: function () {
              this.exportChart({
                type: 'application/pdf',
              });
            },
          },
          {
            textKey: 'downloadSVG',
            onclick: function () {
              this.exportChart({
                type: 'image/svg+xml',
              });
            },
          },
          // Enable this block to add "View SVG" to the dropdown menu
          /*
			,{

				text: 'View SVG',
				onclick: function () {
					var svg = this.getSVG()
						.replace(/</g, '\n&lt;')
						.replace(/>/g, '&gt;');

					doc.body.innerHTML = '<pre>' + svg + '</pre>';
				}
			} // */
        ],
      },
    },
  };

  // Add the Highcharts.post utility
  Highcharts.post = function (url, data) {
    var name, form;

    // create the form
    form = createElement(
      'form',
      {
        method: 'post',
        action: url,
        enctype: 'multipart/form-data',
      },
      {
        display: NONE,
      },
      doc.body,
    );

    // add the data
    for (name in data) {
      createElement(
        'input',
        {
          type: HIDDEN,
          name: name,
          value: data[name],
        },
        null,
        form,
      );
    }

    // submit
    form.submit();

    // clean up
    discardElement(form);
  };

  extend(Chart.prototype, {
    /**
     * Return an SVG representation of the chart
     *
     * @param additionalOptions {Object} Additional chart options for the generated SVG representation
     */
    getSVG: function (additionalOptions) {
      var chart = this,
        chartCopy,
        sandbox,
        svg,
        seriesOptions,
        sourceWidth,
        sourceHeight,
        cssWidth,
        cssHeight,
        options = merge(chart.options, additionalOptions); // copy the options and add extra options

      // IE compatibility hack for generating SVG content that it doesn't really understand
      if (!doc.createElementNS) {
        /*jslint unparam: true*/ /* allow unused parameter ns in function below */
        doc.createElementNS = function (ns, tagName) {
          return doc.createElement(tagName);
        };
        /*jslint unparam: false*/
      }

      // create a sandbox where a new chart will be generated
      sandbox = createElement(
        DIV,
        null,
        {
          position: ABSOLUTE,
          top: '-9999em',
          width: chart.chartWidth + PX,
          height: chart.chartHeight + PX,
        },
        doc.body,
      );

      // get the source size
      cssWidth = chart.renderTo.style.width;
      cssHeight = chart.renderTo.style.height;
      sourceWidth =
        options.exporting.sourceWidth ||
        options.chart.width ||
        (/px$/.test(cssWidth) && parseInt(cssWidth, 10)) ||
        600;
      sourceHeight =
        options.exporting.sourceHeight ||
        options.chart.height ||
        (/px$/.test(cssHeight) && parseInt(cssHeight, 10)) ||
        400;

      // override some options
      extend(options.chart, {
        animation: false,
        renderTo: sandbox,
        forExport: true,
        width: sourceWidth,
        height: sourceHeight,
      });
      options.exporting.enabled = false; // hide buttons in print

      // prepare for replicating the chart
      options.series = [];
      each(chart.series, function (serie) {
        seriesOptions = merge(serie.options, {
          animation: false, // turn off animation
          showCheckbox: false,
          visible: serie.visible,
        });

        if (!seriesOptions.isInternal) {
          // used for the navigator series that has its own option set
          options.series.push(seriesOptions);
        }
      });

      // generate the chart copy
      chartCopy = new Highcharts.Chart(options, chart.callback);

      // reflect axis extremes in the export
      each(['xAxis', 'yAxis'], function (axisType) {
        each(chart[axisType], function (axis, i) {
          var axisCopy = chartCopy[axisType][i],
            extremes = axis.getExtremes(),
            userMin = extremes.userMin,
            userMax = extremes.userMax;

          if (axisCopy && (userMin !== UNDEFINED || userMax !== UNDEFINED)) {
            axisCopy.setExtremes(userMin, userMax, true, false);
          }
        });
      });

      // get the SVG from the container's innerHTML
      svg = chartCopy.container.innerHTML;

      // free up memory
      options = null;
      chartCopy.destroy();
      discardElement(sandbox);

      // sanitize
      svg = svg
        .replace(/zIndex="[^"]+"/g, '')
        .replace(/isShadow="[^"]+"/g, '')
        .replace(/symbolName="[^"]+"/g, '')
        .replace(/jQuery[0-9]+="[^"]+"/g, '')
        .replace(/url\([^#]+#/g, 'url(#')
        .replace(/<svg /, '<svg xmlns:xlink="http://www.w3.org/1999/xlink" ')
        .replace(/ href=/g, ' xlink:href=')
        .replace(/\n/, ' ')
        .replace(/<\/svg>.*?$/, '</svg>') // any HTML added to the container after the SVG (#894)
        /* This fails in IE < 8
			.replace(/([0-9]+)\.([0-9]+)/g, function(s1, s2, s3) { // round off to save weight
				return s2 +'.'+ s3[0];
			})*/

        // Replace HTML entities, issue #347
        .replace(/&nbsp;/g, '\u00A0') // no-break space
        .replace(/&shy;/g, '\u00AD') // soft hyphen

        // IE specific
        .replace(/<IMG /g, '<image ')
        .replace(/height=([^" ]+)/g, 'height="$1"')
        .replace(/width=([^" ]+)/g, 'width="$1"')
        .replace(/hc-svg-href="([^"]+)">/g, 'xlink:href="$1"/>')
        .replace(/id=([^" >]+)/g, 'id="$1"')
        .replace(/class=([^" >]+)/g, 'class="$1"')
        .replace(/ transform /g, ' ')
        .replace(/:(path|rect)/g, '$1')
        .replace(/style="([^"]+)"/g, function (s) {
          return s.toLowerCase();
        });

      // IE9 beta bugs with innerHTML. Test again with final IE9.
      svg = svg.replace(/(url\(#highcharts-[0-9]+)&quot;/g, '$1').replace(/&quot;/g, "'");

      return svg;
    },

    /**
     * Submit the SVG representation of the chart to the server
     * @param {Object} options Exporting options. Possible members are url, type and width.
     * @param {Object} chartOptions Additional chart options for the SVG representation of the chart
     */
    exportChart: function (options, chartOptions) {
      options = options || {};

      var chart = this,
        chartExportingOptions = chart.options.exporting,
        svg = chart.getSVG(
          merge({ chart: { borderRadius: 0 } }, chartExportingOptions.chartOptions, chartOptions, {
            exporting: {
              sourceWidth: options.sourceWidth || chartExportingOptions.sourceWidth,
              sourceHeight: options.sourceHeight || chartExportingOptions.sourceHeight,
            },
          }),
        );

      // merge the options
      options = merge(chart.options.exporting, options);

      // do the post
      Highcharts.post(options.url, {
        filename: options.filename || 'chart',
        type: options.type,
        width: options.width || 0, // IE8 fails to post undefined correctly, so use 0
        scale: options.scale || 2,
        svg: svg,
      });
    },

    /**
     * Print the chart
     */
    print: function () {
      var chart = this,
        container = chart.container,
        origDisplay = [],
        origParent = container.parentNode,
        body = doc.body,
        childNodes = body.childNodes;

      if (chart.isPrinting) {
        // block the button while in printing mode
        return;
      }

      chart.isPrinting = true;

      // hide all body content
      each(childNodes, function (node, i) {
        if (node.nodeType === 1) {
          origDisplay[i] = node.style.display;
          node.style.display = NONE;
        }
      });

      // pull out the chart
      body.appendChild(container);

      // print
      win.focus(); // #1510
      win.print();

      // allow the browser to prepare before reverting
      setTimeout(function () {
        // put the chart back in
        origParent.appendChild(container);

        // restore all body content
        each(childNodes, function (node, i) {
          if (node.nodeType === 1) {
            node.style.display = origDisplay[i];
          }
        });

        chart.isPrinting = false;
      }, 1000);
    },

    /**
     * Display a popup menu for choosing the export type
     *
     * @param {String} className An identifier for the menu
     * @param {Array} items A collection with text and onclicks for the items
     * @param {Number} x The x position of the opener button
     * @param {Number} y The y position of the opener button
     * @param {Number} width The width of the opener button
     * @param {Number} height The height of the opener button
     */
    contextMenu: function (className, items, x, y, width, height, button) {
      var chart = this,
        navOptions = chart.options.navigation,
        menuItemStyle = navOptions.menuItemStyle,
        chartWidth = chart.chartWidth,
        chartHeight = chart.chartHeight,
        cacheName = 'cache-' + className,
        menu = chart[cacheName],
        menuPadding = mathMax(width, height), // for mouse leave detection
        boxShadow = '3px 3px 10px #888',
        innerMenu,
        hide,
        hideTimer,
        menuStyle;

      // create the menu only the first time
      if (!menu) {
        // create a HTML element above the SVG
        chart[cacheName] = menu = createElement(
          DIV,
          {
            className: className,
          },
          {
            position: ABSOLUTE,
            zIndex: 1000,
            padding: menuPadding + PX,
          },
          chart.container,
        );

        innerMenu = createElement(
          DIV,
          null,
          extend(
            {
              MozBoxShadow: boxShadow,
              WebkitBoxShadow: boxShadow,
              boxShadow: boxShadow,
            },
            navOptions.menuStyle,
          ),
          menu,
        );

        // hide on mouse out
        hide = function () {
          css(menu, { display: NONE });
          if (button) {
            button.setState(0);
          }
          chart.openMenu = false;
        };

        // Hide the menu some time after mouse leave (#1357)
        addEvent(menu, 'mouseleave', function () {
          hideTimer = setTimeout(hide, 500);
        });
        addEvent(menu, 'mouseenter', function () {
          clearTimeout(hideTimer);
        });
        // Hide it on clicking or touching outside the menu (#2258)
        addEvent(document, 'mousedown', function (e) {
          if (!chart.pointer.inClass(e.target, className)) {
            hide();
          }
        });

        // create the items
        each(items, function (item) {
          if (item) {
            var element = item.separator
              ? createElement('hr', null, null, innerMenu)
              : createElement(
                  DIV,
                  {
                    onmouseover: function () {
                      css(this, navOptions.menuItemHoverStyle);
                    },
                    onmouseout: function () {
                      css(this, menuItemStyle);
                    },
                    onclick: function () {
                      hide();
                      item.onclick.apply(chart, arguments);
                    },
                    innerHTML: item.text || chart.options.lang[item.textKey],
                  },
                  extend(
                    {
                      cursor: 'pointer',
                    },
                    menuItemStyle,
                  ),
                  innerMenu,
                );

            // Keep references to menu divs to be able to destroy them
            chart.exportDivElements.push(element);
          }
        });

        // Keep references to menu and innerMenu div to be able to destroy them
        chart.exportDivElements.push(innerMenu, menu);

        chart.exportMenuWidth = menu.offsetWidth;
        chart.exportMenuHeight = menu.offsetHeight;
      }

      menuStyle = { display: 'block' };

      // if outside right, right align it
      if (x + chart.exportMenuWidth > chartWidth) {
        menuStyle.right = chartWidth - x - width - menuPadding + PX;
      } else {
        menuStyle.left = x - menuPadding + PX;
      }
      // if outside bottom, bottom align it
      if (
        y + height + chart.exportMenuHeight > chartHeight &&
        button.alignOptions.verticalAlign !== 'top'
      ) {
        menuStyle.bottom = chartHeight - y - menuPadding + PX;
      } else {
        menuStyle.top = y + height - menuPadding + PX;
      }

      css(menu, menuStyle);
      chart.openMenu = true;
    },

    /**
     * Add the export button to the chart
     */
    addButton: function (options) {
      var chart = this,
        renderer = chart.renderer,
        btnOptions = merge(chart.options.navigation.buttonOptions, options),
        onclick = btnOptions.onclick,
        menuItems = btnOptions.menuItems,
        symbol,
        button,
        symbolAttr = {
          stroke: btnOptions.symbolStroke,
          fill: btnOptions.symbolFill,
        },
        symbolSize = btnOptions.symbolSize || 12;
      if (!chart.btnCount) {
        chart.btnCount = 0;
      }

      // Keeps references to the button elements
      if (!chart.exportDivElements) {
        chart.exportDivElements = [];
        chart.exportSVGElements = [];
      }

      if (btnOptions.enabled === false) {
        return;
      }

      var attr = btnOptions.theme,
        states = attr.states,
        hover = states && states.hover,
        select = states && states.select,
        callback;

      delete attr.states;

      if (onclick) {
        callback = function () {
          onclick.apply(chart, arguments);
        };
      } else if (menuItems) {
        callback = function () {
          chart.contextMenu(
            button.menuClassName,
            menuItems,
            button.translateX,
            button.translateY,
            button.width,
            button.height,
            button,
          );
          button.setState(2);
        };
      }

      if (btnOptions.text && btnOptions.symbol) {
        attr.paddingLeft = Highcharts.pick(attr.paddingLeft, 25);
      } else if (!btnOptions.text) {
        extend(attr, {
          width: btnOptions.width,
          height: btnOptions.height,
          padding: 0,
        });
      }

      button = renderer.button(btnOptions.text, 0, 0, callback, attr, hover, select).attr({
        title: chart.options.lang[btnOptions._titleKey],
        'stroke-linecap': 'round',
      });
      button.menuClassName = options.menuClassName || PREFIX + 'menu-' + chart.btnCount++;

      if (btnOptions.symbol) {
        symbol = renderer
          .symbol(
            btnOptions.symbol,
            btnOptions.symbolX - symbolSize / 2,
            btnOptions.symbolY - symbolSize / 2,
            symbolSize,
            symbolSize,
          )
          .attr(
            extend(symbolAttr, {
              'stroke-width': btnOptions.symbolStrokeWidth || 1,
              zIndex: 1,
            }),
          )
          .add(button);
      }

      button.add().align(
        extend(btnOptions, {
          width: button.width,
          x: Highcharts.pick(btnOptions.x, buttonOffset), // #1654
        }),
        true,
        'spacingBox',
      );

      buttonOffset +=
        (button.width + btnOptions.buttonSpacing) * (btnOptions.align === 'right' ? -1 : 1);

      chart.exportSVGElements.push(button, symbol);
    },

    /**
     * Destroy the buttons.
     */
    destroyExport: function (e) {
      var chart = e.target,
        i,
        elem;

      // Destroy the extra buttons added
      for (i = 0; i < chart.exportSVGElements.length; i++) {
        elem = chart.exportSVGElements[i];

        // Destroy and null the svg/vml elements
        if (elem) {
          // #1822
          elem.onclick = elem.ontouchstart = null;
          chart.exportSVGElements[i] = elem.destroy();
        }
      }

      // Destroy the divs for the menu
      for (i = 0; i < chart.exportDivElements.length; i++) {
        elem = chart.exportDivElements[i];

        // Remove the event handler
        removeEvent(elem, 'mouseleave');

        // Remove inline events
        chart.exportDivElements[i] =
          elem.onmouseout =
          elem.onmouseover =
          elem.ontouchstart =
          elem.onclick =
            null;

        // Destroy the div by moving to garbage bin
        discardElement(elem);
      }
    },
  });

  symbols.menu = function (x, y, width, height) {
    var arr = [
      M,
      x,
      y + 2.5,
      L,
      x + width,
      y + 2.5,
      M,
      x,
      y + height / 2 + 0.5,
      L,
      x + width,
      y + height / 2 + 0.5,
      M,
      x,
      y + height - 1.5,
      L,
      x + width,
      y + height - 1.5,
    ];
    return arr;
  };

  // Add the buttons on chart load
  Chart.prototype.callbacks.push(function (chart) {
    var n,
      exportingOptions = chart.options.exporting,
      buttons = exportingOptions.buttons;

    buttonOffset = 0;

    if (exportingOptions.enabled !== false) {
      for (n in buttons) {
        chart.addButton(buttons[n]);
      }

      // Destroy the export elements at chart destroy
      addEvent(chart, 'destroy', chart.destroyExport);
    }
  });
})(Highcharts);