using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using Autofac.Extras.Moq;
using FestiSpec.Domain;
using FestiSpec.Domain.Repository;
using FestiSpec.Test.Helper;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using Xunit;
using Assert = Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
using xAssert = Xunit.Assert;

namespace FestiSpec.Test.Domain
{
    [TestClass]
    public class GenericRepositoryTest
    {
        private readonly DbSet<User> UserDbSet;
        public GenericRepositoryTest()
        {
            UserDbSet = MockDbSet.GetQueryableMockDbSet(GetDummyUsers(), UserDbSetSetup);
        }

        #region GenericRepository Get based methods
        [Fact]
        public void GetAllUsers_ValidCall()
        {
            using (var mock = AutoMock.GetLoose())
            {
                mock.Mock<IEntitiesContext>()
                    .Setup(context => context.Set<User>())
                    .Returns(UserDbSet);

                mock.Mock<IGenericRepository<User>>()
                    .Setup(repo => repo.GetAll());

                var userRepo = mock.Create<UserRepository>();

                var expected = GetDummyUsers();
                var actual = userRepo.GetAll().ToList();

                xAssert.True(actual != null);
                xAssert.Equal(expected.Count, actual.Count);
            }
        }

        [Fact]
        public void GetUsers_ValidCall()
        {
            using (var mock = AutoMock.GetLoose())
            {
                mock.Mock<IEntitiesContext>()
                    .Setup(context => context.Set<User>())
                    .Returns(UserDbSet);

                mock.Mock<IGenericRepository<User>>()
                    .Setup(repo => repo.Get(null, ""));

                var userRepo = mock.Create<UserRepository>();

                var expected = GetDummyUsers();
                var actual = userRepo.Get(null, "").ToList();

                xAssert.True(actual != null);
                xAssert.Equal(expected.Count, actual.Count);
            }
        }

        [Fact]
        public void GetSpecificUser_ValidCall()
        {
            using(var mock = AutoMock.GetLoose())
            {
                mock.Mock<IEntitiesContext>()
                    .Setup(context => context.Set<User>())
                    .Returns(UserDbSet);

                mock.Mock<IGenericRepository<User>>()
                    .Setup(repo => repo.Get(u => u.Firstname == "Tom", ""));

                var userRepo = mock.Create<UserRepository>();

                var expected = GetDummyUsers().Where(users => users.Firstname == "Tom").ToList();
                var actual = userRepo.Get(u => u.Firstname == "Tom", "").ToList();

                xAssert.True(actual != null);
                xAssert.Equal(expected.Count, actual.Count);
            }
        }

        [Theory]
        [InlineData(1)]
        [InlineData(int.MinValue)]
        [InlineData(int.MaxValue)]
        public void GetUserById_ValidCall(int id)
        {
            using (var mock = AutoMock.GetLoose())
            {
                mock.Mock<IEntitiesContext>()
                    .Setup(context => context.Set<User>())
                    .Returns(UserDbSet);

                mock.Mock<IGenericRepository<User>>()
                    .Setup(repo => repo.GetById(id));

                var userRepo = mock.Create<UserRepository>();

                var expected = GetDummyUsers().SingleOrDefault(users => users.Id == id);
                var actual = userRepo.GetById(id);

                xAssert.True(actual != null);
                xAssert.Equal(expected.Username, actual.Username);
            }
        }
        #endregion

        #region GenericRepository Add based methods
        [Fact]
        public void AddUser_ValidCall()
        {
            using (var mock = AutoMock.GetLoose())
            {
                var user = new User
                {
                    Id = 2,
                    Firstname = "Frank",
                    Lastname = "Frankenstein",
                    Username = "fr3nkst31n"
                };

                mock.Mock<IEntitiesContext>()
                    .Setup(context => context.Set<User>())
                    .Returns(UserDbSet);

                mock.Mock<IGenericRepository<User>>()
                    .Setup(repo => repo.Add(user));

                var userRepo = mock.Create<UserRepository>();

                // Adding user
                userRepo.Add(user);

                var expected = user;
                var actual = userRepo.GetById(2);

                xAssert.True(actual != null);
                Assert.AreEqual(expected, actual);
            }
        }

        [Fact]
        public void AddRangeUser_ValidCall()
        {
            using (var mock = AutoMock.GetLoose())
            {
                var users = new List<User>
                {
                    new User()
                    {
                        Id = 2,
                        Firstname = "Frank",
                        Lastname = "Frankenstein",
                        Username = "fr3nkst31n"
                    },
                    new User()
                    {
                        Id = 3,
                        Firstname = "Stefan",
                        Lastname = "Gras",
                        Username = "Stefgras123"
                    },
                    new User()
                    {
                        Id = 4,
                        Firstname = "Henk",
                        Lastname = "de Steen",
                        Username = "henkSteen"
                    }
                };

                mock.Mock<IEntitiesContext>()
                    .Setup(context => context.Set<User>())
                    .Returns(UserDbSet);

                mock.Mock<IGenericRepository<User>>()
                    .Setup(repo => repo.AddRange(users));

                var userRepo = mock.Create<UserRepository>();

                // Adding users
                userRepo.AddRange(users);

                int currUserIndex = 0;

                for(int i = 2; i <= 4; i++)
                {
                    var expected = users[currUserIndex];
                    var actual = userRepo.GetById(i);

                    xAssert.True(actual != null);
                    Assert.AreEqual(expected, actual);

                    currUserIndex++;
                }
            }
        }
        #endregion

        #region Test specific setup
        private List<User> GetDummyUsers()
        {
            var users = new List<User>
            {
                new User()
                {
                    Id = 1,
                    Firstname = "Tom",
                    Lastname = "Steenbergen",
                    Username = "t0mStb3rg"
                },
                new User()
                {
                    Id = int.MinValue,
                    Firstname = "Tom",
                    Lastname = "Thomassen",
                    Username = "tomThoms142"
                },
                new User()
                {
                    Id = int.MaxValue,
                    Firstname = "Frank",
                    Lastname = "Regenbui",
                    Username = "frankregen978"
                }
            };

            return users;
        }

        private void UserDbSetSetup(Mock<DbSet<User>> dbSet, List<User> sourceList)
        {
            dbSet
                .Setup(set => set.Find(It.IsAny<object[]>()))
                .Returns((object[] id) => sourceList.SingleOrDefault(e => e.Id.Equals(id[0])));
        }
        #endregion
    }
}