package 
{
	import flash.display.*;
	import flash.events.Event;
	import flash.geom.Point;
	
	/**
	 * ...
	 * @author Buho29
	 */
	public class Main extends Sprite 
	{
		
		
		public function Main():void 
		{
			if (stage) init();
			else addEventListener(Event.ADDED_TO_STAGE, init);
		}
		
		private function init(e:Event = null):void 
		{
			removeEventListener(Event.ADDED_TO_STAGE, init);
			// entry point
			Builder.stage = this;
			
			var radio:int = 100;
			
			/*var cage:Cage = new Cage(radio - 10, radio, "NSNSNSNS", .5);
			var stator:Stator = new Stator(40, radio-10,"ABCABCABCABC");*/
			
			var cage:Cage = new Cage(radio - 10, radio, "NS", .5);
			var stator:Stator = new Stator(40, radio-10,"ABC");
			
			var motor:Motor = new Motor(stator, cage, new Esc(1));
			Builder.buildMotor(motor);
			motor.x = motor.y = radio * 2;
			
			addChild(motor);
			motor.init();
			motor.On();
			
		}
		
		
	}
	
}

//{ import
import flash.events.EventDispatcher;
import flash.display.*;
import flash.events.Event;
import flash.geom.ColorTransform;
import flash.geom.Point;
//} endregion


class Builder {
	
	public static var N:uint =  2;
	public static var S:uint =  1;
	public static var OFF:uint =  0;
	
	private static var _color:Array = [
		0xC0C0C0,// OFF
		0x0000FF,// S
		0xFF0000// N
	]
	
	public static var backgroundCage:Number = 0xC0C0C0 ;
	public static var stage:Main;
	
	public static function getColor(id:uint):uint {
		if (id < _color.length) return _color[id];
		return 0;
	}
	
	public static function createMark(x:Number, y:Number,color:uint=0xFF80FF):Shape {
		var w:int = 5;
		var cruz:Shape = new Shape();
		cruz.x = x;
		cruz.y = y;
		cruz.graphics.lineStyle(.1, color);
		cruz.graphics.moveTo( -w,-w);
		cruz.graphics.lineTo(w, w);
		cruz.graphics.moveTo( w,-w);
		cruz.graphics.lineTo( -w, w);
		//cruz.rotation = Math.round(Math.random() * 45);
		return cruz;
	}
	
	//{ region build
	public static function buildMotor(motor:Motor):void 
	{
		buildStator(motor);
		buildCage(motor.cage);
	}
	
	public static function buildStator(motor:Motor):void {
		
		var stator:Stator = motor.stator;
		stator.motor = motor;
		
		var graphics:Graphics = stator.graphics;
		var radiusIn:Number = stator.radiusIn;
		var radiusOut:Number = stator.radiusOut;
		
		var list:Array = stator.config.split("");
		var center:Point = new Point(0, 0);
		var angleStep:Number = 360 / list.length;
		var then:TheenStator;
		var rot:int = 0;
		for (var i:int = 0; i < list.length; i++) 
		{
			then = new TheenStator(motor);
			switch (list[i]) 
			{
				case "A":
					then.CW = true;
					then.group = 0;
					drawThen(then.graphics, stator.radiusIn, stator.radiusOut);
					break;
				case "B": 
					then.CW = true;
					then.group = 1;
					drawThen(then.graphics, stator.radiusIn, stator.radiusOut);
					
					break;
				case "C": 
					then.CW = true;
					then.group = 2;
					drawThen(then.graphics, stator.radiusIn, stator.radiusOut);
					break;
				case "a": 
					;
					break;
				case "b": 
					;
					break;
				case "c": 
					;
					break;
				default:
					then.group = 8;
					drawThen(then.graphics, stator.radiusIn, stator.radiusOut);;
			}
			then.rotation = rot += angleStep;
			stator.addTheen(then);
		}
		
		//background
		
		graphics.beginFill(backgroundCage);
		graphics.drawCircle(0, 0, radiusIn);
		graphics.drawCircle(0, 0, radiusIn + 10);
		graphics.endFill();
		//var spacer:Number = angleStep - (angleStep * porcent);
		
		
		stator.rotation = 90;
		
	}
	
