using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using ResourcesManager.Controllers;
using ResourcesManager.Interfaces;
using ResourcesManager.Models;
using ResourcesManagerTests.RepositoryTests;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web.Mvc;

namespace ResourcesManager.Controllers.Tests
{
    [TestClass()]
    public class ReservationsControllerTests
    {
        List<Reservation> expectedReservs;
        public Mock<IReservationRepository> mockReservRepo;
        ReservationsController reservController;
        UserRepositoryTests userRepoTest;
        ResourcesControllerTests resourceContTest;
        StatisticsControllerTests statContTest;
        public ReservationsControllerTests()
        {
            InitializeTestData();
        }

        [TestInitialize]
        public void InitializeTestData()
        {
            expectedReservs = new List<Reservation> {
                new Reservation() {
                    Id =1,
                    Begining = DateTime.Now.AddHours(-3),
                    End = DateTime.Now.AddHours(-2),
                    Resource = new Resource(){
                        Users = new List<ApplicationUser>(){
                            new ApplicationUser(),
                            new ApplicationUser()
                        }
                    }
                },
                new Reservation() {
                    Id =2,
                    Begining = DateTime.Now.AddHours(1),
                    End = DateTime.Now.AddHours(2),
                    Resource = new Resource(){
                        Users = new List<ApplicationUser>(){
                            new ApplicationUser(),
                            new ApplicationUser()
                        }
                    }
                },
                new Reservation() {
                    Id =3,
                    Begining = DateTime.Now.AddHours(3),
                    End = DateTime.Now.AddHours(4),
                    Resource = new Resource(){
                        Users = new List<ApplicationUser>(){
                            new ApplicationUser(),
                            new ApplicationUser()
                        }
                    }
                }
            };
            mockReservRepo = new Mock<IReservationRepository>() { CallBase = true };
            resourceContTest = new ResourcesControllerTests();
            userRepoTest = new UserRepositoryTests();
            statContTest = new StatisticsControllerTests();
            reservController = new ReservationsController(mockReservRepo.Object,
                userRepoTest.mockUserRepo.Object,
                resourceContTest.mockResourceRepo.Object,
                statContTest.mockStatRepo.Object);

            mockReservRepo.Setup(m => m.GetReservations()).Returns(expectedReservs);

            mockReservRepo.Setup(m => m.GetReservationByID(It.IsAny<int>())).Returns((int id) =>
            {
                return expectedReservs.FirstOrDefault(x => x.Id == id);
            });

            mockReservRepo.Setup(m => m.InsertReservation(It.IsAny<Reservation>())).Returns((Reservation reserv) =>
            {
                expectedReservs.Add(reserv);
                return true;
            });

            mockReservRepo.Setup(m => m.UpdateReservation(It.IsAny<Reservation>())).Returns((Reservation target) =>
            {
                var reserv = expectedReservs.FirstOrDefault(x => x.Id == target.Id);
                if (reserv == null)
                {
                    return false;
                }
                reserv.Begining = target.Begining;
                reserv.End = target.End;
                reserv.Resource = target.Resource;
                reserv.ResourceId = target.ResourceId;
                reserv.User = target.User;
                return true;
            });

            mockReservRepo.Setup(m => m.DeleteReservation(It.IsAny<int>())).Returns((int id) =>
            {
                var resource = expectedReservs.FirstOrDefault(x => x.Id == id);
                if (resource == null)
                {
                    return false;
                }
                expectedReservs.Remove(resource);
                return true;
            });
        }

        [TestMethod()]
        public void Reservation_Get_Index_Test()
        {
            var result = reservController.Index();
            Assert.IsNotNull((result as ViewResult).Model);
        }

        [TestMethod()]
        public void Reservation_Get_Week_Test()
        {
            var result = reservController.Week(DateTime.Now);
            Assert.IsNotNull((result as ViewResult).Model);
        }

