using System;
using System.Collections.Generic;
using System.Linq;
using LCU.API.Collections.RepoApi.Controllers;
using LCU.API.Collections.RepoApi.Models.Filters;
using LCU.API.Collections.RepoApi.Models.Requests;
using LCU.API.Collections.RepoApi.Models.Responses;
using LCU.API.Collections.RepoApi.Services;
using LCU.Shared.Collections.RepoApiLib.Exceptions;
using LCU.Shared.Collections.RepoApiLib.Models;
using LCU.Shared.Collections.RepoApiLib.Models.Results;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Moq;
using Xunit;

namespace LCU.API.Collections.RepoApiTests.Controllers
{
    public class RepoAccountControllerTest
    {
        private Mock<IRepoAccountService> mockService;
        private Mock<IRepoStatusChangeService> mockStatusService;
        private Mock<IRepoLetterService> mockLetterService;
        private RepoAccountController controller;
        private readonly Mock<IHttpContextAccessor> mockHttpContextAccessor;

        public RepoAccountControllerTest()
        {
            mockService = new Mock<IRepoAccountService>();
            mockStatusService = new Mock<IRepoStatusChangeService>();
            mockLetterService = new Mock<IRepoLetterService>();
            mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
            controller = new RepoAccountController(mockService.Object, mockLetterService.Object,
                mockStatusService.Object, mockHttpContextAccessor.Object);
        }

        [Fact]
        public async void Get_OK()
        {
            mockService.Setup(service => service.ListAll(It.IsAny<PageFilter>(), It.IsAny<RepoAccountPostFilter>()))
                .ReturnsAsync(
                    new PagedResult<RepoAccount>()
                    {
                        Total = 1,
                        Items = new List<RepoAccount>
                        {
                            new RepoAccount()
                            {
                                RepoId = 5,
                                AccountNo = "1234567-98"
                            }
                        }
                    });

            // arrange
            var filter = new PageFilter();

            // act
            var result = await controller.Get(filter);
            Assert.NotNull(result);
            var okResult = result as OkObjectResult;

            // assert
            Assert.NotNull(okResult);
            Assert.Equal(200, okResult.StatusCode);

            var okValue = okResult.Value as PagedResponse<RepoAccount>;
            Assert.NotNull(okValue);
            Assert.Equal(1, okValue.TotalItems);
        }

        [Fact]
        public async void Get_Repo_Account_Status_Changes_OK()
        {
            // arrange
            var statusChanges = new List<RepoStatusChange>
            {
                new RepoStatusChange()
                {
                    Id = 1,
                    RepoId = 5,
                    StatusFrom = "None",
                    StatusTo = "O4R",
                    ChangedBy = "System",
                    ChangedDate = DateTime.Now
                }
            };
            mockStatusService.Setup(x => x.ListByAccount(It.IsAny<int>())).ReturnsAsync(statusChanges);

            // act
            var result = await controller.GetStatusChangesByRepoId(5);
            Assert.NotNull(result);
            var okResult = result as OkObjectResult;

            // assert
            Assert.NotNull(okResult);
            Assert.Equal(200, okResult.StatusCode);

            var okValue = okResult.Value as IEnumerable<RepoStatusChange>;
            Assert.NotNull(okValue);
            Assert.True(statusChanges.SequenceEqual(okValue));
        }

        [Fact]
        public async void Get_Repo_Account_Letters_OK()
        {
            // arrange
            var letters = new List<RepoLetter>
            {
                new RepoLetter
                {
                    NoticeType = "Type",
                    DateSent = DateTime.Now,
                    DateExpired = DateTime.Now.AddDays(15),
                    DaysToRedeem = 15
                }
            };
            mockLetterService.Setup(x => x.ListByAccountIdAsync(It.IsAny<int>())).ReturnsAsync(letters);

            // act
            var result = await controller.GetLettersByRepoId(5);
            Assert.NotNull(result);
            var okResult = result as OkObjectResult;

            // assert
            Assert.NotNull(okResult);
            Assert.Equal(200, okResult.StatusCode);

            var okValue = okResult.Value as IEnumerable<RepoLetter>;
            Assert.NotNull(okValue);
            Assert.True(letters.SequenceEqual(okValue));
        }


        [Fact]
        public async void GetByAccountNo_OK()
        {
            // arrange
            var repos = new List<RepoAccount>
            {
                new RepoAccount()
                {
                    RepoId = 5,
                    AccountNo = "1234567-98",
                    DateClosed = DateTime.Today
                },
                new RepoAccount()
                {
                    RepoId = 6,
                    AccountNo = "1234567-98",
                    DateClosed = DateTime.Today
                }
            };
            mockService.Setup(x => x.GetByAccountNo(It.IsAny<string>())).ReturnsAsync(repos);

            // act
            var result = await controller.GetByAccountNo("55555-123");
            Assert.NotNull(result);
            var okResult = result as OkObjectResult;

            // assert
            Assert.NotNull(okResult);
            Assert.Equal(200, okResult.StatusCode);

            var okValue = okResult.Value as IReadOnlyCollection<RepoAccount>;
            Assert.NotNull(okValue);
            Assert.Equal(5, okValue.First().RepoId);
        }

