using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Moq;
using NUnit.Framework;
using LCU.Library.Internal.CoreApiWrapperLib.Configuration;
using LCU.Library.Internal.CoreApiWrapperLib.CoreApiUtilities;
using LCU.Library.Internal.CoreApiWrapperLib.CoreDbUtilities;
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreResponses;
using LCU.Library.Internal.ApiSecurity.Models;
using LCU.Library.Internal.LcuHttpClient.HttpRequest;
using LCU.Library.Internal.CoreApiWrapperLib.Utilities;

namespace LCU.Api.Internal.CoreApiWrapperTest.DataAccess
{
    public class AccountDaoTest
    {
        private IAccountDao _accountDao;
        private CoreConfiguration _coreConfiguration;
        private ApiSecurityConfiguration _apiSecurityConfiguration;
        private Mock<ICoreRequest> _mockCoreRequest;
        private Mock<ICoreDbExecution> _mockCoreDbExecution;
        private Mock<IPostRequest> _mockPostRequest;
        private Mock<IPutRequest> _mockPutRequest;

        [SetUp]
        public void SetUp()
        {
            _mockCoreDbExecution = new Mock<ICoreDbExecution>();
            _mockCoreRequest = new Mock<ICoreRequest>();
            _mockPostRequest = new Mock<IPostRequest>();
            _mockPutRequest = new Mock<IPutRequest>();

            _coreConfiguration = new CoreConfiguration()
            {
                CoreSoapApiConfiguration = new CoreSoapApiConfiguration()
                {
                    CoreSoapApiWrapperHost = "test.lcu-internal.com",
                    CoreSoapEndpointConfiguration = new CoreSoapEndpointConfiguration()
                    {
                        PutAccountAnalysisGroupMaintenanceRequest = "TEST/Account/AccountAnalysisGroupMaintenanceRequest"
                    }
                }
            };

            _apiSecurityConfiguration = new ApiSecurityConfiguration()
            {
                InternalApiKeySet = new Dictionary<string, string>()
                {
                    ["CoreSoapApiWrapper"] = "TEST"
                }
            };

            _accountDao = new AccountDao(_mockCoreRequest.Object,
                                         _coreConfiguration,
                                         _apiSecurityConfiguration,
                                         _mockCoreDbExecution.Object,
                                         _mockPostRequest.Object,
                                         _mockPutRequest.Object);
        }

        [Test]
        public async Task GetActivityAccountDetailsByAccountNumbers_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<ActivityAccountDetails, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<ActivityAccountDetails>()
                {
                    new() {AccountNumber = 1},
                    new() {AccountNumber = 2},
                    new() {AccountNumber = 3}
                }).Verifiable();

