package shapesinmotion.base
{
    import flash.concurrent.Condition;
    import flash.concurrent.Mutex;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.system.Worker;
    import flash.system.WorkerDomain;
    import flash.utils.ByteArray;
    import flash.utils.clearTimeout;
    import flash.utils.setTimeout;

    import Box2D.Common.Math.b2Vec2;
    import Box2D.Dynamics.IBox2dDebugDraw;
    import Box2D.Dynamics.b2DebugDraw;
    import Box2D.Dynamics.b2World;

    import hcmbox2d.base.PhysicsEngineWorkerProxy;
    import hcmbox2d.helper.AdvancedPathHelper;
    import hcmbox2d.helper.BombExplosionHelper;
    import hcmbox2d.helper.Box2DPhysicsLineDrawHelper;
    import hcmbox2d.helper.Box2dDebugDrawHelper;
    import hcmbox2d.helper.Box2dPhysicsWorldJointHelper;
    import hcmbox2d.helper.PhysicsLineDrawBodyHelper;
    import hcmbox2d.interfaces.IPhysicsEngine;
    import hcmbox2d.interfaces.factory.IPhysicsWorldObjectFactory;

    import shapesinmotion.factory.SIMBasePhysicsObjectFactory;
    import shapesinmotion.factory.SIMPhysicsObjectFactory;
    import shapesinmotion.factory.vertex.SIMObjectVertexFactory;
    import shapesinmotion.helpers.LaserObjectHelper;
    import shapesinmotion.physics.PhysicsEngineWorkerWrapper;
    import shapesinmotion.physics.SIMBox2DDebugDraw;
    import shapesinmotion.physics.SIMBox2dPhysicsEngine;

    public class BaseMainClass extends Sprite
    {
        public static const ENABLE_PHYSICS_ENGINE_WORKER:Boolean = false;

        public var isLoaderInfoLoaded:Boolean = false;
        public var shapesInMotionInitializer:ShapesInMotionInitializer;

        public var physicsEngineWorker:Worker;

        private var physicsEngineMutex:Mutex;
        private var physicsEngineCondition:Condition;

        private var objectData:ByteArray;
        private var jointData:ByteArray;
        private var commandData:ByteArray;
        private var simulationData:ByteArray;
        private var laserData:ByteArray;
        private var touchData:ByteArray;
        private var contactData:ByteArray;
        private var debugDrawData:ByteArray;

        public static const DEBUG_DRAW_LINE_THICKNESS:Number = 2;
        public static const DEBUG_DRAW_ALPHA:Number = 0.5;

        public function BaseMainClass()
        {
            super();
        }

        public static var resizeEventsCount:int = 0;
        public static var maxResolution:uint = 0;

        protected function startMainThread():void
        {
            if(ENABLE_PHYSICS_ENGINE_WORKER)
            {
                physicsEngineWorker = WorkerDomain.current.createWorker(this.loaderInfo.bytes);

                physicsEngineMutex = new Mutex();
                physicsEngineCondition = new Condition(physicsEngineMutex);

                physicsEngineWorker.setSharedProperty("condition", physicsEngineCondition);
                physicsEngineWorker.setSharedProperty("mutex", physicsEngineMutex);


                objectData = new ByteArray();
                objectData.shareable = true;

                jointData = new ByteArray();
                jointData.shareable = true;

                commandData = new ByteArray();
                commandData.shareable = true;

                simulationData = new ByteArray();
                simulationData.shareable = true;

                laserData = new ByteArray();
                laserData.shareable = true;

                touchData = new ByteArray();
                touchData.shareable = true;

                contactData = new ByteArray();
                contactData.shareable = true;

                debugDrawData = new ByteArray();
                debugDrawData.shareable = true;


                physicsEngineWorker.setSharedProperty('objectData', objectData);
                physicsEngineWorker.setSharedProperty('jointData', jointData);
                physicsEngineWorker.setSharedProperty('simulationData', simulationData);
                physicsEngineWorker.setSharedProperty('simulationData', laserData);
                physicsEngineWorker.setSharedProperty('commandData', commandData);
                physicsEngineWorker.setSharedProperty('touchData', touchData);
                physicsEngineWorker.setSharedProperty('contactData', contactData);
                physicsEngineWorker.setSharedProperty('debugDrawData', debugDrawData);
            }

            this.stage.addEventListener(flash.events.Event.RESIZE, _stageResizeEvent);
            this.loaderInfo.addEventListener(Event.COMPLETE, this.loaderInfoLoadCompleteEventHandler);
        }

        private static var safeTimeout:int;

        public function _stageResizeEvent(event:flash.events.Event):void
        {
            if(safeTimeout > 0) clearTimeout(safeTimeout);
            if(isLoaderInfoLoaded && !ShapesInMotionInitializer.IS_INITIALIZED) safeTimeout = setTimeout(shapesInMotionInitializer.init, 400);

            resizeEventsCount++;
            maxResolution = Math.max(this.stage.stageHeight, maxResolution);
        }

        protected function loaderInfoLoadCompleteEventHandler(event:Event):void
        {
            isLoaderInfoLoaded = true;

            shapesInMotionInitializer.mainInstance = this;
            shapesInMotionInitializer.physicsEngineWorker = physicsEngineWorker;

            shapesInMotionInitializer.loaderInfoLoadComplete();

            if(safeTimeout > 0) clearTimeout(safeTimeout);
            safeTimeout = setTimeout(shapesInMotionInitializer.init, 400);

        }

        public function createPhysicsEngineForMainThread():void
        {
            var engine:IPhysicsEngine;

            if(ENABLE_PHYSICS_ENGINE_WORKER)
            {
                var engineWorker:PhysicsEngineWorkerProxy = new PhysicsEngineWorkerProxy();
                    engineWorker.engineWorker = physicsEngineWorker;

                engine = engineWorker;
            }
            else
            {
                var physicsEngine:SIMBox2dPhysicsEngine = new SIMBox2dPhysicsEngine();
                    physicsEngine.box2dWorld = new b2World(new b2Vec2(0, 9.81), true);
                    physicsEngine.box2dJointHelper = new Box2dPhysicsWorldJointHelper();

                var physicsWorldObjectFactory:IPhysicsWorldObjectFactory = this.createPhysicsObjectFactory();
                    physicsWorldObjectFactory.physicsObjectFactory.physicsWorld = physicsEngine.box2dWorld;
                    physicsWorldObjectFactory.physicsObjectFactory.meterToPixelRatio = ShapesInMotionContainer.METER_TO_PIXEL_RATIO;
                    physicsWorldObjectFactory.physicsObjectFactory.pixelToMeterRatio = ShapesInMotionContainer.PIXEL_TO_METER_RATIO;

                    physicsEngine.physicsWorldObjectFactory = physicsWorldObjectFactory;

                    physicsEngine.debugDraw = this.createBox2dDebugDraw();

                    physicsEngine.advancedPathHelper = new AdvancedPathHelper();
                    physicsEngine.physicsLineDrawHelper = new Box2DPhysicsLineDrawHelper();
                    physicsEngine.laserHelper = new LaserObjectHelper();
                    physicsEngine.bombExplosionHelper = new BombExplosionHelper();

                    physicsEngine.advancedPathHelper.physicsEngine = physicsEngine;
                    physicsEngine.laserHelper.physicsEngine = physicsEngine;
                    physicsEngine.bombExplosionHelper.physicsEngine = physicsEngine;

                var physicsLineDrawBodyHelper:PhysicsLineDrawBodyHelper = new PhysicsLineDrawBodyHelper();
                    physicsLineDrawBodyHelper.box2dWorld = physicsEngine.box2dWorld;

                    physicsEngine.physicsLineDrawHelper.physicsLineDrawBodyHelper = physicsLineDrawBodyHelper;

                engine = physicsEngine;
            }

            shapesInMotionInitializer.physicsEngine = engine;
        }

        protected function startPhysicsEngineThread():void
        {
            var workerWrapper:PhysicsEngineWorkerWrapper = new PhysicsEngineWorkerWrapper();
                workerWrapper.physicsEngine.physicsWorldObjectFactory = this.createPhysicsObjectFactory();
                workerWrapper.init();
        }

        protected function createBox2dDebugDraw():IBox2dDebugDraw
        {
            var simDebugDrawMain:SIMBox2DDebugDraw = new SIMBox2DDebugDraw();
                simDebugDrawMain.debugDrawHelper = new Box2dDebugDrawHelper();
                simDebugDrawMain.SetDrawScale(ShapesInMotionContainer.METER_TO_PIXEL_RATIO);

                simDebugDrawMain.SetLineThickness(DEBUG_DRAW_LINE_THICKNESS);
                simDebugDrawMain.SetFillAlpha(DEBUG_DRAW_ALPHA);
                simDebugDrawMain.SetFlags(b2DebugDraw.e_jointBit | b2DebugDraw.e_shapeBit);

            return simDebugDrawMain;
        }

        protected function createPhysicsObjectFactory():IPhysicsWorldObjectFactory
        {
            var objectVertexFactory:SIMObjectVertexFactory = new SIMObjectVertexFactory();

            var physicsObjectFactory:SIMPhysicsObjectFactory;
                physicsObjectFactory = new SIMPhysicsObjectFactory();
                physicsObjectFactory.physicsObjectVertexFactory = objectVertexFactory.create();

            var physicsWorldObjectFactory:SIMBasePhysicsObjectFactory = new SIMBasePhysicsObjectFactory();
                physicsWorldObjectFactory.physicsObjectFactory = physicsObjectFactory;

            return physicsWorldObjectFactory;
        }
    }
}