        [Fact]
        public async void GetById_OK()
        {
            // arrange
            var repos = new List<RepoAccount>
            {
                new RepoAccount()
                {
                    RepoId = 5,
                    AccountNo = "1234567-98"
                }
            };
            mockService.Setup(x => x.Get(It.IsAny<int>())).ReturnsAsync(repos.First());

            // act
            var result = await controller.GetById(5);
            Assert.NotNull(result);
            var okResult = result as OkObjectResult;

            // assert
            Assert.NotNull(okResult);
            Assert.Equal(200, okResult.StatusCode);

            var okValue = okResult.Value as RepoAccount;
            Assert.NotNull(okValue);
            Assert.Equal(5, okValue.RepoId);
        }

        // Post tests
        [Fact]
        public async void Post_OK()
        {
            // arrange
            var postAlert = new RepoAccount()
            {
                AccountNo = "1234567-98",
                Borrowers = new List<Borrower>()
                {
                    new Borrower()
                    {
                        RepoId = 0,
                        IndividualId = "123456",
                        OwnershipType = 6,
                        IndividualName = "John Doe"
                    }
                },
                Collaterals = new List<Collateral>
                {
                    new Collateral()
                    {
                        CollateralId = 1234567,
                        RepoId = 2345678
                    }
                }
            };

            // act
            var result = await controller.Post(postAlert);
            Assert.NotNull(result);
            var okResult = result as OkObjectResult;

            // assert
            Assert.NotNull(okResult);
            Assert.Equal(200, okResult.StatusCode);
        }

        [Fact]
        public async void Post_Bad_Request()
        {
            // arrange
            var postAlert = new RepoAccount()
            {
                AccountNo = "1234567-98",
            };
            controller.ModelState.AddModelError("Message", "The message field is required.");

            // act
            var result = await controller.Post(postAlert);
            Assert.NotNull(result);
            var badRequestResult = result as BadRequestObjectResult;

            // assert
            Assert.NotNull(badRequestResult);
            Assert.Equal(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
        }

        [Fact]
        public async void Search_Ok()
        {
            // arrange
            var searchPhrase = "abcd123";
            mockService.Setup(service => service.SearchRepoAccounts(It.IsAny<string>(), It.IsAny<int>())).ReturnsAsync(
                new List<RepoAccount>()
                {
                    new RepoAccount(),
                    new RepoAccount(),
                    new RepoAccount()
                });

            // act
            var result = await controller.SearchRepoAccounts(searchPhrase);
            Assert.NotNull(result);
            var okResult = result as OkObjectResult;

            // assert
            Assert.NotNull(okResult);

            var okResultValue = okResult.Value as IReadOnlyCollection<RepoAccount>;
            Assert.NotNull(okResultValue);
            Assert.Equal(3, okResultValue.Count());
        }

        [Fact]
        public async void Search_Empty_Bad_Request()
        {
            // arrange
            var searchPhrase = "";

            // act
            var result = await controller.SearchRepoAccounts(searchPhrase);
            Assert.NotNull(result);
            var badRequestResult = result as BadRequestObjectResult;

            // assert
            Assert.NotNull(badRequestResult);
            Assert.Equal(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
            Assert.Equal("Search Phrase Cannot Be Empty", badRequestResult.Value);
        }

        [Fact]
        public async void Search_Low_Characters_Bad_Request()
        {
            // arrange
            var searchPhrase = "12";

            // act
            var result = await controller.SearchRepoAccounts(searchPhrase);
            Assert.NotNull(result);
            var badRequestResult = result as BadRequestObjectResult;

            // assert
            Assert.NotNull(badRequestResult);
            Assert.Equal(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
            Assert.Equal("Search Phrase Must Be At Least Three (3) Characters Long", badRequestResult.Value);
        }

        [Fact]
        public async void Search_Max_Results_Bad_Request()
        {
            // arrange
            var searchPhrase = "143";
            mockService.Setup(service => service.SearchRepoAccounts(It.IsAny<string>(), It.IsAny<int>()))
                .ThrowsAsync(new MaxItemException(1492));

            // act
            var result = await controller.SearchRepoAccounts(searchPhrase);
            Assert.NotNull(result);
            var payloadTooLargeResult = result as ObjectResult;

            // assert
            Assert.NotNull(payloadTooLargeResult);
            Assert.Equal(StatusCodes.Status413PayloadTooLarge, payloadTooLargeResult.StatusCode);
            Assert.Equal("Too Many Search Results. (Max: 100) (Found: 1492)", payloadTooLargeResult.Value);
        }

        [Fact]
        public async void DeleteAccountByID_Exception()
        {
            //arrange
            mockService.Setup(service => service.DeleteAsync(It.IsAny<int>())).ThrowsAsync(new Exception("oops"));

            var result = await controller.DeleteAccountById(5);
            var badres = result as StatusCodeResult;
            Assert.NotNull(result);
            Assert.Equal(500, badres.StatusCode);
        }

        [Fact]
        public async void DeleteAccountByID_Ok()
        {
            //arrange
            mockService.Setup(service => service.DeleteAsync(It.IsAny<int>())).ReturnsAsync(new RepoAccount() { });

            var result = await controller.DeleteAccountById(5);
            var okres = result as OkObjectResult;
            Assert.NotNull(result);
            Assert.Equal(200, okres.StatusCode);
        }
    }
}