using System;
using System.Collections.Generic;
using System.Text;
using Xunit;
using Moq;
using System.Linq;
using LCU.Shared.Collections.RepoApiLib.Repositories;
using LCU.Shared.Collections.RepoApiLib.Models;
using LCU.API.Collections.RepoApi.Services;
using Microsoft.AspNetCore.Mvc.RazorPages;
using LCU.API.Collections.RepoApi.Models.Filters;
using LCU.API.Collections.RepoApi.Models.Responses;
using LCU.Shared.Collections.RepoApiLib.Models.Results;
using Castle.DynamicProxy.Generators;
using LCU.API.Collections.RepoApi.Exceptions;
using Xunit.Sdk;
using System.Threading.Tasks;
using System.Threading;

namespace LCU.API.Collections.RepoApiTests.Services
{
    public class AuditRecordServiceTests
    {
        [Fact]
        public async void ListAll_Ok()
        {
            PageFilter filter = new PageFilter() 
            { 
                Limit = 5,
                Page = 1
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.ListAllAsync(It.IsAny<int>(), It.IsAny<int>())).ReturnsAsync(new PagedResult<AuditRecord>() { Total = 1 });

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            var res = await auditRecordService.ListAll(filter);
            Assert.NotNull(res);
            Assert.Equal(1,res.Total);
        }

        [Fact]
        public async void ListAll_Exception()
        {
            PageFilter filter = new PageFilter()
            {
                Limit = 5,
                Page = 1
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.ListAllAsync(It.IsAny<int>(), It.IsAny<int>())).ThrowsAsync(new Exception("oops")); 

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auditRecordService.ListAll(filter));
        }

        [Fact]
        public async void SaveAsync_Ok()
        {

            AuditRecord auditRecord = new AuditRecord()
            {
                ID = 5
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.AddAsync(It.IsAny<AuditRecord>())).Returns(Task.CompletedTask);
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            var res = await auditRecordService.SaveAsync(auditRecord);
            Assert.NotNull(res);
            Assert.Equal(auditRecord, res);
        }

        [Fact]
        public async void SaveAsync_Exception()
        {

            AuditRecord auditRecord = new AuditRecord()
            {
                ID = 5
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.AddAsync(It.IsAny<AuditRecord>()));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auditRecordService.SaveAsync(auditRecord));
        }

        [Fact]
        public async void Get_OK()
        {
            AuditRecord auditRecord = new AuditRecord()
            {
                ID = 5
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(auditRecord);
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            var res = await auditRecordService.Get(5);
            Assert.NotNull(res);
            Assert.Equal(auditRecord, res);
        }

        [Fact]
        public async void Get_Exception()
        {
            AuditRecord auditRecord = new AuditRecord()
            {
                ID = 5
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ThrowsAsync(new Exception("oops"));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async() => await auditRecordService.Get(5));
        }

        [Fact]
        public async void UpdateAsync_OK()
        {
            AuditRecord auditRecord = new AuditRecord()
            {
                ID = 5
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(auditRecord);
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockAuditRecordRepo.Setup(repo => repo.Update(It.IsAny<AuditRecord>()));

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            var res = await auditRecordService.UpdateAsync(auditRecord);
            Assert.NotNull(res);
            Assert.Equal(auditRecord,res);
        }

        [Fact]
        public async void UpdateAsync_Existing_Exception()
        {
            AuditRecord auditRecord = new AuditRecord()
            {
                ID = 5
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ThrowsAsync(new Exception("oops"));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockAuditRecordRepo.Setup(repo => repo.Update(It.IsAny<AuditRecord>()));

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auditRecordService.UpdateAsync(auditRecord));
        }

        [Fact]
        public async void UpdateAsync_Existing_Null()
        {
            AuditRecord auditRecord = new AuditRecord()
            {
                ID = 5
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).Returns(Task.FromResult<AuditRecord>(null));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockAuditRecordRepo.Setup(repo => repo.Update(It.IsAny<AuditRecord>()));

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<NotFoundException>(async () => await auditRecordService.UpdateAsync(auditRecord));
        }

        [Fact]
        public async void UpdateAsync_Update_Exception()
        {
            AuditRecord auditRecord = new AuditRecord()
            {
                ID = 5
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(auditRecord);
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockAuditRecordRepo.Setup(repo => repo.Update(It.IsAny<AuditRecord>())).Throws(new Exception("oops"));

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auditRecordService.UpdateAsync(auditRecord));
        }

        [Fact]
        public async void DeleteAsync_OK()
        {
            AuditRecord auditRecord = new AuditRecord()
            {
                ID = 5
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(auditRecord);
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockAuditRecordRepo.Setup(repo => repo.Remove(It.IsAny<AuditRecord>()));

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            var res = await auditRecordService.DeleteAsync(5);
            Assert.NotNull(res);
            Assert.Equal(auditRecord, res);
        }

        [Fact]
        public async void DeleteAsync_Existing_Exception()
        {
            AuditRecord auditRecord = new AuditRecord()
            {
                ID = 5
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ThrowsAsync(new Exception("oops"));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockAuditRecordRepo.Setup(repo => repo.Remove(It.IsAny<AuditRecord>()));

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auditRecordService.DeleteAsync(5));
        }

        [Fact]
        public async void DeleteAsync_Existing_Null()
        {
            AuditRecord auditRecord = new AuditRecord()
            {
                ID = 5
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).Returns(Task.FromResult<AuditRecord>(null));
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockAuditRecordRepo.Setup(repo => repo.Remove(It.IsAny<AuditRecord>()));

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<NotFoundException>(async () => await auditRecordService.DeleteAsync(5));
        }

        [Fact]
        public async void DeleteAsync_Update_Exception()
        {
            AuditRecord auditRecord = new AuditRecord()
            {
                ID = 5
            };

            var _mockAuditRecordRepo = new Mock<IAuditRecordRepository>();
            var _mockUnitOfWork = new Mock<IUnitOfWork>();

            _mockAuditRecordRepo.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(auditRecord);
            _mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            _mockAuditRecordRepo.Setup(repo => repo.Remove(It.IsAny<AuditRecord>())).Throws(new Exception("oops"));

            AuditRecordService auditRecordService = new AuditRecordService(_mockAuditRecordRepo.Object, _mockUnitOfWork.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await auditRecordService.DeleteAsync(5));
        }

    }
}