using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using Moq;
using NUnit.Framework;
using LCU.Api.Internal.CoreApiWrapper.Controllers;
using LCU.Api.Internal.CoreApiWrapper.Services;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
using System.Threading.Tasks;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Account;

namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
{
    public class AccountControllerTest
    {
        private AccountController _accountController;
        private Mock<IAccountService> _mockAccountService;

        [SetUp]
        public void SetUp()
        {
            _mockAccountService = new Mock<IAccountService>();
            _accountController = new AccountController(_mockAccountService.Object);
        }

        [Test]
        public async Task AccountMaintenanceRequest_OK()
        {
            var accountMaintenanceRequest = new List<AccountMaintenanceRequest>
            {
                new() {
                AccountNumber = 123,
                DeliveryMethod = "PRNT"
                }
            };
            
            var results = await _accountController.AccountMaintenanceRequest(accountMaintenanceRequest);

            _mockAccountService.Verify(x => x.PutAccountMaintenanceRequest(accountMaintenanceRequest), Times.Once);

            Assert.NotNull(results);
            var okResult = results as OkResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task AccountMaintenanceRequest_Exception()
        {
            var accountMaintenanceRequest = new List<AccountMaintenanceRequest>
            {
                new() {
                    AccountNumber = 123,
                    DeliveryMethod = "PRNT"
                }
            };
            
            _mockAccountService.Setup(x => x.PutAccountMaintenanceRequest(accountMaintenanceRequest)).Throws(new Exception("Oops")).Verifiable();

            var results = await _accountController.AccountMaintenanceRequest(accountMaintenanceRequest);

            _mockAccountService.Verify();

            Assert.NotNull(results);
            var badRes = results as BadRequestObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(400, badRes.StatusCode);
        }

        [Test]
        public async Task GetActivityAccountDetailsByAccountNumber_OK()
        {
            _mockAccountService.Setup(x => x.GetActivityAccountDetailsByAccountNumbers(It.IsAny<List<long>>()))
                .ReturnsAsync(new List<ActivityAccountDetails>()
                {
                    new() { AccountNumber = 1 },
                    new() { AccountNumber = 1 },
                    new() { AccountNumber = 1 },
                });

           var res = await _accountController.GetActivityAccountDetailsByAccountNumber(new ActivityAccountDetailsRequest() { AccountNumbers = new List<long>(){1, 2, 3 }});
           Assert.NotNull(res);
           var okres = res as OkObjectResult;
           Assert.NotNull(okres);
           Assert.AreEqual(200, okres.StatusCode);
        }
        
        
        [Test]
        public async Task GetActivityAccountDetailsByAccountNumber_Exception()
        {
            _mockAccountService.Setup(x => x.GetActivityAccountDetailsByAccountNumbers(It.IsAny<List<long>>())).ThrowsAsync(new Exception("Oops"));
            var res = await _accountController.GetActivityAccountDetailsByAccountNumber(
                (new ActivityAccountDetailsRequest() { AccountNumbers = new List<long>() { 1, 2, 3 } }));
            Assert.NotNull(res);
            var badRes = res as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);;
        }

        [Test]
        public async Task GetOwnersByAccountNumber_OK()
        {
            var accountNumber = 12345;
            var createdDate = new DateTime(1900, 1, 1);

            _mockAccountService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, createdDate)).ReturnsAsync(
                new List<AccountOwnership>() {
                    new ()
                    {
                        IsPrimaryOwner = true,
                        PersonNumber = 12345,
                        ByOrgNbr = 45678
                    },
                    new ()
                    {
                        IsPrimaryOwner = false,
                        PersonNumber = 09876,
                        ByOrgNbr = 98765
                    },
                }).Verifiable();

            var results = await _accountController.GetOwnersByAccountNumber(accountNumber, createdDate.ToShortDateString());

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            var result = okResult.Value as List<AccountOwnership>;
            Assert.NotNull(result);
            _mockAccountService.Verify();
        }

        [Test]
        public async Task GetOwnersByAccountNumber_NoContent()
        {
            var accountNumber = 12345;
            var createdDate = new DateTime(1900, 1, 1);

            _mockAccountService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, createdDate)).ReturnsAsync((List<AccountOwnership>)null).Verifiable();

            var results = await _accountController.GetOwnersByAccountNumber(accountNumber, createdDate.ToShortDateString());

            Assert.NotNull(results);
            var noContentResult = results as NoContentResult;
            Assert.NotNull(noContentResult);
            Assert.AreEqual(204, noContentResult.StatusCode);
        }

        [Test]
        public async Task GetOwnersByAccountNumber_Error_StatusServerError()
        {
            var accountNumber = 12345;
            var createdDate = new DateTime(1900, 1, 1);

            _mockAccountService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, createdDate)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();

            var results = await _accountController.GetOwnersByAccountNumber(accountNumber, createdDate.ToShortDateString());

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAccountService.Verify();
        }

        [Test]
        public async Task GetOwnersByAccountNumber_Null_BadRequest()
        {
            var accountNumber = 12345;
            var createdDate = "Not a date";

            var results = await _accountController.GetOwnersByAccountNumber(accountNumber, createdDate);

            _mockAccountService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<long>(), It.IsAny<DateTime>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
        }

        [Test]
        public async Task GetPrimaryOwnersByPersonName_OK()
        {
            var personName = "Pete Peterson";

            _mockAccountService.Setup(x => x.GetPrimaryOwnersByPersonName(personName)).ReturnsAsync(
                new List<AccountOwnership>() {
                    new ()
                    {
                        IsPrimaryOwner = true,
                        FirstName = "Pete",
                        LastName = "Peterson"
                    }
                }).Verifiable();

            var results = await _accountController.GetPrimaryOwnersByPersonName(personName);

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            var result = okResult.Value as List<AccountOwnership>;
            Assert.NotNull(result);
            _mockAccountService.Verify();
        }

        [Test]
        public async Task GetPrimaryOwnersByPersonName_NoContent()
        {
            var personName = "Pete Peterson";

            _mockAccountService.Setup(x => x.GetPrimaryOwnersByPersonName(personName)).ReturnsAsync((List<AccountOwnership>)null).Verifiable();

            var results = await _accountController.GetPrimaryOwnersByPersonName(personName);

            Assert.NotNull(results);
            var noContentResult = results as NoContentResult;
            Assert.NotNull(noContentResult);
            Assert.AreEqual(204, noContentResult.StatusCode);
        }

        [Test]
        public async Task GetPrimaryOwnersByPersonName_Error_StatusServerError()
        {
            var personName = "Pete Peterson";

            _mockAccountService.Setup(x => x.GetPrimaryOwnersByPersonName(personName)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();

            var results = await _accountController.GetPrimaryOwnersByPersonName(personName);

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAccountService.Verify();
        }

        [Test]
        public async Task GetPrimaryOwnersByPersonName_Null_BadRequest()
        {
            var personName = "";

            var results = await _accountController.GetPrimaryOwnersByPersonName(personName);

            _mockAccountService.Verify(x => x.GetPrimaryOwnersByPersonName(It.IsAny<string>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
        }

        [Test]
        public async Task GetPrimaryOwnersByOrganizationName_OK()
        {
            var organizationName = "The Big Company";

            _mockAccountService.Setup(x => x.GetPrimaryOwnersByOrganizationName(organizationName)).ReturnsAsync(
                new List<AccountOwnership>() {
                    new ()
                    {
                        IsPrimaryOwner = true,
                        OrganizationName = "The Big Company"
                    }
                }).Verifiable();

            var results = await _accountController.GetPrimaryOwnersByOrganizationName(organizationName);

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            var result = okResult.Value as List<AccountOwnership>;
            Assert.NotNull(result);
            _mockAccountService.Verify();
        }

        [Test]
        public async Task GetPrimaryOwnersByOrganizationName_NoContent()
        {
            var organizationName = "The Big Company";

            _mockAccountService.Setup(x => x.GetPrimaryOwnersByOrganizationName(organizationName)).ReturnsAsync((List<AccountOwnership>)null).Verifiable();

            var results = await _accountController.GetPrimaryOwnersByOrganizationName(organizationName);

            Assert.NotNull(results);
            var noContentResult = results as NoContentResult;
            Assert.NotNull(noContentResult);
            Assert.AreEqual(204, noContentResult.StatusCode);
        }

        [Test]
        public async Task GetPrimaryOwnersByOrganizationName_Error_StatusServerError()
        {
            var organizationName = "The Big Company";

            _mockAccountService.Setup(x => x.GetPrimaryOwnersByOrganizationName(organizationName)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();

            var results = await _accountController.GetPrimaryOwnersByOrganizationName(organizationName);

            Assert.NotNull(results);
            var badRes = results as StatusCodeResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAccountService.Verify();
        }

        [Test]
        public async Task GetPrimaryOwnersByOrganizationName_Null_BadRequest()
        {
            var organizationName = "";

            var results = await _accountController.GetPrimaryOwnersByOrganizationName(organizationName);

            _mockAccountService.Verify(x => x.GetPrimaryOwnersByOrganizationName(It.IsAny<string>()), Times.Never());

            Assert.NotNull(results);
            var badRequest = results as BadRequestObjectResult;
            Assert.NotNull(badRequest);
            Assert.AreEqual(400, badRequest.StatusCode);
        }

        [Test]
        public async Task GetAccountsForGroupMaintenance_OK()
        {
            _mockAccountService.Setup(x => x.GetAccountsForGroupAnalysisMaintenance()).ReturnsAsync(
                new List<string>() {
                        "1111111",
                        "22222222"
                }).Verifiable();

            var results = await _accountController.GetAccountsForGroupAnalysisMaintenance();

            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            var result = okResult.Value as List<string>;
            Assert.NotNull(result);
            _mockAccountService.Verify();
        }

        [Test]
        public async Task GetAccountsForGroupMaintenance_Error_StatusServerError()
        {
            _mockAccountService.Setup(x => x.GetAccountsForGroupAnalysisMaintenance()).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();

            var results = await _accountController.GetAccountsForGroupAnalysisMaintenance();

            var badRes = results as ObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
            _mockAccountService.Verify();
        }

        [Test]
        public async Task UpdateAccountGroupMaintenanceRequest_OK()
        {
            var accountAnalysisGroupMaintenanceRequest = new AccountAnalysisGroupMaintenanceRequest()
            {
                AccountNumber = 123,
                IsGenerateAnalysisStatement = true,
                IsPrintAnalysisStatement = true,
                IsUseForServiceCharge = true
            };

            var results = await _accountController.PutAccountAnalysisGroup(accountAnalysisGroupMaintenanceRequest);

            _mockAccountService.Verify(x => x.UpdateAccountAnalysisMaintenance(accountAnalysisGroupMaintenanceRequest), Times.Once);
            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task UpdateAccountGroupMaintenanceRequest_Exception()
        {
            var accountAnalysisGroupMaintenanceRequest = new AccountAnalysisGroupMaintenanceRequest()
            {
                AccountNumber = 123,
                IsGenerateAnalysisStatement = true,
                IsPrintAnalysisStatement = true,
                IsUseForServiceCharge = true
            };

            _mockAccountService.Setup(x => x.UpdateAccountAnalysisMaintenance(accountAnalysisGroupMaintenanceRequest)).Throws(new Exception("Oops")).Verifiable();
            var results = await _accountController.PutAccountAnalysisGroup(accountAnalysisGroupMaintenanceRequest);
            _mockAccountService.Verify();

            var badRes = results as ObjectResult;
            Assert.NotNull(badRes); 
            Assert.AreEqual(500, badRes.StatusCode);
        }

        [Test]
        public async Task AccountNickNameUpdateRequest_OK()
        {
            var accountRequest = new AccountNickNameUpdateRequest
            {
                AccountNumber = 123,
                AccountDescription = "TestOk"
            };

            var results = await _accountController.PutAccountNickNameUpdateRequest(accountRequest);

            _mockAccountService.Verify(x => x.UpdateAccountNickName(accountRequest), Times.Once);
            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task GetPersonNumberByAccountNumber_OK()
        {
            long accountNumber = 1234;

            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(accountNumber)).ReturnsAsync(
                new Account() {
                        AccountNumber = 1234,
                        ReportingForPersonNumber = 5678
                }).Verifiable();

            
            var results = await _accountController.GetAccountByAccountNumber(accountNumber);

            _mockAccountService.Verify(x => x.GetAccountDetailsByAccountNumber(accountNumber), Times.Once);
            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task AccountNickNameUpdateRequest_Exception()
        {
            var accountRequest = new AccountNickNameUpdateRequest
            {
                AccountNumber = 123,
                AccountDescription = "TestError"
            };

            _mockAccountService.Setup(x => x.UpdateAccountNickName(accountRequest)).Throws(new Exception("Oops")).Verifiable();
            var results = await _accountController.PutAccountNickNameUpdateRequest(accountRequest);
            _mockAccountService.Verify();

            var badRes = results as ObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
        }
    
        [Test]
        public async Task AccountCreditReportTypeUpdateRequest_OK()
        {
            var accountRequest = new AccountCreditReportTypeUpdateRequest
            {
                AccountNumber = 123,
                CreditReportType = "EXCL"
            };

            var results = await _accountController.PutAccountCreditReportType(accountRequest);

            _mockAccountService.Verify(x => x.UpdateAccountCreditReportType(accountRequest), Times.Once);
            Assert.NotNull(results);
            var okResult = results as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task AccountCreditReportTypeUpdateRequest_Exception()
        {
            var accountRequest = new AccountCreditReportTypeUpdateRequest
            {
                AccountNumber = 123,
                CreditReportType = "EXCL"
            };

            _mockAccountService.Setup(x => x.UpdateAccountCreditReportType(accountRequest)).Throws(new Exception("Oops")).Verifiable();
            var results = await _accountController.PutAccountCreditReportType(accountRequest);
            _mockAccountService.Verify();

            var badRes = results as ObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
        }

        [Test]
        public async Task GetAccountByAccountNumber_Exception()
        {

            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(1000L)).Throws(new Exception("Oops")).Verifiable();
            var results = await _accountController.GetAccountByAccountNumber(1000L);
            _mockAccountService.Verify();

            var badRes = results as ObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
        }

        [Test]
        public async Task GetAccountByAccountNumber_Ok()
        {

            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(1000L)).ReturnsAsync(
                new Account()
                {
                    AccountNumber = 1000L,
                    
                }).Verifiable();
            var results = await _accountController.GetAccountByAccountNumber(1000L);
            _mockAccountService.Verify();

            var goodResult = results as ObjectResult;
            Assert.NotNull(goodResult);
            Assert.AreEqual(200, goodResult.StatusCode);
        }

        [Test]
        public async Task GetAccountByMajorMinorBranchAndStatus_Ok()
        {
            var request = new AccountsByMajorMinorBranchAndStatusRequest()
            {
                BranchCodes = new List<long>()
                {
                    1234,
                    1235
                },
                AccountStatuses = new List<string>()
                {
                    "Status"
                },
                MajorTypes = new List<string>()
                {
                    "Major"
                },
                MinorTypes = new List<string>()
                {
                    "MinorOne",
                    "MinorTwo"
                }
            };

            _mockAccountService.Setup(x => x.GetAccountsByMajorMinorBranchAndStatus(request)).ReturnsAsync(
                new List<AccountsByMajorMinorBranchAndStatusResponse>()
                {
                    new AccountsByMajorMinorBranchAndStatusResponse()
                    {
                        AccountNumber = 123456789,
                        BranchCode = 1310,
                        Name = "Test Testerson"
                    }
                }).Verifiable();

            var results = await _accountController.GetAccountsByMajorMinorBranchAndStatus(request);
            _mockAccountService.Verify();

            var goodResult = results as ObjectResult;
            Assert.NotNull(goodResult);
            Assert.AreEqual(200, goodResult.StatusCode);
        }

        [Test]
        public async Task GetAccountByMajorMinorBranchAndStatus_Exception()
        {

            _mockAccountService.Setup(x => x.GetAccountsByMajorMinorBranchAndStatus(It.IsAny<AccountsByMajorMinorBranchAndStatusRequest>())).Throws(new Exception("Oops")).Verifiable();
            var results = await _accountController.GetAccountsByMajorMinorBranchAndStatus(new AccountsByMajorMinorBranchAndStatusRequest());
            _mockAccountService.Verify();

            var badRes = results as ObjectResult;
            Assert.NotNull(badRes);
            Assert.AreEqual(500, badRes.StatusCode);
        }

		[Test]
		public async Task AccountContractDateUpdateRequest_OK()
		{
            var accountRequest = new AccountContractDateUpdateRequest
            {
                AccountNumber = 123,
                ContractDate = DateTime.Now
            };

			var results = await _accountController.PutAccountContractDateUpdateRequest(accountRequest);

			_mockAccountService.Verify(x => x.UpdateAccountContractDate(accountRequest), Times.Once);
			Assert.NotNull(results);
			var okResult = results as OkObjectResult;
			Assert.NotNull(okResult);
			Assert.AreEqual(200, okResult.StatusCode);
		}

		[Test]
		public async Task AccountContractDateUpdateRequest_Exception()
		{
			var accountRequest = new AccountContractDateUpdateRequest
			{
				AccountNumber = 123,
				ContractDate = DateTime.Now
			};

			_mockAccountService.Setup(x => x.UpdateAccountContractDate(accountRequest)).Throws(new Exception("Oops")).Verifiable();
			var results = await _accountController.PutAccountContractDateUpdateRequest(accountRequest);
			_mockAccountService.Verify();

			var badRes = results as ObjectResult;
			Assert.NotNull(badRes);
			Assert.AreEqual(500, badRes.StatusCode);
		}
	}
}