using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using NJDOTNET.Trivia;
using System.Linq;
using NJDOTNET.Trivia.Exceptions;

namespace NJDOTNET.Trivia.UnitTests
{
    [TestClass]
    public class GameControllerTests
    {
        Mock<Game> mockGame;
        Mock<GameController> mockController;
        GameController controller;

        [TestInitialize]
        public void TestInitialize()
        {
            mockGame = new Mock<Game>(new Mock<IQuestionProvider>().Object);
            mockController = new Mock<GameController>(mockGame.Object);
            controller = mockController.Object;
        }

        [TestMethod]
        public void StartStartsGameWhenControllerIsInReadyStateAndHasPlayers()
        {
            mockGame.Expect(g => g.Players).Returns(new List<Player> { new Player() });
            controller.Status = GameStatus.PlayerRegistration;
            controller.Start();
            Assert.AreEqual(GameStatus.InProgress, controller.Status);
        }

        [TestMethod]
        public void StartTriggersOnGameStartedEvent()
        {
            setupEnvironmentForGameStart();
            var eventTriggered = false;
            controller.OnGameStarted += delegate { eventTriggered = true; };
            controller.Start();
            Assert.IsTrue(eventTriggered);
        }

        [TestMethod]
        [ExpectedException(typeof(InvalidStateException))]
        public void StartThrowsExceptionWhenControllerIsInReadyState()
        {
            controller.Status = GameStatus.InProgress;
            controller.Start();
        }

        [TestMethod]
        public void EndEndsGameWhenGameIsInProgress()
        {
            controller.Status = GameStatus.InProgress;
            controller.End();
            Assert.AreEqual(GameStatus.Ended, controller.Status);
        }

        [TestMethod]
        public void EndTriggersOnGameEndedEvent()
        {
            var eventTriggered = false;
            controller.OnGameEnded += delegate { eventTriggered = true; };
            controller.Status = GameStatus.InProgress;
            controller.End();
            Assert.IsTrue(eventTriggered);
        }

        [TestMethod]
        [ExpectedException(typeof(InvalidStateException))]
        public void EndThrowsExceptionWhenGameIsNOTInProgress()
        {
            controller.Status = GameStatus.Ended;
            controller.End();
        }

        [TestMethod]
        public void AddPlayerAddsNewPlayerWhenGameIsOpenForRegistration()
        {
            Assert.AreEqual(GameStatus.PlayerRegistration, controller.Status);
            var p = new Player();
            controller.AddPlayer(p);
            Assert.IsTrue(mockGame.Object.Players.Contains(p));
        }

        [TestMethod]
        [ExpectedException(typeof(PlayerRegistrationClosedException))]
        public void AddPlayerThrowExceptionWhenGameIsNotOpenForRegistration()
        {
            controller.Status = GameStatus.InProgress;
            controller.AddPlayer(new Player());
        }

        [TestMethod]
        public void GenerateGameSummaryProducesSummary()
        {
            Assert.IsNotNull(controller.GenerateGameSummary());
        }


        private void setupEnvironmentForGameStart()
        {
            mockGame.Expect(g => g.Players).Returns(new List<Player> { new Player() });
            controller.Status = GameStatus.PlayerRegistration;
        }
    }
}