/**
   * @license 
   * Highcharts funnel module, Beta
   *
   * (c) 2010-2012 Torstein Hønsi
   *
   * License: www.highcharts.com/license
   */
  
  /*global Highcharts */
  (function (Highcharts) {
  	
  'use strict';
  
  // create shortcuts
  var defaultOptions = Highcharts.getOptions(),
  	defaultPlotOptions = defaultOptions.plotOptions,
  	seriesTypes = Highcharts.seriesTypes,
  	merge = Highcharts.merge,
  	noop = function () {},
  	each = Highcharts.each;
  
  // set default options
  defaultPlotOptions.funnel = merge(defaultPlotOptions.pie, {
  	center: ['50%', '50%'],
  	width: '90%',
  	neckWidth: '30%',
  	height: '100%',
  	neckHeight: '25%',
  
  	dataLabels: {
  		//position: 'right',
  		connectorWidth: 1,
  		connectorColor: '#606060'
  	},
  	size: true, // to avoid adapting to data label size in Pie.drawDataLabels
  	states: {
  		select: {
  			color: '#C0C0C0',
  			borderColor: '#000000',
  			shadow: false
  		}
  	}	
  });
  
  
  seriesTypes.funnel = Highcharts.extendClass(seriesTypes.pie, {
  	
  	type: 'funnel',
  	animate: noop,
  
  	/**
  	 * Overrides the pie translate method
  	 */
  	translate: function () {
  		
  		var 
  			// Get positions - either an integer or a percentage string must be given
  			getLength = function (length, relativeTo) {
  				return (/%$/).test(length) ?
  					relativeTo * parseInt(length, 10) / 100 :
  					parseInt(length, 10);
  			},
  			
  			sum = 0,
  			series = this,
  			chart = series.chart,
  			plotWidth = chart.plotWidth,
  			plotHeight = chart.plotHeight,
  			cumulative = 0, // start at top
  			options = series.options,
  			center = options.center,
  			centerX = getLength(center[0], plotWidth),
  			centerY = getLength(center[0], plotHeight),
  			width = getLength(options.width, plotWidth),
  			tempWidth,
  			getWidthAt,
  			height = getLength(options.height, plotHeight),
  			neckWidth = getLength(options.neckWidth, plotWidth),
  			neckHeight = getLength(options.neckHeight, plotHeight),
  			neckY = height - neckHeight,
  			data = series.data,
  			path,
  			fraction,
  			half = options.dataLabels.position === 'left' ? 1 : 0,
  
  			x1, 
  			y1, 
  			x2, 
  			x3, 
  			y3, 
  			x4, 
  			y5;
  
  		// Return the width at a specific y coordinate
  		series.getWidthAt = getWidthAt = function (y) {
  			return y > height - neckHeight || height === neckHeight ?
  				neckWidth :
  				neckWidth + (width - neckWidth) * ((height - neckHeight - y) / (height - neckHeight));
  		};
  		series.getX = function (y, half) {
  			return centerX + (half ? -1 : 1) * ((getWidthAt(y) / 2) + options.dataLabels.distance);
  		};
  
  		// Expose
  		series.center = [centerX, centerY, height];
  		series.centerX = centerX;
  
  		/*
  		 * Individual point coordinate naming:
  		 *
  		 * x1,y1 _________________ x2,y1
  		 *  \                         /
  		 *   \                       /
  		 *    \                     /
  		 *     \                   /
  		 *      \                 /
  		 *     x3,y3 _________ x4,y3
  		 *
  		 * Additional for the base of the neck:
  		 *
  		 *       |               |
  		 *       |               |
  		 *       |               |
  		 *     x3,y5 _________ x4,y5
  		 */
  
  
  
  
  		// get the total sum
  		each(data, function (point) {
  			sum += point.y;
  		});
  
  		each(data, function (point) {
  			// set start and end positions
  			y5 = null;
  			fraction = sum ? point.y / sum : 0;
  			y1 = centerY - height / 2 + cumulative * height;
  			y3 = y1 + fraction * height;
  			//tempWidth = neckWidth + (width - neckWidth) * ((height - neckHeight - y1) / (height - neckHeight));
  			tempWidth = getWidthAt(y1);
  			x1 = centerX - tempWidth / 2;
  			x2 = x1 + tempWidth;
  			tempWidth = getWidthAt(y3);
  			x3 = centerX - tempWidth / 2;
  			x4 = x3 + tempWidth;
  
  			// the entire point is within the neck
  			if (y1 > neckY) {
  				x1 = x3 = centerX - neckWidth / 2;
  				x2 = x4 = centerX + neckWidth / 2;
  			
  			// the base of the neck
  			} else if (y3 > neckY) {
  				y5 = y3;
  
  				tempWidth = getWidthAt(neckY);
  				x3 = centerX - tempWidth / 2;
  				x4 = x3 + tempWidth;
  
  				y3 = neckY;
  			}
  
  			// save the path
  			path = [
  				'M',
  				x1, y1,
  				'L',
  				x2, y1,
  				x4, y3
  			];
  			if (y5) {
  				path.push(x4, y5, x3, y5);
  			}
  			path.push(x3, y3, 'Z');
  
  			// prepare for using shared dr
  			point.shapeType = 'path';
  			point.shapeArgs = { d: path };
  
  
  			// for tooltips and data labels
  			point.percentage = fraction * 100;
  			point.plotX = centerX;
  			point.plotY = (y1 + (y5 || y3)) / 2;
  
  			// Placement of tooltips and data labels
  			point.tooltipPos = [
  				centerX,
  				point.plotY
  			];
  
  			// Slice is a noop on funnel points
  			point.slice = noop;
  			
  			// Mimicking pie data label placement logic
  			point.half = half;
  
  			cumulative += fraction;
  		});
  
  
  		series.setTooltipPoints();
  	},
  	/**
  	 * Draw a single point (wedge)
  	 * @param {Object} point The point object
  	 * @param {Object} color The color of the point
  	 * @param {Number} brightness The brightness relative to the color
  	 */
  	drawPoints: function () {
  		var series = this,
  			options = series.options,
  			chart = series.chart,
  			renderer = chart.renderer;
  
  		each(series.data, function (point) {
  			
  			var graphic = point.graphic,
  				shapeArgs = point.shapeArgs;
  
  			if (!graphic) { // Create the shapes
  				point.graphic = renderer.path(shapeArgs).
  					attr({
  						fill: point.color,
  						stroke: options.borderColor,
  						'stroke-width': options.borderWidth
  					}).
  					add(series.group);
  					
  			} else { // Update the shapes
  				graphic.animate(shapeArgs);
  			}
  		});
  	},
  
  	/**
  	 * Funnel items don't have angles (#2289)
  	 */
  	sortByAngle: noop,
  	
  	/**
  	 * Extend the pie data label method
  	 */
  	drawDataLabels: function () {
  		var data = this.data,
  			labelDistance = this.options.dataLabels.distance,
  			leftSide,
  			sign,
  			point,
  			i = data.length,
  			x,
  			y;
  		
  		// In the original pie label anticollision logic, the slots are distributed
  		// from one labelDistance above to one labelDistance below the pie. In funnels
  		// we don't want this.
  		this.center[2] -= 2 * labelDistance;
  		
  		// Set the label position array for each point.
  		while (i--) {
  			point = data[i];
  			leftSide = point.half;
  			sign = leftSide ? 1 : -1;
  			y = point.plotY;
  			x = this.getX(y, leftSide);
  				
  			// set the anchor point for data labels
  			point.labelPos = [
  				0, // first break of connector
  				y, // a/a
  				x + (labelDistance - 5) * sign, // second break, right outside point shape
  				y, // a/a
  				x + labelDistance * sign, // landing point for connector
  				y, // a/a
  				leftSide ? 'right' : 'left', // alignment
  				0 // center angle
  			];
  		}
  		
  		seriesTypes.pie.prototype.drawDataLabels.call(this);
  	}
  
  });
  
  
  }(Highcharts));