using System.Collections.Generic;
using System.Web.Mvc;
using Moq;
using NUnit.Framework;
using NUnit.Framework.SyntaxHelpers;
using Website;
using Website.Controllers;

namespace UnitTests.Controllers
{
    [TestFixture]
    public class MembersControllerTests : ControllerTester
    {
        Mock<IAuthenticationProvider> mockAuthenticationProvider;
        IAuthenticationProvider authenticationProvider;
        Mock<IRoleProvider> mockRoleProvider;
        IRoleProvider roleProvider;

        [SetUp]
        public void SetUp()
        {
            mockAuthenticationProvider = new Mock<IAuthenticationProvider>();
            authenticationProvider = mockAuthenticationProvider.Object;

            mockRoleProvider = new Mock<IRoleProvider>();
            roleProvider = mockRoleProvider.Object;
        }

        [Test]
        public void Index()
        {
            var controller = new MembersController(authenticationProvider, null);
            var result = controller.Login("username", "password", "redirectUrl") as ViewResult;
            result.AssertViewName("Login");
            result.AssertViewDataMappings(new Dictionary<string, object>
                                              {
                                                  {"username", "username"},
                                                  {"password", "password"},
                                                  {"redirectUrl", "redirectUrl"}
                                              });
        }

        [Test]
        public void Authenticate_valid_user_with_redirect()
        {
            // Expect a call to the Authenticate method on the authentication provider.
            // Let it pass (return true)
            mockAuthenticationProvider.Expect(p => p.Authenticate("username", "password")).Returns(true);

            // If the authentication succeeds, then the SignIn should come shortly after!
            mockAuthenticationProvider.Expect(p => p.SignIn("username"));

            var controller = new MembersController(authenticationProvider, null);
            var result = controller.Authenticate("username", "password", "redirectUrl") as RedirectResult;

            Assert.AreEqual("redirectUrl", result.Url);

            mockAuthenticationProvider.VerifyAll();
        }

        [Test]
        public void Authenticate_valid_user_without_redirect()
        {
            // Expect a call to the Authenticate method on the authentication provider.
            // Let it pass (return true)
            mockAuthenticationProvider.Expect(p => p.Authenticate("username", "password")).Returns(true);

            // If the authentication succeeds, then the SignIn should come shortly after!
            mockAuthenticationProvider.Expect(p => p.SignIn("username"));

            var controller = new MembersController(authenticationProvider, null);
            var result = controller.Authenticate("username", "password", null) as RedirectResult;

            Assert.AreEqual("~/", result.Url);

            mockAuthenticationProvider.VerifyAll();
        }

        [Test]
        public void Authenticate_invalid_user_fails()
        {
            // Expect a call to the Authenticate method on the authentication provider.
            // Do NOT authenticate the user! (return false)
            mockAuthenticationProvider.Expect(p => p.Authenticate("INVALID_USER", "password")).Returns(false);

            var tempData = New.TempData();
            var controller = new MembersController(authenticationProvider, null) { TempData = tempData };
            var result = controller.Authenticate("INVALID_USER", "password", null) as RedirectToRouteResult;

            Assert.IsNotNull(tempData["ErrorMessage"]);
            result.AssertAction("Login");

            mockAuthenticationProvider.VerifyAll();
        }

        [Test]
        public void Logout_logged_in_user()
        {
            mockAuthenticationProvider.Expect(p => p.SignOut());

            var controller = new TestMembersController(authenticationProvider, null) 
                                { IsUserAuthenticated = true };
            var result = controller.Logout();

            result.AssertViewName("Logout");

            mockAuthenticationProvider.VerifyAll();
        }

        [Test]
        public void Logout_does_nothing_for_anonymous_user()
        {
            var controller = new TestMembersController(authenticationProvider, null) 
                                { IsUserAuthenticated = false };
            var result = controller.Logout();

            result.AssertViewName("Logout");

            mockAuthenticationProvider.VerifyAll();
        }


        [Test]
        public void Roles()
        {
            var controller = new MembersController(null, null);
            var result = controller.Roles() as ViewResult;
            result.AssertViewName("Roles");
        }