        [TestMethod()]
        public void Reservation_Get_Day_Test()
        {
            var result = reservController.Day(DateTime.Now);
            Assert.IsNotNull((result as ViewResult).Model);
        }

        [TestMethod()]
        public void Reservation_Get_Create_Test()
        {
            var result = reservController.Create(1);
            Assert.IsNotNull((result as ViewResult).Model);
        }

        [TestMethod()]
        public void Reservation_Post_Create_Ok_Test()
        {
            var beforeCount = ((reservController.Index() as ViewResult).Model as ReservationViewModel).Reservations?.Count();
            Assert.AreEqual(3, beforeCount);

            reservController.Create(new Reservation() { Id = 4, Begining = DateTime.Now.AddHours(2), End = DateTime.Now.AddHours(3), ResourceId = 1 });

            var afterCount = ((reservController.Index() as ViewResult).Model as ReservationViewModel).Reservations?.Count();
            Assert.AreEqual(4, afterCount);
        }

        [TestMethod()]
        public void Reservation_Post_Create_Fail_Test()
        {
            var beforeCount = ((reservController.Index() as ViewResult).Model as ReservationViewModel).Reservations?.Count();
            Assert.AreEqual(3, beforeCount);

            reservController.Create(new Reservation() { Id = 4, Begining = DateTime.Now });

            var afterCount = ((reservController.Index() as ViewResult).Model as ReservationViewModel).Reservations?.Count();
            Assert.AreEqual(3, afterCount);
        }

        [TestMethod()]
        public void Reservation_Get_Edit_Test()
        {
            var result = reservController.Edit(1);
            Assert.IsNotNull((result as ViewResult).Model);
        }

        [TestMethod()]
        public void Reservation_Post_Edit_Ok_Test()
        {
            var beforeBegin = DateTime.Now.AddDays(2);
            reservController.Edit(new Reservation() { Id = 3, Begining = beforeBegin, End = DateTime.Now.AddDays(2).AddHours(4), ResourceId = 1 });
            var afterBegin = ((reservController.Details(3) as ViewResult).Model as Reservation).Begining;
            Assert.AreEqual(beforeBegin, afterBegin);
        }

        [TestMethod()]
        public void Reservation_Post_Edit_Fail_Test()
        {
            var beforeBegin = DateTime.Now.AddDays(2);
            reservController.Edit(new Reservation() { Id = 3, Begining = beforeBegin, ResourceId = 1 });
            var afterBegin = ((reservController.Details(3) as ViewResult).Model as Reservation).Begining;
            Assert.AreNotEqual(beforeBegin, afterBegin);
        }

        [TestMethod()]
        public void Reservation_Get_Delete_Test()
        {
            var result = reservController.Delete(1);
            Assert.IsNotNull((result as ViewResult).Model);
        }

        [TestMethod()]
        public void Reservation_Post_Delete_Ok_Test()
        {
            var beforeCount = ((reservController.Index() as ViewResult).Model as ReservationViewModel).Reservations?.Count();
            Assert.AreEqual(3, beforeCount);

            reservController.DeleteConfirmed(1);

            var afterCount = ((reservController.Index() as ViewResult).Model as ReservationViewModel).Reservations?.Count();
            Assert.AreEqual(2, afterCount);
        }

        [TestMethod()]
        public void Reservation_Post_Delete_Fail_Test()
        {
            var beforeCount = ((reservController.Index() as ViewResult).Model as ReservationViewModel).Reservations?.Count();
            Assert.AreEqual(3, beforeCount);

            reservController.DeleteConfirmed(8);

            var afterCount = ((reservController.Index() as ViewResult).Model as ReservationViewModel).Reservations?.Count();
            Assert.AreEqual(3, afterCount);
        }

        [TestCleanup]
        public void Resources_CleanUpTestData()
        {
            expectedReservs = null;
            mockReservRepo = null;
            statContTest.Statistic_CleanUpTestData();
            resourceContTest.Resources_CleanUpTestData();
            userRepoTest.User_CleanUpTestData();
        }
    }
}