	public static function buildCage(cage:Cage):void {
		
		var graphics:Graphics = cage.graphics;
		var radiusIn:Number = cage.radiusIn;
		var radiusOut:Number = cage.radiusOut;
		
		graphics.clear();
		
		graphics.beginFill(backgroundCage);
		graphics.drawCircle(0, 0, radiusOut);
		graphics.drawCircle(0, 0, radiusOut + 5);
		graphics.endFill();
		
		var list:Array = cage.config.split("");
		var center:Point = new Point(0, 0);
		var angleStep:Number = 360 / list.length;
		var spacer:Number = angleStep - (angleStep * cage.porcent);
		
		for (var i:int = 0; i < list.length; i++) 
		{
			switch (list[i]) 
			{
				case " ": break;
				case "N": 
					drawMagnet(graphics, center, radiusIn , radiusOut , i*angleStep ,(i+1)*angleStep-spacer, getColor(N));
					cage.addMagnet(new Magnet(N));
					break;
				case "S": 
					drawMagnet(graphics, center, radiusIn , radiusOut , i*angleStep ,(i+1)*angleStep-spacer, getColor(S));
					cage.addMagnet(new Magnet(S));
					break;
				default:
					drawMagnet(graphics, center, radiusIn , radiusOut , i*angleStep ,(i+1)*angleStep-spacer, getColor(OFF));
					cage.addMagnet(new Magnet(OFF));
			}
		}
		
	}
	//} endregion

	//{ region draw
	public static function drawThen(graphics:Graphics, radiusIn:Number, radiusOut:Number, w:int= 10, h:int = 10,hHead:int=5):void {
		
		graphics.beginFill(0);
		graphics.moveTo( -w / 2, -radiusIn)
		
		graphics.lineTo(w / 2, -radiusIn);
		graphics.lineTo(w / 2, -radiusOut + h);
		graphics.lineTo(w / 2+hHead, -radiusOut + h);
		graphics.lineTo(w / 2+hHead, -radiusOut + h-h/2);
		graphics.curveTo(
			0, -radiusOut ,
			-w / 2-hHead, -radiusOut + h-h/2
		);
		graphics.lineTo( -w / 2 - hHead, -radiusOut + h);
		graphics.lineTo(-w / 2, -radiusOut + h);
		graphics.lineTo(-w / 2, -radiusIn);
		graphics.endFill();
	}
	
	public static function drawMagnet(graphics:Graphics,center:Point,radiusIn:Number,radiusOut:Number,startAngle:Number,endAngle:Number,color:uint):void {
		
		graphics.lineStyle(1, 0);
		graphics.beginFill(color);
		
		//
		var angleStart:Number = startAngle*Math.PI/180;
		var angleEnd:Number = endAngle*Math.PI/180;
		
		graphics.moveTo(center.x + Math.cos(angleStart) * radiusIn ,center.y + Math.sin(angleStart) * radiusIn);
		graphics.lineTo(center.x + Math.cos(angleStart) * radiusOut ,center.y + Math.sin(angleStart) * radiusOut);
		
		drawArc(graphics, center, radiusOut, startAngle, endAngle);
		
		graphics.lineTo(center.x + Math.cos(angleEnd) * radiusIn ,center.y + Math.sin(angleEnd) * radiusIn);
		drawArc(graphics, center, radiusIn, endAngle, startAngle);
		
	}
	
	public static function drawArc(graphics:Graphics,center:Point, radius:Number, startAngle:Number,endAngle:Number):Point {
		
		var segAngle:Number, angle:Number, angleMid:Number, segs:Number, bx:Number, by:Number, cx:Number, cy:Number, arc:Number;
		
		arc =  endAngle - startAngle;
		
		segs = Math.ceil(Math.abs(arc)/45);
		 
		segAngle = (arc/segs)*Math.PI/180;
		angle = startAngle*Math.PI/180;
		
		
		if (segs>0) {
			
			for (var i:int = 0; i<segs; i++) {
				
				angle += segAngle;
			
				angleMid = angle-(segAngle/2);
				
				bx = center.x+Math.cos(angle)*radius;
				by = center.y+Math.sin(angle)*radius;
				
				cx = center.x+Math.cos(angleMid)*(radius/Math.cos(segAngle/2));
				cy = center.y+Math.sin(angleMid)*(radius/Math.cos(segAngle/2));
				
				graphics.curveTo(cx, cy, bx, by);
			}
		}
		
		return new Point(bx, by);
	}
	
