package com.view
{
    import com.controller.LineEvent;
    import com.helpers.LineTools;
    import com.model.vo.DataVO;

    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.geom.Matrix;
    import flash.geom.Point;
    import flash.geom.Rectangle;

    import org.robotlegs.mvcs.Mediator;

    public class FurnitureMediator extends Mediator
    {
        [Inject]
        public var furniture:FurnitureView;

        private var item:Sprite;

        private var canMove:Boolean=false;

        private var pointsArray:Array;
        private var itemRect:Rectangle;
        private var rotation:Number=0;

        private var itemLastPositionX:Number;
        private var itemLastPositionY:Number;

        private var collisionWallPoints:Array;
        private var wallIntersectPoints:Array;

        private var outSideBounds:Array;

        override public function onRegister():void
        {
            item=furniture.item;

            pointsArray=DataVO.cornerPoints;

            itemRect=item.getBounds(furniture);

            //for rotating center
            itemRect.x=item.x - 25;
            itemRect.y=item.y - 50;

            item.x=100;
            item.y=100;

            eventMap.mapListener(item.stage, MouseEvent.MOUSE_UP, mouseUpHandler);
            eventMap.mapListener(item, MouseEvent.MOUSE_DOWN, mouseDownHandler);
            eventMap.mapListener(item, Event.ENTER_FRAME, render);
        }


        protected function render(event:Event):void
        {
            if (canMove)
            {
                item.x=DataVO.mouseX;
                item.y=DataVO.mouseY;

                itemRect.x=item.x - 25;
                itemRect.y=item.y - 50;

                if (getCollisionWallCornerPoints())
                {
                    collisionWallPoints = getCollisionWallCornerPoints();
                }

                if (getObjectWallIntersectPoints(rotation, item, itemRect))
                {
                    wallIntersectPoints = getObjectWallIntersectPoints(rotation, item, itemRect);
                }

                if (collisionWallPoints)
                {
                    rotation=getSnapRotationOfTwoPoint(collisionWallPoints);

                    item.rotation=rotation;
                }

                if (wallIntersectPoints)
                {
                    if (wallIntersectPoints.length > 0)
                    {
                        outSideBounds = getOutsidePointOfPolygon(getRotatedBoundsOfObject(rotation, item, itemRect));

                        if (wallIntersectPoints.length > 0)
                        {
                            try
                            {
                                var diffX:Number = outSideBounds[0].x - wallIntersectPoints[1][0].x;
                                var diffY:Number = outSideBounds[0].y - wallIntersectPoints[1][0].y;

                                if (Math.abs(diffX) < 50 && Math.abs(diffY) < 50)
                                {
                                    item.x=DataVO.mouseX + (diffX * -1);
                                    item.y=DataVO.mouseY + (diffY * -1);

                                    itemRect.x=item.x - 25;
                                    itemRect.y=item.y - 50;
                                }
                            }
                            catch(error:Error)
                            {
                                trace(error);
                            }

                        }
                    }
                }

            }
        }

        private function getOutsidePointOfPolygon(bounds:Array):Array
        {
            var points:Array=new Array();

            for (var i:int=0; i < 4; i++)
            {
                var array:Array=new Array();
                var check:Boolean=LineTools.isPointInsidePolygon(bounds[i], pointsArray, convertPointsToWall(pointsArray).length);
                array.push(check);
                array.push(bounds[i]);

                points.push(array);
            }

            var result:Array=new Array();

            for (var j:int=0; j < points.length; j++)
            {
                if (!points[j][0])
                {
                    result.push(points[j][1]);
                }
            }

            if (result.length > 0)
            {
                return result;
            }

            return null;
        }

        private function pointInsidePolygon(point:Point):Boolean
        {
            var check:Boolean=false;

            check=LineTools.isPointInsidePolygon(point, pointsArray, convertPointsToWall(pointsArray).length);
            return check;
        }

        private function getObjectWallIntersectPoints(rotation:Number, object:Sprite, itemRect:Rectangle):Array
        {
            var result:Array=new Array();
            var wallCornerPoints:Array=convertPointsToWall(pointsArray);
            var rotatedItemBounds:Array=getRotatedBoundsOfObject(rotation, item, itemRect);

            for (var i:int=0; i < wallCornerPoints.length; i++)
            {
                var wallPoints:Array=new Array();
                var boxIntersect:Array=LineTools.boxIntersect(wallCornerPoints[i][0], wallCornerPoints[i][1], rotatedItemBounds[0], rotatedItemBounds[1], rotatedItemBounds[2], rotatedItemBounds[3]);

                if (boxIntersect)
                {
                    wallPoints.push(wallCornerPoints[i]);
                    wallPoints.push(boxIntersect);
                    result.push(wallPoints);
                }
            }

            //if two or more wall intersect
            if (result.length >= 2)
            {
                return null;
            }

            //if one wall intersect
            if (result.length == 1)
            {
                return result[0];
            }

            return new Array();
        }

        private function getRotatedBoundsOfObject(rotation:Number, object:Sprite, objectRectangle:Rectangle):Array
        {
            var rotationInRadians:Number=degreesToRadians(rotation);

            var itemCenterPoint:Point=new Point(object.x, object.y);

            var realBounds:Array=getBoundsOfObject(objectRectangle);

            var bounds:Array=new Array();

            var topLeft:Point=getRotatedRectPoint(rotationInRadians, realBounds[0], itemCenterPoint);
            var topRight:Point=getRotatedRectPoint(rotationInRadians, realBounds[1], itemCenterPoint);
            var bottomRight:Point=getRotatedRectPoint(rotationInRadians, realBounds[2], itemCenterPoint);
            var bottomLeft:Point=getRotatedRectPoint(rotationInRadians, realBounds[3], itemCenterPoint);

            bounds.push(topLeft);
            bounds.push(topRight);
            bounds.push(bottomRight);
            bounds.push(bottomLeft);

            return bounds;
        }

        private function getBoundsOfObject($objectRectangle:Rectangle):Array
        {
            var bounds:Array=new Array();

            var topLeft:Point=$objectRectangle.topLeft;
            var topRight:Point=new Point($objectRectangle.right, $objectRectangle.top);
            var bottomRight:Point=$objectRectangle.bottomRight;
            var botomLeft:Point=new Point($objectRectangle.x, $objectRectangle.bottom);

            bounds.push(topLeft);
            bounds.push(topRight);
            bounds.push(bottomRight);
            bounds.push(botomLeft);

            return bounds;
        }

        private function getRotatedRectPoint(angle:Number, point:Point, rotationPoint:Point=null):Point
        {
            var ix:Number=(rotationPoint) ? rotationPoint.x : 0;
            var iy:Number=(rotationPoint) ? rotationPoint.y : 0;

            var m:Matrix=new Matrix(1, 0, 0, 1, point.x - ix, point.y - iy);
            m.rotate(angle);
            return new Point(m.tx + ix, m.ty + iy);
        }

        private function radiansToDegrees(radians:Number):Number
        {
            var degrees:Number=radians * 180 / Math.PI;
            return degrees;
        }

        private function degreesToRadians(degrees:Number):Number
        {
            var radians:Number=degrees * Math.PI / 180
            return radians;
        }

        private function drawRuler():void
        {
            var wallCornerPoints:Array=getCollisionWallCornerPoints();
            var wallIntersectPoints:Array=getObjectWallIntersectPoints(rotation, item, itemRect);
            var rulerPoints:Array=new Array();

            if (!wallCornerPoints || !wallIntersectPoints)
                return;

            if (Point.distance(wallCornerPoints[0], wallIntersectPoints[0]) > Point.distance(wallCornerPoints[0], wallIntersectPoints[1]))
            {
                rulerPoints.push(wallIntersectPoints[0], wallIntersectPoints[1], wallCornerPoints[0], wallIntersectPoints[1], wallIntersectPoints[0], wallCornerPoints[1]);
                dispatch(new LineEvent(LineEvent.PLACE_RULER, rulerPoints));
            }
            else
            {
                rulerPoints.push(wallIntersectPoints[0], wallIntersectPoints[1], wallCornerPoints[0], wallIntersectPoints[0], wallIntersectPoints[1], wallCornerPoints[1]);
                dispatch(new LineEvent(LineEvent.PLACE_RULER, rulerPoints));
            }
        }

        private function getSnapRotationOfTwoPoint(array:Array):Number
        {
            var rotation:Number=radiansToDegrees(getAngleOfTwoPoint(array[0], array[1]));
            return rotation - 90;
        }

        private function isThePointBetweenTwoPoint(testPoint:Point, point1:Point, point2:Point):Boolean
        {
            var slope:int=(point1.y - point2.y) / (point1.x - point2.x);
            var int1:Number=testPoint.y - point2.y;
            var int2:Number=slope * (testPoint.x - point2.x);

            if (int1 == int2)
            {
                return true;
            }

            return false;
        }

        private function getAngleOfTwoPoint(point1:Point, point2:Point):Number
        {
            var dx:Number=point2.x - point1.x;
            var dy:Number=point2.y - point1.y;
            return Math.atan2(dy, dx);
        }

        private function getCollisionWallCornerPoints():Array
        {
            var wallCornerPoints:Array=convertPointsToWall(pointsArray);
            var wallIntersectPoints:Array=getObjectWallIntersectPoints(item.rotation, item, itemRect);
            var result:Array=new Array();

            if (!wallIntersectPoints || wallIntersectPoints.length == 0)
            {
                return null;
            }

            try
            {
                for (var i:int=0; i < wallCornerPoints.length; i++)
                {
                    var point:Point=LineTools.rayRayIntersect(wallIntersectPoints[1][0], wallIntersectPoints[1][1], wallCornerPoints[i][0], wallCornerPoints[i][1]);

                    if (point)
                    {
                        result.push(wallCornerPoints[i][0]);
                        result.push(wallCornerPoints[i][1]);
                        return result;
                    }

                }
            }
            catch (error:Error)
            {
                trace(error);
            }



            return null;
        }

        private function getCenterPointOfTwoPoint(point1:Point, point2:Point):Point
        {
            var x:int=point1.x + point2.x;
            var y:int=point1.y + point2.y;
            var centerPoint:Point=new Point(x / 2, y / 2);
            return centerPoint;
        }

        private function convertPointsToWall(array:Array):Array
        {
            var result:Array=new Array();
            var points:Array=array;

            for (var i:int=0; i < points.length; i++)
            {
                var wall:Array=new Array();

                if (i == points.length - 1)
                {
                    wall.push(points[i]);
                    wall.push(points[0]);
                }
                else
                {
                    wall.push(points[i]);
                    wall.push(points[i + 1]);
                }
                result.push(wall);
            }

            return result;

        }

        protected function mouseUpHandler(event:MouseEvent):void
        {
            canMove=false;
        }

        protected function mouseDownHandler(event:MouseEvent):void
        {
            canMove=true;
        }
    }
}