            var results = await _accountDao.GetActivityAccountDetailsByAccountNumbers(new List<string>() { "1", "2", "3" });
            Assert.NotNull(results);
            Assert.AreEqual(3,results.Count);

            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<ActivityAccountDetails, object>(It.Is<string>(str => str.Contains("ActivityAccountDetailsByAccountNbr") && str.Contains(":accountNumbers")),
                    It.IsAny<It.IsAnyType>()));
        }
        
        [Test]
        public async Task GetActivityAccountDetailsByAccountNumbers_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<ActivityAccountDetails, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Oops"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _accountDao.GetActivityAccountDetailsByAccountNumbers(new List<string>() { "1", "2", "3" }));
          
            
            _mockCoreDbExecution.Verify(x =>
                x.ExecuteQuery<ActivityAccountDetails, object>(It.Is<string>(str => str.Contains("ActivityAccountDetailsByAccountNbr") && str.Contains(":accountNumbers")),
                    It.IsAny<It.IsAnyType>()));
        }

        [Test]
        public async Task FindOwnersByAccountNumber_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<AccountOwnership, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<AccountOwnership> { new AccountOwnership() { FirstName = "Tim" } }).Verifiable();

            var result = await _accountDao.FindOwnersByAccountNumber(12345, new DateTime());

            Assert.NotNull(result);
            var firstResult = result.First();
            Assert.AreEqual(firstResult.FirstName, "Tim");
            _mockCoreDbExecution.Verify();
        }

        [Test]
        public void FindOwnersByAccountNumber_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<AccountOwnership, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Error thrown from unit test"));

            Assert.ThrowsAsync<Exception>(async () => await _accountDao.FindOwnersByAccountNumber(12345, new DateTime()));

            _mockCoreDbExecution.Verify();
        }

        [Test]
        public async Task FindOwnersByPersonName_OK()
        {
            var firstName = "Tim";
            var role = "OWN";

            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<AccountOwnership, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<AccountOwnership> { new AccountOwnership() { FirstName = firstName, Role = role } }).Verifiable();

            var result = await _accountDao.FindPrimaryOwnersByPersonName(firstName);

            Assert.NotNull(result);
            var firstResult = result.First();
            Assert.AreEqual(firstResult.FirstName, firstName);
            Assert.AreEqual(firstResult.Role, role);
            _mockCoreDbExecution.Verify();
        }

        [Test]
        public void FindOwnersByPersonName_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<AccountOwnership, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Error thrown from unit test"));

            Assert.ThrowsAsync<Exception>(async () => await _accountDao.FindPrimaryOwnersByPersonName("Tim"));

            _mockCoreDbExecution.Verify();
        }

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

            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<AccountOwnership, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(new List<AccountOwnership> { new AccountOwnership() { OrganizationName = organizationName } }).Verifiable();

            var result = await _accountDao.FindPrimaryOwnersByOrganizationName(organizationName);

            Assert.NotNull(result);
            var firstResult = result.First();
            Assert.AreEqual(firstResult.OrganizationName, organizationName);
            _mockCoreDbExecution.Verify();
        }

        [Test]
        public void FindOwnersByOrganizationName_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<AccountOwnership, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ThrowsAsync(new Exception("Error thrown from unit test"));

            Assert.ThrowsAsync<Exception>(async () => await _accountDao.FindPrimaryOwnersByOrganizationName("The Big Company"));

            _mockCoreDbExecution.Verify();
        }

        [Test]
        public async Task FindAccountsForGroupAnalysisUpdate_OK()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<string>(It.IsAny<string>()))
                .ReturnsAsync(new List<string> { { "11111111" }, { "22222222" } }).Verifiable();

           var result = await _accountDao.FindAccountsToUpdateAccountAnalysis();

            Assert.NotNull(result);
            Assert.AreEqual(result.First(), "11111111");
            _mockCoreDbExecution.Verify();
        }

        [Test]
        public async Task FindAccountsForGroupAnalysisUpdate_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<string, object>(null, null))
                .ThrowsAsync(new Exception("Error thrown from unit test"));
            _mockCoreDbExecution.Verify();
            var result = await _accountDao.FindAccountsToUpdateAccountAnalysis();

            Assert.IsEmpty(result);
        }

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

            var basicResponse = new BasicResponse()
            {
                Success = true
            };

            var endpoint = HttpUtilities.BuildHttpsUri(_coreConfiguration.CoreSoapApiConfiguration.CoreSoapApiWrapperHost,
                                                       _coreConfiguration.CoreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountAnalysisGroupMaintenanceRequest);
            _mockPutRequest.Setup(x => x.Async<AccountAnalysisGroupMaintenanceRequest, BasicResponse>(endpoint,
                                                                                                      It.IsAny<AccountAnalysisGroupMaintenanceRequest>(),
                                                                                                      It.IsAny<Dictionary<string, string>>(),
                                                                                                      It.IsAny<int>(),
                                                                                                      It.IsAny<int>()))
                .ReturnsAsync(basicResponse).Verifiable();

            var result = await _accountDao.UpdateAccountAnalysis(accountAnalysisGroupMaintenanceRequest);

            Assert.NotNull(result);
            Assert.AreEqual(result.Success, true);
        }

        [Test]
        public async Task UpdateAccountsForGroupAnalysisUpdate_Exception()
        {
            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<string, object>(null, null))
                .ThrowsAsync(new Exception("Error thrown from unit test"));
            _mockCoreDbExecution.Verify();
            var result = await _accountDao.FindAccountsToUpdateAccountAnalysis();

            Assert.IsEmpty(result);
        }

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

            var basicResponse = new BasicResponse()
            {
                Success = true
            };

            var endpoint = HttpUtilities.BuildHttpsUri(_coreConfiguration.CoreSoapApiConfiguration.CoreSoapApiWrapperHost,
                                                       _coreConfiguration.CoreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountNickNameUpdateRequest);
            _mockPutRequest.Setup(x => x.Async<AccountNickNameUpdateRequest, BasicResponse>(endpoint,
                                                                                            It.IsAny<AccountNickNameUpdateRequest>(),
                                                                                            It.IsAny<Dictionary<string, string>>(),
                                                                                            It.IsAny<int>(),
                                                                                            It.IsAny<int>()))
                .ReturnsAsync(basicResponse).Verifiable();

            var result = await _accountDao.UpdateAccountNickName(accountRequest);

            Assert.NotNull(result);
            Assert.AreEqual(result.Success, true);
        }

        [Test]
        public async Task UpdateAccountNickName_Exception()
        {
            var accountRequest = new AccountNickNameUpdateRequest()
            {
                AccountNumber = 0,
                AccountDescription = "TestError"
            };
            var result = await _accountDao.UpdateAccountNickName(accountRequest);

            Assert.IsNull(result);
        }
        [Test]
        public async Task UpdateAccountCreditReportType_OK()
        {
            var accountRequest = new AccountCreditReportTypeUpdateRequest()
            {
                AccountNumber = 123,
                CreditReportType = "EXCL"
            };

            var basicResponse = new BasicResponse()
            {
                Success = true
            };

            var endpoint = HttpUtilities.BuildHttpsUri(_coreConfiguration.CoreSoapApiConfiguration.CoreSoapApiWrapperHost,
                                           _coreConfiguration.CoreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountCreditReportTypeUpdateRequest);
            _mockPutRequest.Setup(x => x.Async<AccountCreditReportTypeUpdateRequest, BasicResponse>(endpoint,
                                                                                                    It.IsAny<AccountCreditReportTypeUpdateRequest>(),
                                                                                                    It.IsAny<Dictionary<string, string>>(),
                                                                                                    It.IsAny<int>(),
                                                                                                    It.IsAny<int>()))
                .ReturnsAsync(basicResponse).Verifiable();

            var result = await _accountDao.UpdateAccountCreditReportType(accountRequest);

            Assert.NotNull(result);
            Assert.AreEqual(result.Success, true);
        }

        [Test]
        public async Task UpdateAccountCreditReportType_Exception()
        {
            var accountRequest = new AccountCreditReportTypeUpdateRequest()
            {
                AccountNumber = 0,
                CreditReportType = "EXCL"
            };
            var result = await _accountDao.UpdateAccountCreditReportType(accountRequest);

            Assert.IsNull(result);
        }

        [Test]
        public async Task GetAccountsByMajorMinorBranchAndStatus_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"
                }
            };

            var response = new List<AccountsByMajorMinorBranchAndStatusResponse>()
            {
                new AccountsByMajorMinorBranchAndStatusResponse()
                {
                    AccountNumber = 1234,
                    BranchCode = 987654321,
                    Name = "Test Name"
                },
                new AccountsByMajorMinorBranchAndStatusResponse()
                {
                    AccountNumber = 5678,
                    BranchCode = 987654321,
                    Name = "Test Name Two"
                }
            };

            _mockCoreDbExecution
                .Setup(x => x.ExecuteQuery<AccountsByMajorMinorBranchAndStatusResponse, object>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(response).Verifiable();

            var result = await _accountDao.GetAccountsByMajorMinorBranchAndStatus(request);

            Assert.NotNull(result);
            var firstResult = result.First();
            Assert.AreEqual(firstResult.AccountNumber, 1234);
            Assert.AreEqual(firstResult.Name, "Test Name");
            _mockCoreDbExecution.Verify();
        }

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

			var basicResponse = new BasicResponse()
			{
				Success = true
			};

            var endpoint = HttpUtilities.BuildHttpsUri(_coreConfiguration.CoreSoapApiConfiguration.CoreSoapApiWrapperHost,
                                           _coreConfiguration.CoreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountContractDateUpdateRequest);
            _mockPutRequest.Setup(x => x.Async<AccountContractDateUpdateRequest, BasicResponse>(endpoint,
                                                                                                It.IsAny<AccountContractDateUpdateRequest>(),
                                                                                                It.IsAny<Dictionary<string, string>>(),
                                                                                                It.IsAny<int>(),
                                                                                                It.IsAny<int>()))
                .ReturnsAsync(basicResponse).Verifiable();

            var result = await _accountDao.UpdateAccountContractDate(accountRequest);

			Assert.NotNull(result);
			Assert.AreEqual(result.Success, true);
		}

		[Test]
		public async Task UpdateAccountContractDate_Exception()
		{
			var accountRequest = new AccountContractDateUpdateRequest
			{
				AccountNumber = 123,
				ContractDate = DateTime.Now
			};
			var result = await _accountDao.UpdateAccountContractDate(accountRequest);

			Assert.IsNull(result);
		}
	}
}