/**
*	com.jR.Drawing.Polygon
*	March 14th, 2006
*	Copyright (c) Jānis Radiņš ( janis@mediaverk.lv )
* 
*	This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
*	License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.
* 
*	This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
*	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
* 
*	You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software
*	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/
import com.jR.Utils;
class com.jR.Drawing.Polygon extends com.jR.Drawing.Base {
	private var _drawX:Number = 0;
	private var _drawY:Number = 0;
	private var _roundCorners:Boolean = true;
	private var _passAnchors:Boolean = false;
	private var _join:Boolean = true;
	private var _showLine:Boolean = true; 
	private var _points:Array = null;
	private var _drawPoints:Array = null;
	private var _radius:Number = null;
	private var bounds:Object;
	private var useLineTo:Boolean;
	public function Polygon(host:MovieClip, level:Number) {
		if(host == undefined){
			throwError("No host provided for Poligon object", false)
		}
		if (level === undefined) {
			level = host.getNextHighestDepth();
		}
		_mc = host.createEmptyMovieClip("polygon_"+level, level);
		_points = new Array();
	}
	public function get drawX():Number {
		return _drawX;
	}
	public function get drawY():Number {
		return _drawY;
	}
	public function get roundCorners():Boolean {
		return _roundCorners;
	}
	public function get passAnchors():Boolean {
		return _passAnchors;
	}
	public function get join():Boolean {
		return _join;
	}
	public function get showLine():Boolean {
		return _showLine;
	}
	public function get points():Array {
		return _points;
	}
	public function get drawPoints():Array {
		return _drawPoints;
	}
	public function get radius():Number {
		for(var i:Number = 0; i<_points.length; i++){
			if(_points[i].r != _points[0].r){
				return null;
			}
		}
		return _points[0].r;
	}
	public function set drawX(value:Number):Void {
		_drawX = value;
	}
	public function set drawY(value:Number):Void {
		_drawY = value;
	}
	public function set roundCorners(value:Boolean):Void {
		_roundCorners = value;
	}
	public function set passAnchors(value:Boolean):Void {
		_passAnchors = value;
	}
	public function set join(value:Boolean):Void {
		_join = value;
	}
	public function set showLine(value:Boolean):Void {
		_showLine = value;
	}
	public function set points(value:Array):Void {
		_points = value;
	}
	public function set radius(value:Number):Void {
		_radius = value;
		for(var i:Number = 0; i<_points.length; i++){
			_points[i].r = _radius;
		}
	}
	public function addPoint(x:Number, y:Number, r:Number):Void {
		_points.push({x:x, y:y, r:(isNaN(r) == true ? 0 : r)});
	}
	public function removePoint(index:Number):Void {
		if (index<0 || index>=_points.length) {
			return;
		}
		_points.splice(index, 1);
	}
	public function modifyPoint(index:Number, propertys:Object):Void {
		if (index<0 || index>=_points.length) {
			return;
		}
		for (var i in propertys) {
			_points[index][i] = propertys[i];
		}
	}
	public function clearPoints(Void):Void {
		_points = new Array();
	}
	public function reset(Void):Void {
		super.reset();
		clear();
		_drawX = 0;
		_drawY = 0;
		_roundCorners = true;
		_join = true;
		_showLine = true;
		_points = new Array();
	}
	private function calcBounds(Void):Void {
		bounds = new Object();
		var xMin:Number = _drawPoints[0].x;
		var xMax:Number = _drawPoints[0].x;
		var yMin:Number = _drawPoints[0].y;
		var yMax:Number = _drawPoints[0].y;
		var __compare:Function = function (point:Object):Void {
			if (point.x<xMin)	xMin = point.x;
			if (point.x>xMax)	xMax = point.x;
			if (point.y<yMin)	yMin = point.y;
			if (point.y>yMax)	yMax = point.y;
		};
		for (var i = 1; i<_drawPoints.length; i++) {
			if (_drawPoints[i] instanceof Array == true) {
				__compare(_drawPoints[i][0]);
				__compare(_drawPoints[i][1]);
				continue;
			}
			__compare(_drawPoints[i]);
		}
		bounds = {xMin:xMin, xMax:xMax, yMin:yMin, yMax:yMax};
	}
	private function dealArguments(__inputObject:Object):Void {
		if (_autoClear == true) {
			clear();
		}
		for (var i in __inputObject) {
			if (this["_"+i] !== undefined && this[i] !== undefined) {
				this[i] = __inputObject[i];
			}
		}
	}
	public function drawOutline(__props:Object):Void {
		dealArguments(__props);
		calculatePoints();
		applyLineStyle(true);
		draw();
	}
	public function drawSolid(__props:Object):Void {
		dealArguments(__props);
		calculatePoints();
		applyLineStyle();
		beginFill();
		draw();
		endFill();
	}
	public function drawGradient(__props:Object):Void {
		dealArguments(__props);
		calculatePoints();
		if (_skewX != 0 || _skewY != 0 || _rotation != 0) {
			calcBounds();
		}
		if (_rotation != 0 && _gradientType == "radial") {
			_gradientX = _drawX+bounds.xMin+(bounds.xMax-bounds.xMin)/2;
			_gradientY = _drawY+bounds.yMin+(bounds.yMax-bounds.yMin)/2;
		} else {
			_gradientX = _drawX+bounds.xMin;
			_gradientY = _drawY+bounds.yMin;
		}
		_gradientRotation = _rotation;
		_gradientWidth = bounds.xMax-bounds.xMin;
		_gradientHeight = bounds.yMax-bounds.yMin;
		applyLineStyle();
		beginGradientFill();
		draw();
		endFill();
	}
	private function calculatePoints(Void):Void {
		_drawPoints = new Array();
		useLineTo = true;
		for (var i = 0; i<_points.length; i++) {
			if (isNaN(_points[i].r) == false && _points[i].r != 0) {
				useLineTo = false;
				_roundCorners == true ? addRPoint(i) : addCPoint(i);
			} else {
				_drawPoints.push(_points[i]);
			}
		}
		calcBounds();
		skewXBaby();
		skewYBaby();
		rotatePoints();
	}
	private function addCPoint(_index:Number, _newX:Number, _newY:Number):Void {
		var current_point:Object = _points[_index];
		if (_newX !== undefined && _newY !== undefined) {
			current_point = Utils.clone(current_point);
			current_point.x = _newX;
			current_point.y = _newY;
		}
		var prev_point:Object = _points[_index == 0 ? _points.length-1 : _index-1];
		var next_point:Object = _points[_index == _points.length-1 ? 0 : _index+1];
		var __bc:Number = Math.sqrt(Math.pow(current_point.x-next_point.x, 2)+Math.pow(current_point.y-next_point.y, 2));
		var __r:Number = current_point.r;
		var __a1:Number = Math.atan2(prev_point.y-current_point.y, prev_point.x-current_point.x);
		var __a2:Number = Math.atan2(next_point.y-current_point.y, next_point.x-current_point.x);
		var point1:Object = {x:current_point.x+__r*Math.cos(__a1), y:current_point.y+__r*Math.sin(__a1)};
		var point2:Object = {x:current_point.x+__r*Math.cos(__a2), y:current_point.y+__r*Math.sin(__a2)};
		if (_newX === undefined && _passAnchors == true) {
			addCPoint(_index, current_point.x-((point1.x+(point2.x-point1.x)/2)-current_point.x)*0.5, current_point.y-((point1.y+(point2.y-point1.y)/2)-current_point.y)*0.5);
			return;
		}
		_drawPoints.push(point1);
		_drawPoints.push([current_point, point2]);
	}
	private function addRPoint(_index:Number):Void {
		var __reverse = false;
		var current_point:Object = _points[_index];
		var prev_point:Object = _points[_index == 0 ? _points.length-1 : _index-1];
		var next_point:Object = _points[_index == _points.length-1 ? 0 : _index+1];
		var __angle1:Number = rad2deg(Math.atan2(prev_point.y-current_point.y, prev_point.x-current_point.x));
		var __angle2:Number = rad2deg(Math.atan2(next_point.y-current_point.y, next_point.x-current_point.x));
		var __radius:Number = current_point.r;
		var inner_angle, mid_angle:Number;
		if (angleDelta(__angle1, __angle2)>=180) {
			inner_angle = angleDelta(__angle2, __angle1);
			mid_angle = __angle1+angleDelta(__angle1, __angle2)/2;
		} else {
			inner_angle = angleDelta(__angle1, __angle2);
			mid_angle = __angle2+angleDelta(__angle2, __angle1)/2;
			__reverse = true;
		}
		var draw_angle:Number = 180-inner_angle;
		var sector:Array = getSectorPoints(mid_angle-draw_angle/2, mid_angle+draw_angle/2, __radius);
		if (__reverse == true) {
			sector.reverse();
		}
		var hip:Number = __radius/Math.cos(deg2rad(draw_angle/2));
		var trans_point:Object = rotatePoint(hip, 0, (mid_angle+180)%360);
		for (var i = 0; i<sector.length; i++) {
			sector[i].x += current_point.x+trans_point.x;
			sector[i].y += current_point.y+trans_point.y;
		}
		_drawPoints.push(sector.shift());
		for (var i:Number = 0; i<sector.length; i += 2) {
			_drawPoints.push([sector[i], sector[i+1]]);
		}
	}
	private function skewXBaby(Void):Void {
		if (_skewX == 0) {
			return;
		}
		var skewRatio:Number = Math.tan(_skewX);
		var maxY:Number = bounds.yMax;
		for (var i = 0; i<_drawPoints.length; i++) {
			if (_drawPoints[i] instanceof Array == true) {
				_drawPoints[i][0].x += (maxY-_drawPoints[i][0].y)*skewRatio;
				_drawPoints[i][1].x += (maxY-_drawPoints[i][1].y)*skewRatio;
				continue;
			}
			_drawPoints[i].x += (maxY-_drawPoints[i].y)*skewRatio;
		}
	}
	private function skewYBaby(Void):Void {
		if (_skewY == 0) {
			return;
		}
		var skewRatio:Number = Math.tan(_skewY);
		var minX:Number = bounds.xMin;
		for (var i = 0; i<_drawPoints.length; i++) {
			if (_drawPoints[i] instanceof Array == true) {
				_drawPoints[i][0].y += (_drawPoints[i][0].x-minX)*skewRatio;
				_drawPoints[i][1].y += (_drawPoints[i][1].x-minX)*skewRatio;
				continue;
			}
			_drawPoints[i].y += (_drawPoints[i].x-minX)*skewRatio;
		}
	}
	private function rotatePoints(Void):Void {
		if (_rotation == 0) {
			return;
		}
		for (var i = 0; i<_drawPoints.length; i++) {
			if (_drawPoints[i] instanceof Array == true) {
				_drawPoints[i][0] = rotatePoint(_drawPoints[i][0].x, _drawPoints[i][0].y, _rotation);
				_drawPoints[i][1] = rotatePoint(_drawPoints[i][1].x, _drawPoints[i][1].y, _rotation);
				continue;
			}
			_drawPoints[i] = rotatePoint(_drawPoints[i].x, _drawPoints[i].y, _rotation);
		}
	}
	private function draw(Void):Void {
		var __startPoint:Object = _drawPoints[0];
		__startPoint.x += _drawX;
		__startPoint.y += _drawY;
		_mc.moveTo(__startPoint.x, __startPoint.y);
		for (var i:Number = 1; i<_drawPoints.length; i++) {
			if (_drawPoints[i] instanceof Array == true) {
				_mc.curveTo(_drawX+_drawPoints[i][0].x, _drawY+_drawPoints[i][0].y, _drawX+_drawPoints[i][1].x, _drawY+_drawPoints[i][1].y);
				continue;
			}
			if(useLineTo == true){
				_mc.lineTo(_drawX+_drawPoints[i].x, _drawY+_drawPoints[i].y);
				continue;
			} 
			_mc.curveTo(_drawX+_drawPoints[i].x, _drawY+_drawPoints[i].y, _drawX+_drawPoints[i].x, _drawY+_drawPoints[i].y);
		}
		if (_join == true) {
			if(useLineTo == true){
				_mc.lineTo(__startPoint.x, __startPoint.y);
				break;
			} 
			_mc.curveTo(__startPoint.x, __startPoint.y, __startPoint.x, __startPoint.y);
		}
	}
}