	//} endregion
	
}

// representation visuel du stator
// control la polarité des aiment (visuel)
// declanche animation de magnetisme
class Stator extends Sprite {
	
	// assembly type
	public static const STAR:String = "star";
	public static const DELTA:String = "delta";
	// view
	public static const GROUP:String = "group";
	public static const PHASE:String = "phase";
	
	private var _asemblyType:String = STAR;
	private var _viewType:String = GROUP;
	private var _listTheen:Array;
	
	private var _radiusIn:Number;
	private var _radiusOut:Number;
	private var _config:String;
	private var _spacer:int;
	private var _motor:Motor;
	
	function Stator(radiusIn:Number, radiusOut:Number, config:String, spacer:int = 5):void {
		_radiusIn = radiusIn;
		_radiusOut = radiusOut;
		_config = config; 
		_spacer = spacer;
		
		_listTheen = new Array();
	}
	
	
	private function view(type:String):void {
		for (var i:int = 0; i < _listTheen.length; i++) 
		{
			
		}
	}
	
	
	public function init():void 
	{
		var theen:TheenStator,color:uint;
		if (_viewType == GROUP) {
		for (var i:int = 0; i < _listTheen.length; i++) 
		{
			theen = _listTheen[i] as TheenStator;
			
			theen.draw(Builder.getColor(theen.group)); 
		}	
		}
		
	}
	
	private function changedphase(e:Event):void {
		//var phase:uint = _esc.phase;
		_motor.magnetism.run();
	}
	
	private function terminatephase(e:Event):void {
		_motor.esc.next();
	}
	
	
	public function addTheen(theen:TheenStator):void {
		addChild(theen);
		_listTheen.push(theen);
	}
	
	public function get radiusIn():Number { return _radiusIn; }
	public function get radiusOut():Number { return _radiusOut; }
	public function get config():String { return _config; }
	public function get spacer():int { return _spacer; }
	public function get numTheen():int { return _listTheen.length; }
	
	public function get asemblyType():String { return _asemblyType; }
	public function set asemblyType(value:String):void 
	{
		_asemblyType = value;
	}
	
	
	public function get motor():Motor { return _motor; }
	public function set motor(value:Motor):void 
	{
		_motor = value;
		_motor.magnetism.addEventListener(Magnetism.TERMINATEPHASE, terminatephase);
		_motor.esc.addEventListener(Esc.CHANGEDPHASE, changedphase);
	}
	
}


// representation visuel une dent du stator
// 
class TheenStator extends Shape
{
	public var CW:Boolean, group:int;
	private var _motor:Motor
	function TheenStator(motor:Motor):void 
	{
		_motor = motor;
		_motor.esc.addEventListener(Esc.CHANGEDPHASE, changedphase);
	}
	
	public function draw(color:uint):void 
	{
		var c:ColorTransform = new ColorTransform();
		c.color = color;
		transform.colorTransform = c;
	}
	
	private function changedphase(e:Event=null):void 
	{
		draw(Builder.getColor(_motor.magnetism.getPole(this)));
		//trace("changed color in theen");
	}
}

// representation visuel de la cage
// 
class  Cage extends Shape{
	private var _listMagnets:Array;
	
	private var _radiusIn:Number;
	private var _radiusOut:Number;
	private var _config:String;
	private var _porcent:Number;
	
	function Cage(radiusIn:Number,radiusOut:Number,config:String,porcent:Number):void{
		_radiusIn = radiusIn;
		_radiusOut = radiusOut;
		_config = config; 
		_porcent = porcent;
		
		_listMagnets = new Array();
	}
	
	public function addMagnet(magnet:Magnet):void 
	{
		_listMagnets.push(magnet);
	}
	
	public function get radiusIn():Number { return _radiusIn; }
	public function get radiusOut():Number { return _radiusOut; }
	public function get config():String { return _config; }
	public function get porcent():Number { return _porcent; }
	
	public function get listMagnets():Array { return _listMagnets; }
	
	public function get numMagnets():uint { return _listMagnets.length; }
}



// controler qui marque le ritme
class Esc extends EventDispatcher {
	
	public static var N:uint =  2;
	public static var S:uint =  1;
	public static var OFF:uint =  0;
	
	public static const CHANGEDPHASE:String = "changed phase";
	private var _phase:int = -1;
	private var _timing:Number;
	
