//stops us from sending multiple rpc calls to display the gui if it is already being displayed
 public ArenaState(StateManager manager)
 {
     this.manager = manager;
     manager.StartCoroutine ("BreakDelay");
     timeUntilNextWave = Time.time + timeBetweenWaves;
     waveNumber = 0;
 }

    private void InitialzeStateManager()
    {
        _stateManager = new StateManager(_muffinAnimator);

        IdleState 		idle = new IdleState(_stateManager, transform);
        MoveState 		move = new MoveState(_stateManager, transform);
        TrapState 		trap = new TrapState(_stateManager, transform);
        DieState 		die	= new DieState(_stateManager, transform);
        SpinState		spin = new SpinState(_stateManager, transform);
        BlastState		blast = new BlastState(_stateManager, transform);
        ChocoRushState	chocoRush = new ChocoRushState(_stateManager, transform);

        PauseState		pause = new PauseState(_stateManager, transform);

        _stateManager.AddCharacterState(idle);
        _stateManager.AddCharacterState(move);
        _stateManager.AddCharacterState(trap);
        _stateManager.AddCharacterState(die);
        _stateManager.AddCharacterState(spin);
        _stateManager.AddCharacterState(blast);
        _stateManager.AddCharacterState(chocoRush);

        _stateManager.AddCharacterState(pause);

        _stateManager.SetDefaultState("Pause");
    }

        public void ExecuteContinousInvalidCommand()
        {
            var stateManager = new StateManager();
            var game = new TestGameImplementation();
            game.Initialize<DefaultPlayer>(null);

            var commands = CommandFactory.GetCommands(new Assembly[] { Assembly.GetExecutingAssembly() });

            if (commands.Count() == 0)
            {
                Assert.Fail("No commands were fetched from the factory.");
            }

            stateManager.Initialize(game.Player, commands);

            stateManager.PerformCommand(new ReceivedInputMessage("CommandWithInput"));

            Assert.IsTrue(game.Messages.Count > 0);
            Assert.IsNotNull(game.Player.StateManager.CurrentState);
            Assert.IsTrue(game.Player.StateManager.CurrentState.GetType() == typeof(ReceivingInputState));

            stateManager.PerformCommand(new ReceivedInputMessage("someRandomStuff"));

            Assert.IsTrue(game.Messages.Count > 0);
            Assert.IsNotNull(game.Player.StateManager.CurrentState);
            Assert.IsTrue(game.Player.StateManager.CurrentState.GetType() == typeof(TestState));

            stateManager.PerformCommand(new ReceivedInputMessage("randomMessage"));

            Assert.IsTrue(game.Messages.Pop() == "Invalid command used!" + Environment.NewLine);
        }

				//private PlayerScript controller;
		
				public PlayState2 (StateManager managerRef)
				{ //Constructor
						manager = managerRef;
						Debug.Log ("Constructing PlayState2");
						manager.darkState = false; 
			
						"Stage2".LoadScene ();
						//if (Application.loadedLevelName != "Stage2")
						//		Application.LoadLevel ("Stage2");
			
						StaticMethods.SetOneActive ("Following Camera", manager.gameDataRef.cameras); //Camera that follows the Player, setOneActive method

						player = GameObject.FindGameObjectWithTag ("Player"); //the Player GameObject is now active and can be found
						player.GetComponent<Rigidbody2D> ().isKinematic = false; //Player is now affected by physics
			
						player.transform.SetPositionXY (-6.0f, -0.4f); //set starting position for Player
						skin = Resources.Load ("GUISkin") as GUISkin;
				
						//darkness = GameObject.FindGameObjectWithTag ("Darkness");
						//dark.a += 0f;
						//darkness.GetComponent<Renderer>().material.color = dark; 
			
						//darkness.GetComponent<Renderer>().material.color.a;
						//Color dark = darkness.renderer.material.color;
						//dark.a -= 0;
						//darkness.renderer.material.color = color;
				}

        public PlayStateScene2(StateManager managerRef)
        {
            manager = managerRef;
            if(Application.loadedLevelName != "Scene2")
                Application.LoadLevel("Scene2");

            player = GameObject.Find("Player");
            controller = player.GetComponent < PlayerControl > ();

            player.rigidbody.isKinematic = false;

            foreach(var camera in manager.gameDataRef.cameras)
            {
                if(camera.name != "Following Camera")
                {
                    if (camera != null)
                        camera.SetActive(false);
                }
                else
                {
                    if (camera != null)
                        camera.SetActive(true);
                }
            }
        }

 //Constructor for BeginState
 public BeginState(StateManager managerRef)
 {
     manager = managerRef;
     if(Application.loadedLevelName != "Scene0Menu"){
         Application.LoadLevel("Scene0Menu");
     }
 }

 // Constructor
 public BeginState(StateManager manageRef)
 {
     manager = manageRef;
     futureTime = screenDuration + Time.realtimeSinceStartup;
     Debug.Log("Constructing BeginState");
     Time.timeScale = 1;
 }

        public void ShouldStartAndStopListening()
        {
            var fixtureSnapshot = new Fixture { Id = "TestId", MatchStatus = "30", Sequence = 1 };
            var plugin = new Mock<IAdapterPlugin>();

            var resource = new Mock<IResourceFacade>();
            var connector = new Mock<IAdapterPlugin>();
            var eventState = new Mock<IEventState>();
            
            var marketFilterObjectStore = new StateManager(_settings.Object,plugin.Object);
            
            resource.Setup(r => r.Sport).Returns("Football");
            resource.Setup(r => r.Content).Returns(new Summary());
            resource.Setup(r => r.StartStreaming()).Raises(r => r.StreamConnected += null, EventArgs.Empty);
            resource.Setup(r => r.StopStreaming()).Raises(r => r.StreamDisconnected += null, EventArgs.Empty);
            resource.Setup(r => r.GetSnapshot()).Returns(FixtureJsonHelper.ToJson(fixtureSnapshot));
            resource.Setup(r => r.Id).Returns("TestId");
            eventState.Setup(e => e.GetCurrentSequence(It.IsAny<string>(), It.IsAny<string>())).Returns(-1);

            var listener = new StreamListener(resource.Object, connector.Object, eventState.Object, marketFilterObjectStore,_settings.Object);
            
            listener.MonitorEvents();
            
            listener.Start();

            listener.Stop();

            listener.ShouldRaise("OnConnected");
            listener.ShouldNotRaise("OnError");
            listener.ShouldRaise("OnStop");
            listener.ShouldNotRaise("OnDisconnected","The disconnection is triggered by the user");

            connector.Verify(c => c.ProcessSnapshot(It.IsAny<Fixture>(), false), Times.Once());
        }

    public static void resetReferencesForNewLevel()
    {
        // Managers
        manager = GameObject.FindGameObjectWithTag("Manager");
        stateManager = manager.GetComponent<StateManager>();
        stateTiming = manager.GetComponent<StateTiming>();

        // Game stats and information
        gameStats = manager.GetComponent<GameStats>();
        itemDatabase = manager.GetComponent<Item_Database>();
        inventory = manager.GetComponent<Inventory>();
        market = manager.GetComponent<Market>();
        marketArrays = manager.GetComponent<MarketArrays>();
        soundEffects = GameObject.FindObjectOfType<SoundEffectsDatabase>().GetComponent<SoundEffectsDatabase>();

        // Cameras
        realtimeCamera = GameObject.FindGameObjectWithTag("Camera_Realtime").GetComponent<Camera>();
        strategicCamera = GameObject.FindGameObjectWithTag("Camera_Strategic").GetComponent<Camera>();

        // Game entities
        player = GameObject.FindGameObjectWithTag("Player");
        castle = GameObject.FindGameObjectWithTag("Castle");
        soundEffect = (GameObject)Resources.Load("OneTimeSoundEffect", typeof(GameObject));

        // Data
        lastLevelIndex = Application.loadedLevel;
        currentLevel = 1;
    }

        public SpaceDefenderPlayingState(StateManager gameStateManager)
        {
            _gameStateManager = gameStateManager;

            IDrawableGameComponent backdrop = new Backdrop(new Vector2(GameRoot.ScreenSize.X / 2.0f, GameRoot.ScreenSize.Y / 2.0f));
            _gameComponents.Add("backdrop", backdrop);

            var projectiles = new ProjectileList(Vector2.Zero);
            _gameComponents.Add("projectiles", projectiles);

            IDrawableGameComponent player = new Player(new Vector2(GameRoot.ScreenSize.X / 2.0f, GameRoot.ScreenSize.Y - 50.0f), projectiles);
            _gameComponents.Add("player", player);

            IDrawableGameComponent alien1 = new Alien(new Vector2(GameRoot.ScreenSize.X / 2.0f, GameRoot.ScreenSize.Y / 2.0f));
            _gameComponents.Add("alien1", alien1);

            IDrawableGameComponent alien2 = new Alien2(new Vector2(100.0f, 100.0f));
            _gameComponents.Add("alien2", alien2);

            //IDrawableGameComponent explosion = new AnimatedSprite("toets", Vector2.Zero, 1, 16, 1, 50);
            IDrawableGameComponent explosion = new Explosion(Vector2.Zero);
            explosion.IsAlive = false;
            _gameComponents.Add("explosion", explosion);

            IDrawableGameComponent hud = new Hud { Score = 0, Lives = 3 };
            _gameComponents.Add("hud", hud);

            _random = new Random();
        }

        public static void SetUpMocks()
        {
            _settings = new Mock<ISettings>();
            _settings.Setup(x => x.MarketFiltersDirectory).Returns(".");
            _settings.Setup(x => x.EventStateFilePath).Returns(".");
            _settings.Setup(x => x.ProcessingLockTimeOutInSecs).Returns(10);
            
            _plugin = new Mock<IAdapterPlugin>();

            _resource = new Mock<IResourceFacade>();
            _resource.Setup(r => r.Sport).Returns("FantasyFootball");
            _resource.Setup(r => r.StartStreaming()).Raises(r => r.StreamConnected += null, new EventArgs());
            _objectProvider = new Mock <IObjectProvider<Dictionary<string, FixtureOverview>>>();
            
            var stateManager = new StateManager(new Mock<ISettings>().Object,_plugin.Object);

            _supervisor = new Supervisor(_settings.Object,_objectProvider.Object);
            _supervisor.StateManager = stateManager;

            var supervisorService = new Mock<ISupervisorService>();
            supervisorService.Setup(x => x.StreamingService).Returns(new Mock<ISupervisorStreamingService>().Object);


            _supervisor.Service = supervisorService.Object;
            _supervisor.Proxy = new Mock<ISupervisorProxy>().Object;
            
            new SuspensionManager(stateManager, _plugin.Object);

        }

        public void ShouldBeCreatedWithNoStates()
        {
            var manager = new StateManager<IGameLogicState>(null);

            Assert.AreEqual(0, manager.StateCount);
            Assert.IsNull(manager.Current);
        }

        public Adapter(ISettings settings, IServiceFacade udapiServiceFacade, IAdapterPlugin platformConnector, IStreamListenerManager listenersManager)
        {
            _listenersManager = listenersManager;
            
            Settings = settings;
            UDAPIService = udapiServiceFacade;
            PlatformConnector = platformConnector;

            var statemanager = new StateManager(settings,platformConnector);
            StateManager = statemanager;
            StateProviderProxy.Init(statemanager);

            listenersManager.StateManager = statemanager;

            if (settings.StatsEnabled)
                StatsManager.Configure();

            // we just need the initialisation
            new SuspensionManager(statemanager, PlatformConnector);

            platformConnector.Initialise();
            statemanager.AddRules(platformConnector.MarketRules);


            ThreadPool.SetMinThreads(500, 500);
            
            _sports = new List<string>();
            
            _stats = StatsManager.Instance["adapter.core"].GetHandle();

            PopuplateAdapterVersionInfo();
        }

        public KinectHelpState(string name, StateManager manager, string mainWindow, string whereWindow, bool avatar)
            : base(name, manager)
        {
            mInput = manager.Coordinator.GetPlugin<KinectMovementPlugin>();

            mMainWindow = manager.Coordinator[mainWindow];

            mWhereWindow = whereWindow;
            mWhereButton = new ImageHoverTrigger(mMainWindow.OverlayManager, new DialCursorRenderer(), new OverlayImage(new Bitmap(mWhereAmIImage), .65f, .25f, mainWindow));
            mWhereButton.Triggered += new Action(mWhereButton_Triggered);

            mCloseWhereButton = new ImageHoverTrigger(Manager.Coordinator[whereWindow].OverlayManager, new DialCursorRenderer(), mWhereButton.Image);
            mCloseWhereButton.Triggered += new Action(mCloseWhereButton_Triggered);

            mClickTrigger = new CursorTrigger(new CircleRenderer(100), mMainWindow);

            SkeletonFeature helpSkeleton = new SkeletonFeature(.065f, 0f, avatar ? .23f : .13f, 125f, mainWindow);
            AddFeature(helpSkeleton);
            AddFeature(new OverlayImage(new Bitmap(avatar ? mHelpAvatarImages : mHelpFlycamImages), .05f, avatar ? .2f : .1f, mainWindow));
            AddFeature(mClickTrigger);
            //AddFeature(mWhereButton);

            mWhereButton.Active = false;
            mCloseWhereButton.Active = false;
        }

        public SetupState(StateManager managerRef)
        {
            manager = managerRef;
            if(Application.loadedLevelName != "Scene0")
                Application.LoadLevel("Scene0");
            //player = GameObject.Find("Player");
            //controller = player.GetComponent <PlayerControl>();
            mainCamera = GameObject.Find("Main Camera");
            //mainCamera = GameObject.Find("OVRPlayerController");
            // Import data
            newCube = GameObject.Find("Cube");

            // Grab a camera

            foreach(GameObject camera in manager.gameDataRef.cameras)
            {
                //if(camera.name != "OVRPlayerController")
                if(camera.name != "Main Camera")
                {
                    if (camera != null)
                        camera.SetActive(false);
                }
                else
                {
                    if (camera != null)
                        camera.SetActive(true);
                }
            }
            import(fileDirectory);
        }

 public BeginState(StateManager managerRef)
 {
     manager = managerRef;
     Debug.Log ("In BeginState");
     if(Application.loadedLevelName != "Scene0")
         Application.LoadLevel("Scene0");
 }

 public WonStateScene2(StateManager managerRef)
 {
     manager = managerRef;
     if(Application.loadedLevelName != "Scene0"){
         Application.LoadLevel("Scene0");
     }
 }

				public PlayState1 (StateManager managerRef)
				{ //Constructor
						manager = managerRef;
						Debug.Log ("Constructing PlayState1 from Xamarin");

						"Stage1".LoadScene ();
						//if (Application.loadedLevelName != "Stage1")
						//		Application.LoadLevel ("Stage1");
	
						//StaticMethods.SetActive ("Player", manager.gameDataRef.activeObjects); //Set Player active, setOneActive method
						StaticMethods.SetActive ("Darkness_Layer", manager.gameDataRef.activeObjects); 
						StaticMethods.SetOneActive ("Following Camera", manager.gameDataRef.cameras); //Camera that follows the Player, setOneActive method
						//"Following Camera".SetOneActive (manager.gameDataRef.cameras);
						//setManyActive (managerRef.gameDataRef.GUIObjects); //Set all GUI elements active, setActive method

						player = GameObject.FindGameObjectWithTag ("Player"); //the Player GameObject is now active and can be found
						player.GetComponent<Rigidbody2D> ().isKinematic = false; //Player is now affected by physics
						 
						player.transform.SetPositionXY (-5.8f, -0.4f); //set starting position for Player
						player.transform.SetLocalScale (0.3f, 0.3f, 1f); //Set initial scale

						skin = Resources.Load ("GUISkin") as GUISkin;

						/*	if (GameObject.Find ("Platform")) {
								Debug.Log ("platform");
								//platform = GameObject.Find ("Platform");
						} else
								Debug.Log ("no platform");
*/

						//darkness.GetComponent<Renderer>().material.color.a;
						//Color dark = darkness.renderer.material.color;
						//dark.a -= 0;
						//darkness.renderer.material.color = color;
				}

        public void ShouldSetCurrentToStartStateWhenCreated()
        {
            var state = new StartState();
            var manager = new StateManager<IGameLogicState>(state);

            Assert.AreSame(state, manager.Current);
        }

 public SetupState(StateManager managerRef)
 {
     manager = managerRef;
     gData = GameObject.Find("GameManager").GetComponent<GalaxyData>();
     gameData = GameObject.Find("GameManager").GetComponent<GlobalGameData>();
     Debug.Log("In SetupState");
 }