/*
* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com
*
* This software is provided 'as-is', without any express or implied
* warranty.  In no event will the authors be held liable for any damages
* arising from the use of this software.
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
 
/*
*This a port in AS3 by Guillaume Pommey of a slicing engine in C
*Thanks to Emanuele Feronato for his help : http://www.emanueleferonato.com/category/box2d/
*Thanks to Boris The Brave for his Raycast function : http://personal.boristhebrave.com/
*I hope you will enjoy this, have fun !
*/
 
package{
 
import Box2D.Dynamics.*
import Box2D.Collision.*
import Box2D.Collision.Shapes.*
import Box2D.Dynamics.Joints.*
import Box2D.Dynamics.Contacts.*
import Box2D.Common.Math.*
import Box2D.Common.*
import General.*
import flash.display.*;
import flash.events.*;
import flash.utils.getTimer
import flash.display.MovieClip;
 
	public class Main extends MovieClip{
		public function Main(){
 
			m_fpsCounter.x = 7;
			m_fpsCounter.y = 5;
			addChildAt(m_fpsCounter, 0);
 
			m_sprite = new Sprite();
			addChild(m_sprite);
 
			m_input = new Input(m_sprite);
 
			addEventListener(Event.ENTER_FRAME, update, false, 0, true);
			stage.addEventListener(KeyboardEvent.KEY_DOWN, key_pressed);
			stage.addEventListener(MouseEvent.MOUSE_UP, mouseUpEvent);
 
			//Create a b2World
			var worldAABB:b2AABB = new b2AABB();
			worldAABB.lowerBound.Set(-1000.0, -1000.0);
			worldAABB.upperBound.Set(1000.0, 1000.0);
 
			// Define the gravity vector
			var gravity:b2Vec2 = new b2Vec2(0.0, 10.0);
 
			// Allow bodies to sleep
			var doSleep:Boolean = true;
 
			// Construct a world object
			m_world = new b2World(worldAABB, gravity, doSleep);
			dbgDraw = new b2DebugDraw();
			dbgDraw.m_sprite = m_sprite;
			dbgDraw.m_drawScale = 15.0;
			dbgDraw.m_fillAlpha = 0.3;
			dbgDraw.m_lineThickness = 1.0;
			dbgDraw.m_drawFlags = b2DebugDraw.e_shapeBit;
			m_world.SetDebugDraw(dbgDraw);
 
			//Create some nice shapes
			CutterTest();
		}
 
		public function CutterTest(){
 
				var ground:b2Body = null;
 
				//Top
				var bd:b2BodyDef = new b2BodyDef();
				bd.position.Set(0.0, -6.0);
				ground = m_world.CreateBody(bd);
 
				var sd:b2PolygonDef = new b2PolygonDef();
				sd.SetAsBox(50.0, 10.0);
				ground.CreateShape(sd);
 
				//Bottom
				bd.position.Set(0.0, 45);
				ground = m_world.CreateBody(bd);
 
				sd.SetAsBox(50.0, 10.0);
				ground.CreateShape(sd);
 
				//Laser body
				bd.position.Set(6.0, 15.0);
				laserBody = m_world.CreateBody(bd);
 
				sd.SetAsBox(5.0, 1.0);
				sd.density = 4.0;
				laserBody.CreateShape(sd);
				laserBody.SetMassFromShapes();
 
				//Boxes
				sd.SetAsBox(3.0, 3.0);
				sd.density = 5.0;
 
				bd.userData = 1;
				bd.position.Set(25.0, 15.0);
				var body1:b2Body = m_world.CreateBody(bd);
				body1.CreateShape(sd);
				body1.SetMassFromShapes();
 
				sd.SetAsBox(3.0, 3.0);
				sd.density = 5.0;
 
				bd.userData = 1;
				bd.position.Set(25.0, 15.0);
				body1 = m_world.CreateBody(bd);
				body1.CreateShape(sd);
				body1.SetMassFromShapes();
		}
 
		/***************************************************/
		/*********************ETAPE 1***********************/
		/***************************************************/
 
		public function CheckPolyShape(poly:b2PolygonDef)
		{
			if (!(3 <= poly.vertexCount && poly.vertexCount <= b2_maxPolygonVertices)){
					return -1;
			}
			var m_normals:Array = new Array(poly.vertexCount);
 
		 		// Compute normals. Ensure the edges have non-zero length.
				for (var i=0; i < poly.vertexCount; i++)
				{
					var i1 = i;
					var i2 = 0;
 
					if((i + 1) < poly.vertexCount){
						i2 = i + 1;
					} else {
						i2 = 0;
					}
 
					var edge:b2Vec2 = poly.vertices[i2].Copy();
					edge.Subtract(poly.vertices[i1]);
 
 
					if (!(edge.LengthSquared()> Number.MIN_VALUE * Number.MIN_VALUE)){//Peut être une erreur
						return -1;
					}
					m_normals[i] = b2Math.b2CrossVF(edge, 1.0);
					m_normals[i].Normalize();
				}
 
				// Ensure the polygon is convex.
				for (i=0; i <poly.vertexCount; i++)
				{
					for (var j=0; j <poly.vertexCount; j++)
					{
						// Don't check vertices on the current edge.
						if (j == i || j == (i + 1) % poly.vertexCount)
						{
							continue;
						}
						// Your polygon is non-convex (it has an indentation).
						// Or your polygon is too skinny.
						var vecPlus:b2Vec2 = b2Math.SubtractVV(poly.vertices[j], poly.vertices[i]);
						var s = b2Math.b2Dot(m_normals[i], vecPlus);//Problème ??
						if (!(s < -b2Settings.b2_linearSlop)){//Idem
							return -1;
						}
					}
				}
 
				// Ensure the polygon is counter-clockwise.
				for (i=1; i <poly.vertexCount; i++)
				{
					var cross:Number = b2Math.b2CrossVV(m_normals[i-1], m_normals[i]);
 
					// Keep asinf happy.
					cross = b2Math.b2Clamp(cross, -1, 1);
 
					// You have consecutive edges that are almost parallel on your polygon.
					var angle:Number = Math.asin(cross);
					if (!(angle> b2Settings.b2_angularSlop))
						return -1;
				}
 
				// Compute the polygon centroid.
				var m_centroid:b2Vec2 = new b2Vec2(); 
				var area:Number = 0;
				var pRef:b2Vec2 = new b2Vec2(0.0, 0.0);
				var inv3:Number = 1 / 3;
 
				for (i=0; i <poly.vertexCount; i++)
				{
					// Triangle vertices.
					var p1:b2Vec2 = pRef;
					var p2:b2Vec2 = poly.vertices[i];
					var p3 = 0;
 
					if((i + 1) < poly.vertexCount){
						p3 = poly.vertices[i+1];
					} else {
						p3 = poly.vertices[0];
					}
 
					var e1:b2Vec2 = b2Math.SubtractVV(p2, p1);
					var e2:b2Vec2 = b2Math.SubtractVV(p3, p1);
 
					var D:Number = b2Math.b2CrossVV(e1, e2);
					var triangleArea:Number = 0.5 * D;
					area += triangleArea;
 
					// Area weighted centroid
					var p123:b2Vec2 = p1.Copy();
					p123.Add(p1);
					p123.Add(p2);
					var trInv3:Number = triangleArea * inv3;
					var p123Mul:b2Vec2 = b2Math.MulFV(trInv3, p123);
					m_centroid.Add(p123);
				}
 
				// Centroid
				if (!(area> Number.MIN_VALUE)){
					return -1;
				}
				b2Math.MulFV((1.0 / area), m_centroid); // ??????
 
				// Compute the oriented bounding box.
				//ComputeOBB(&m_obb, m_vertices, m_vertexCount);
 
				// Create core polygon shape by shifting edges inward.
				// Also compute the min/max radius for CCD.
				for (i=0; i <poly.vertexCount; i++)
				{
					if((i - 1) >= 0){
						i1 = i - 1;
					}else {
						i1 = (poly.vertexCount - 1)
					}
					i2 = i;
 
					var n1:b2Vec2 = m_normals[i1];
					var n2:b2Vec2 = m_normals[i2];
					var v:b2Vec2 = b2Math.SubtractVV(poly.vertices[i], m_centroid); // ?????
 
					var d:b2Vec2 = new b2Vec2();
					d.x = b2Math.b2Dot(n1, v) - b2Settings.b2_toiSlop;
					d.y = b2Math.b2Dot(n2, v) - b2Settings.b2_toiSlop;
 
					// Shifting the edge inward by b2_toiSlop should
					// not cause the plane to pass the centroid.
 
					//Those conditions are very annoying !!
 
					// Your shape has a radius/extent less than b2_toiSlop.
					/*if (!(d.x>= 0)){
						return -1;
					}
					if (!(d.y>= 0)){
						return -1;
					}*/
				}
			return 0;
 
		}
 
	 /// Split a shape trough a segment
    /// @return
    /// -1 - Error on split
    ///  0 - Normal result is two new shape definitions.
    public function SplitShape(shape:b2PolygonShape, segment, splitSize, newPolygon:Array)// ????
    {
        /*assert(shape != NULL);
        assert(newPolygon != NULL);
        assert(splitSize>= 0);*/
 
		if(shape == null)
			return -1;
 
		if(newPolygon == null)
			return -1;
 
		if(splitSize <= 0)
			return -1;
 
     	var lambda:Array = [1];
        var normal:b2Vec2 = new b2Vec2();
 
		var b:b2Body = shape.GetBody();
      	var xf:b2XForm = b.GetXForm();
        if (shape.TestSegment(xf, lambda, normal, segment, 1) != b2Shape.e_hitCollide){
            return -1;
		}
 
		var entryPoint:b2Vec2 = segment.p1.Copy();
		entryPoint.Multiply(1 - lambda[0]);
		var tmp:b2Vec2 = segment.p2.Copy();
		tmp.Multiply(lambda[0]);
		entryPoint.Add(tmp);			
 
        var reverseSegment:b2Segment= new b2Segment;
        reverseSegment.p1 = segment.p2;
        reverseSegment.p2 = segment.p1;
 
        if (shape.TestSegment(xf, lambda, normal, reverseSegment, 1.0) != e_hitCollide){
            return -1;
		}
 
		var exitPoint:b2Vec2 = reverseSegment.p1.Copy();
		exitPoint.Multiply(1 - lambda[0]);
		tmp = reverseSegment.p2.Copy();
		tmp.Multiply(lambda[0]);
		exitPoint.Add(tmp);		
 
        var localEntryPoint:b2Vec2 = b.GetLocalPoint(entryPoint);
        var localExitPoint:b2Vec2  = b.GetLocalPoint(exitPoint);
 
        var vertices:Array = shape.GetVertices();
        var cutAdded:Array = [-1,-1];
        var lastA = -1;
 
        for(var i = 0; i<shape.GetVertexCount(); i++)
        {
            var n;
            //Find out if this vertex is on the old or new shape.
            if (b2Math.b2Dot(b2Math.b2CrossVF(b2Math.SubtractVV(localExitPoint,localEntryPoint), 1), b2Math.SubtractVV(vertices[i], localEntryPoint))> 0) //Clash ??
                n = 0;
            else
                n = 1;
            if (lastA != n)
            {
                //If we switch from one shape to the other add the cut vertices.
                if (lastA == 0)
                {
                    //assert(cutAdded[0] == -1); Couiiic
					if(cutAdded[0] != -1){
						return -1;
					}
                    cutAdded[0] = newPolygon[lastA].vertexCount;
                    newPolygon[lastA].vertices[newPolygon[lastA].vertexCount] = localExitPoint;
                    newPolygon[lastA].vertexCount++;
                    newPolygon[lastA].vertices[newPolygon[lastA].vertexCount] = localEntryPoint;
                    newPolygon[lastA].vertexCount++;
                }
                if (lastA == 1)
                {
                    //assert(cutAdded[lastA] == -1); Recouiiic
					if(cutAdded[lastA] != -1){
						return -1;
					}
                    cutAdded[lastA] = newPolygon[lastA].vertexCount;
                    newPolygon[lastA].vertices[newPolygon[lastA].vertexCount] = localEntryPoint;
                    newPolygon[lastA].vertexCount++;
                    newPolygon[lastA].vertices[newPolygon[lastA].vertexCount] = localExitPoint;
                    newPolygon[lastA].vertexCount++;
                }
            }
            newPolygon[n].vertices[newPolygon[n].vertexCount] = vertices[i];
            newPolygon[n].vertexCount++;
            lastA = n;
        }
 
        //Add the cut in case it has not been added yet.
        if (cutAdded[0] == -1)
        {
            cutAdded[0] = newPolygon[0].vertexCount;
            newPolygon[0].vertices[newPolygon[0].vertexCount] = localExitPoint;
            newPolygon[0].vertexCount++;
            newPolygon[0].vertices[newPolygon[0].vertexCount] = localEntryPoint;
            newPolygon[0].vertexCount++;
        }
        if (cutAdded[1] == -1)
        {
            cutAdded[1] = newPolygon[1].vertexCount;
            newPolygon[1].vertices[newPolygon[1].vertexCount] = localEntryPoint;
            newPolygon[1].vertexCount++;
            newPolygon[1].vertices[newPolygon[1].vertexCount] = localExitPoint;
            newPolygon[1].vertexCount++;
        }
 
        for(n = 0; n<2 ; n++)
        {
            var offset:b2Vec2;
            if (cutAdded[n]> 0)
            {
				offset =  b2Math.SubtractVV(newPolygon[n].vertices[cutAdded[n]-1],  newPolygon[n].vertices[cutAdded[n]])//Substitution
            }else{
				//Substitution
				offset = b2Math.SubtractVV(newPolygon[n].vertices[newPolygon[n].vertexCount-1], newPolygon[n].vertices[0]);
            }
            offset.Normalize();
 
			var aNewVec:b2Vec2 = b2Math.MulFV(splitSize, offset);
            newPolygon[n].vertices[cutAdded[n]] = b2Math.AddVV(newPolygon[n].vertices[cutAdded[n]], aNewVec);
 
            if (cutAdded[n] <newPolygon[n].vertexCount-2)
            {
				offset = b2Math.SubtractVV(newPolygon[n].vertices[cutAdded[n]+2], newPolygon[n].vertices[cutAdded[n]+1]);
            }else{
				offset = b2Math.SubtractVV(newPolygon[n].vertices[0], newPolygon[n].vertices[newPolygon[n].vertexCount-1]);
            }
            offset.Normalize();
 
			aNewVec = b2Math.MulFV(splitSize, offset);
            newPolygon[n].vertices[cutAdded[n]+1] = b2Math.AddVV(newPolygon[n].vertices[cutAdded[n]+1], aNewVec);
		}
 
 
        //Check if the new shapes are not too tiny. (TODO: still generates shapes which fail assert checks)
        for(n=0;n<2;n++)
            for(i=0;i<newPolygon[n].vertexCount;i++)
                for(var j=0;j<newPolygon[n].vertexCount;j++)
                    if (i != j && (b2Math.SubtractVV(newPolygon[n].vertices[i], newPolygon[n].vertices[j])).Length() <0.1)
                        return -1;
 
        for(n=0;n<2;n++){
            if (CheckPolyShape(newPolygon[n])){
                return -1;
			}
        return 0;
		}
 
    }
 
	public function Cut():void
    {
 
     	/*laserStart = new b2Vec2(5.0-0.1, 0.0);
      	laserDir = new b2Vec2(segmentLength, 0.0);
 
        segment.p1 = laserBody.GetWorldPoint(laserStart);
        segment.p2 = b2Math.AddVV(segment.p1, laserBody.GetWorldVector(laserDir));*/
 
		var shapes:Array = new Array();
		max_shapes = 64;
		var count = 1;
        count = m_world.Raycast(segment, shapes, max_shapes, false, null);
        for(var i=0;i<count;i++)
        {
            //Make sure it's a polygon, we cannot cut circles.
            if(shapes[i].GetType() != b2Shape.e_polygonShape){
                continue;
			}
 
			var b:b2Body;
            b = shapes[i].GetBody();
            //Custom check to make sure we don't cut stuff we don't want to cut.
            if (b.GetUserData() != 1){ //Ouille !
                continue;//return if we cannot pass trough uncutable shapes.
			}
 
			var polyShape:b2PolygonShape;
 
			polyShape = shapes[i];
			var pd:Array = new Array(1);
			pd[0] = new b2PolygonDef();
			pd[1] = new b2PolygonDef();
            pd[0].density = 5.0;
            pd[1].density = 5.0;
 
           if (SplitShape(polyShape, segment, 0.1, pd) == 0)
            {  
				b.DestroyShape(shapes[i]);
				b.CreateShape(pd[0]);
                b.SetMassFromShapes();
                b.WakeUp();
 
				var bd:b2BodyDef = new b2BodyDef();
                bd.userData = 1;
                bd.position = b.GetPosition();
                bd.angle = b.GetAngle();
 
				var newBody:b2Body;
               	newBody = m_world.CreateBody(bd);
				newBody.CreateShape(pd[1]);
                newBody.SetMassFromShapes();
                newBody.SetAngularVelocity(b.GetAngularVelocity());
                newBody.SetLinearVelocity(b.GetLinearVelocity());
 
				var oldBody:b2Body;
				oldBody = m_world.CreateBody(bd);
				oldBody.CreateShape(pd[0]);
               	oldBody.SetMassFromShapes();
 
				m_world.DestroyBody(b);
				bd = new b2BodyDef();
                bd.position.Set(15, 5);
            }
        }
    }
 
	public function Step(ite, ate)
    {
		if(tool == 1){
 
			laserStart = new b2Vec2(5.0-0.1, 0.0);
			laserDir = new b2Vec2(segmentLength,0.0);
			segment.p1 = laserBody.GetWorldPoint(laserStart);
			segment.p2 = laserBody.GetWorldVector(laserDir);
			segment.p2 = b2Math.AddVV(segment.p2, segment.p1);
 
			laserColor = new b2Color(0,0,1);
			dbgDraw.DrawSegment(segment.p1, segment.p2, laserColor);
 
		} else {
 
			if(Input.mouseDown){
 
			if(!firstClic){
				depX = (Input.mouseX / m_physScale);
				depY = (Input.mouseY / m_physScale);
				firstClic = true;
			}
 
			arrX = (Input.mouseX / m_physScale);
			arrY = (Input.mouseY / m_physScale);
 
			laserStart = new b2Vec2(depX, depY);
			laserDir = new b2Vec2((arrX - depX), (arrY - depY));
			segment.p1 = laserStart;
			segment.p2 = laserDir;
			segment.p2 = b2Math.AddVV(segment.p2, segment.p1);
 
			laserColor = new b2Color(0,0,1);
			dbgDraw.DrawSegment(segment.p1, segment.p2, laserColor);
 
			m_cut = 1;
			}
 
			if(!(Input.mouseDown)){
				firstClic = false;
			}
		}
    }
 
	public function mouseUpEvent(e:MouseEvent){
		if(m_cut){
			Cut();
			m_cut = null;
		}
	}
 
		/*********MEMBER DATA*********/
 
		//World
		public var m_world:b2World;
		public var m_physScale:Number = 15;
		public var m_iterations:int = 10;
		public var m_timeStep:Number = 1/30;
		public var m_input:Input;
		public var m_sprite:Sprite;
		public var dbgDraw:b2DebugDraw;
		static public var m_fpsCounter:FpsCounter = new FpsCounter();
 
		//Basics
		public const b2_maxPolygonVertices:int = 8;
		public var e_hitCollide = 1;
 
		//Laser
		public var segment:b2Segment = new b2Segment();
		public var laserBody:b2Body;
		public var segmentLength:Number = 30.0;
		public var laserStart:b2Vec2;
		public var laserDir:b2Vec2;
		public var laserColor:b2Color;
		public var max_shapes:Number = 64;
 
		//Radio Button
		public var tool:Number = 1;
		public var firstClic:Boolean = false;
		public var depX:Number;
		public var depY:Number;
		public var arrX:Number;
		public var arrY:Number;
		public var m_cut = null;
 
		public function update(e:Event):void{
 
			m_sprite.graphics.clear();
 
			// For the mouse
			if(tool == 1){
				UpdateMouseWorld()
				MouseDestroy();
				MouseDrag();
			}
 
			var physStart:uint = getTimer();
			m_world.Step(m_timeStep, m_iterations);
			m_fpsCounter.updatePhys(physStart);
 
			Step(m_timeStep, m_iterations);
 
			//Update text
			updateText();
 
			// Update counter and limit framerate
			m_fpsCounter.update();
			FRateLimiter.limitFrame(40);
		}
 
		function key_pressed(e:KeyboardEvent):void {
            switch (e.keyCode) {
               case 67 :
			  		if(tool == 1){
                    Cut();
					}
                    break;
            }
        }
 
		public function updateText():void{
 
			if(tool ==1)
				var a:String = "On";
			else
				a = "Off";
 
			mouseS.text = 'Select object with mouse : '+a;
 
			var shapes:Array = new Array();
		 	var count = m_world.Raycast(segment, shapes, 64, false, null);
 
			shapesR.text = 'Number off shapes crossed by laser : '+count;
 
			bodyCount.text = 'Bodies enable to cut : '+(m_world.GetBodyCount() - 4); //Cause we have the top, the bottom, the laser...
		}
 
 
		//The mouse
		public var m_mouseJoint:b2MouseJoint;
		static public var mouseXWorldPhys:Number;
		static public var mouseYWorldPhys:Number;
		static public var mouseXWorld:Number;
		static public var mouseYWorld:Number;
 
		public function UpdateMouseWorld():void{
			mouseXWorldPhys = ((Input.mouseX)/m_physScale);
			mouseYWorldPhys = ((Input.mouseY)/m_physScale); 
 
			mouseXWorld = (Input.mouseX); 
			mouseYWorld = (Input.mouseY); 
		}
 
		public function MouseDrag():void{
			// mouse press
			if (Input.mouseDown && !m_mouseJoint){
 
				var body:b2Body = GetBodyAtMouse();
 
				if (body)
				{
					var md:b2MouseJointDef = new b2MouseJointDef();
					md.body1 = m_world.GetGroundBody();
					md.body2 = body;
					md.target.Set(mouseXWorldPhys, mouseYWorldPhys);
					md.maxForce = 500.0 * body.GetMass();
					md.timeStep = m_timeStep;
					m_mouseJoint = m_world.CreateJoint(md) as b2MouseJoint;
					body.WakeUp();
				}
			}
 
 
			// mouse release
			if (!Input.mouseDown){
				if (m_mouseJoint)
				{
					m_world.DestroyJoint(m_mouseJoint);
					m_mouseJoint = null;
				}
			}
 
 
			// mouse move
			if (m_mouseJoint)
			{
				var p2:b2Vec2 = new b2Vec2(mouseXWorldPhys, mouseYWorldPhys);
				m_mouseJoint.SetTarget(p2);
			}
		}
 
 
 
		//======================
		// Mouse Destroy
		//======================
		public function MouseDestroy():void{
			// mouse press
			if (!Input.mouseDown && Input.isKeyPressed(68/*D*/)){
 
				var body:b2Body = GetBodyAtMouse(true);
 
				if (body)
				{
					m_world.DestroyBody(body);
					return;
				}
			}
		}
 
		//======================
		// GetBodyAtMouse
		//======================
		private var mousePVec:b2Vec2 = new b2Vec2();
		public function GetBodyAtMouse(includeStatic:Boolean=false):b2Body{
			// Make a small box.
			mousePVec.Set(mouseXWorldPhys, mouseYWorldPhys);
			var aabb:b2AABB = new b2AABB();
			aabb.lowerBound.Set(mouseXWorldPhys - 0.001, mouseYWorldPhys - 0.001);
			aabb.upperBound.Set(mouseXWorldPhys + 0.001, mouseYWorldPhys + 0.001);
 
			// Query the world for overlapping shapes.
			var k_maxCount:int = 10;
			var shapes:Array = new Array();
			var count:int = m_world.Query(aabb, shapes, k_maxCount);
			var body:b2Body = null;
			for (var i:int = 0; i < count; ++i)
			{
				if (shapes[i].GetBody().IsStatic() == false || includeStatic)
				{
					var tShape:b2Shape = shapes[i] as b2Shape;
					var inside:Boolean = tShape.TestPoint(tShape.GetBody().GetXForm(), mousePVec);
					if (inside)
					{
 
						body = tShape.GetBody();
 
						break;
					}
				}
			}
			return body;
		}
 
	}
}