using System;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

namespace NJDOTNET.Trivia.UnitTests
{
    [TestClass]
    public class GameServerTests
    {
        GameServerStub server;

        [TestInitialize]
        public void TestInitialize()
        {
            server = new GameServerStub
            {
                MockGameClient = new Mock<IGameClient>(),
                MockGameController = new Mock<GameController>(new Game())
            };
        }

        #region Start

        [TestMethod]
        public void StartShouldStartNewGame()
        {
            server.MockGameController.Expect(c => c.Start());
            server.Start();
            server.MockGameController.VerifyAll();
        }

        [TestMethod]
        public void StartWithNullControllerShouldCreateNewControllerAndStartNewGame()
        {
            // We'll need to mock our stub class below to provide additional smarts
            var mockServer = new Mock<GameServerStub>();
            var mockGameController = new Mock<GameController>(new Game());

            // Since the server's game controller will be null,
            // it's going to try to create one.  Expect a call to
            // the below pass-through method to handle this.
            mockServer.Expect(s => s.CreateNewGameControllerOverride())
                .Returns(mockGameController.Object);

            // We're still expecting a call to the controller's 
            // Start method, as usual
            mockGameController.Expect(c => c.Start());

            // Use the mock server object we init'ed above.
            mockServer.Object.Start();

            mockServer.VerifyAll();
            mockGameController.VerifyAll();
        }

        #endregion

        #region RegisterPlayer

        [TestMethod]
        public void RegisterPlayerShouldAddNewPlayer()
        {
            var player = new Player();
            server.MockGameController.Expect(c => c.AddPlayer(player));
            server.RegisterPlayer(player);
        }

        [TestMethod]
        public void RegisterPlayerShouldRegisterCurrentGameClient()
        {
            var gameClient = server.MockGameClient.Object;
            server.MockGameController.Expect(c => c.AddPlayer(null));
            server.RegisterPlayer(null);
            Assert.IsTrue(server.Clients.Contains(gameClient));
        }

        [TestMethod]
        public void RegisterPlayerShouldRegisterCurrentGameClientOnlyOnce()
        {
            var gameClient = server.MockGameClient.Object;
            server.MockGameController.Expect(c => c.AddPlayer(null));
            server.RegisterPlayer(null);
            server.RegisterPlayer(null);
            server.RegisterPlayer(null);
            Assert.AreEqual(1, server.Clients.Count(c => c == gameClient));
        }

        #endregion

        #region GameServerStub

        public class GameServerStub : GameServer
        {
            private Mock<GameController> _MockGameController;
            public Mock<GameController> MockGameController
            {
                get { return _MockGameController; }
                set
                {
                    _MockGameController = value;
                    controller = (value == null ? null : value.Object);
                }
            }
            public Mock<IGameClient> MockGameClient { get; set; }

            /// <summary>
            /// This method simply exposes the protected CreateNewGameController()
            /// method, allowing it to be overridden.
            /// </summary>
            /// <returns></returns>
            public virtual GameController CreateNewGameControllerOverride()
            {
                throw new NotImplementedException();
            }

            protected override GameController CreateNewGameController()
            {
                return CreateNewGameControllerOverride();
            }

            public override IGameClient GameClient
            {
                get { return MockGameClient == null ? null : MockGameClient.Object; }
            }

        }

        #endregion
    }
}