        [Test]
        public void CreateRole()
        {
            mockRoleProvider.Expect(p => p.CreateRole("new role")).Verifiable();

            var tempData = New.TempData();
            var controller = new MembersController(null, roleProvider) { TempData = tempData };
            var result = controller.CreateRole("new role") as ViewResult;
            
            result.AssertViewName("Roles");
            Assert.IsNotNull(tempData[ControllerBase.SUCCESS_MESSAGE_KEY]);

            mockRoleProvider.VerifyAll();
        }


        #region AddUsersToRole

        [Test]
        public void AddUsersToRole()
        {
            mockRoleProvider.Expect(p => p.AddUsersToRoles(It.IsAny<string[]>(), It.IsAny<string[]>()))
                .Verifiable();

            var tempData = New.TempData();
            var controller = new MembersController(null, roleProvider) { TempData = tempData };
            var result = controller.AddUsersToRole("new role", "user1,user2") as ViewResult;
            
            result.AssertViewName("Roles");
            Assert.IsNotNull(tempData[ControllerBase.SUCCESS_MESSAGE_KEY]);

            mockRoleProvider.VerifyAll();
        }
        [Test]
        public void AddUsersToRole_fails_for_empty_role_name()
        {
            var tempData = New.TempData();
            var controller = new MembersController(null, roleProvider) { TempData = tempData };
            var result = controller.AddUsersToRole(string.Empty, "user1,user2") as ViewResult;
            
            result.AssertViewName("Roles");
            Assert.IsNotNull(tempData[ControllerBase.ERROR_MESSAGE_KEY]);
        }
        [Test]
        public void AddUsersToRole_fails_for_empty_user_names()
        {
            var tempData = New.TempData();
            var controller = new MembersController(null, roleProvider) { TempData = tempData };
            var result = controller.AddUsersToRole("role", string.Empty) as ViewResult;
            
            result.AssertViewName("Roles");
            Assert.IsNotNull(tempData[ControllerBase.ERROR_MESSAGE_KEY]);
        }

        #endregion


        #region RemoveUsersFromRoles

        [Test]
        public void RemoveUsersFromRole()
        {
            mockRoleProvider.Expect(p => p.RemoveUsersFromRoles(It.IsAny<string[]>(), It.IsAny<string[]>()))
                .Verifiable();

            var tempData = New.TempData();
            var controller = new MembersController(null, roleProvider) { TempData = tempData };
            var result = controller.RemoveUsersFromRole("existing role", "user1,user2") as ViewResult;
            
            result.AssertViewName("Roles");
            Assert.IsNotNull(tempData[ControllerBase.SUCCESS_MESSAGE_KEY]);

            mockRoleProvider.VerifyAll();
        }

        [Test]
        public void RemoveUsersFromRole_fails_for_empty_role_name()
        {
            var tempData = New.TempData();
            var controller = new MembersController(null, roleProvider) { TempData = tempData };
            var result = controller.RemoveUsersFromRole(string.Empty, "user1,user2") as ViewResult;

            result.AssertViewName("Roles");
            Assert.IsNotNull(tempData[ControllerBase.ERROR_MESSAGE_KEY]);
        }
        [Test]
        public void RemoveUsersFromRole_fails_for_empty_user_names()
        {
            var tempData = New.TempData();
            var controller = new MembersController(null, roleProvider) { TempData = tempData };
            var result = controller.RemoveUsersFromRole("role", string.Empty) as ViewResult;

            result.AssertViewName("Roles");
            Assert.IsNotNull(tempData[ControllerBase.ERROR_MESSAGE_KEY]);
        }
        #endregion



        protected class TestMembersController : MembersController
        {
            public bool IsUserAuthenticated { get; set; }

            public TestMembersController(IAuthenticationProvider provider, IRoleProvider roleProvider)
                : base(provider, roleProvider)
            {
                
            }

            protected override bool UserAuthenticated
            {
                get { return IsUserAuthenticated; }
            }
        }
    }
}