	function Esc(timing:Number):void {
		_timing = timing;
	}
	
	public function next():void {
		_phase++;
		if (_phase > 2) _phase = 0;
		trace("event", "Esc." + CHANGEDPHASE , _phase);
		dispatchEvent(new Event(CHANGEDPHASE));
	}
	
	public function get phase():int { return _phase; }
	
	public function get timing():Number { return _timing; }
	public function set timing(value:Number):void 
	{
		_timing = value;
	}
	
}

// chargé de animé la cage
// a remplir ...
class Magnetism extends EventDispatcher {
	public static const TERMINATEPHASE:String = "terminate phase";

	public static var N:uint =  2;
	public static var S:uint =  1;
	public static var OFF:uint =  0;
	
	private var _motor:Motor;
	private var angleSteep:Number =0 ;
	
	function Magnetism(motor:Motor):void {
		_motor = motor
	}
	
	private var countAngle:Number = 0;
	private function tick(e:Event):void {
		
		if (_motor.esc.phase == 0) {
			stop(); return;
		}
		
		var steep:Number = _motor.esc.timing;
		_motor.cage.rotation += steep;
		countAngle += steep;
		var f:Number = Math.round((countAngle % angleSteep) * 1000000000) / 1000000000;
		
		trace("event", "Magnetism.tick",_motor.esc.phase,(countAngle % angleSteep),_motor.cage.rotation,angleSteep,f);
		if (f == 0) {
			stop();
			trace("event","Magnetism."+TERMINATEPHASE);
			//_motor.cage.rotation = Math.round(_motor.cage.rotation * 1000000000) / 1000000000;
			trace((countAngle),_motor.cage.rotation,angleSteep)
			countAngle = 0;
			dispatchEvent(new Event(TERMINATEPHASE));
		}
	}
	
	private var count:uint;
	public function getPole(then:TheenStator):uint 
	{
		
		count = _motor.esc.phase;
		//
		if (_motor.esc.phase == 0) {
			if (_motor.stator.asemblyType == Stator.STAR) {
				if (then.group == 0) return N;
				else return S;
			}
		}
		else if (_motor.esc.phase == 1) {
			if (_motor.stator.asemblyType == Stator.STAR) {
				if (then.group == 1) return N;
				else return S;
			}
		}
		else if (_motor.esc.phase == 2) {
			if (_motor.stator.asemblyType == Stator.STAR) {
				if (then.group == 2) return N;
				else return S;
			}
		}
		return count;
		//if (count > 2) count = 0;
	}
	
	public function stop():void 
	{
		_motor.stator.removeEventListener(Event.ENTER_FRAME, tick);
	}
	
	public function run():void 
	{
		_motor.stator.addEventListener(Event.ENTER_FRAME, tick);
	}
	
	public function init():void 
	{
		trace("magnetism.init",angleSteep);
		// center cage to theen
		angleSteep = 360 / _motor.cage.numMagnets;
		_motor.cage.rotation = -angleSteep * _motor.cage.porcent / 2;
		// 
		//_motor.cage.rotation -= -360 / _motor.stator.numTheen/ 2;
		_motor.cage.rotation += 90;
		angleSteep = 360 / _motor.stator.numTheen;
		//_motor.cage.rotation = angleSteep
	}
	
}

// representation visuel du moteur
// reagroupe les diferent partis dun moteur
class Motor extends Sprite
{
	private var _cage:Cage;
	private var _stator:Stator;
	private var _esc:Esc;
	private var _magnetism:Magnetism;
	
	public function Motor(stator:Stator,cage:Cage,esc:Esc):void {
		
		_stator = stator;
		_cage = cage;
		_esc = esc;
		_magnetism = new Magnetism(this);
		
		addChild(_stator);
		addChild(_cage);
		
	}
	
	public function init():void 
	{
		_magnetism.init();
		_stator.init();
		
	}
	
	public function On():void 
	{
		_esc.next();
	}
	
	public function off():void 
	{
		
	}
	
	public function get esc():Esc { return _esc; }
	public function get stator():Stator { return _stator; }
	public function get cage():Cage { return _cage; }
	public function get magnetism():Magnetism { return _magnetism; }
}

class Magnet
{
	private var _pole:uint;
	function Magnet(pole:uint):void 
	{
		_pole = pole;
	}
	
	public function get pole():uint { return _pole; }
}