using System;
using System.Linq;
using System.Collections.Generic;
using System.Threading.Tasks;
using NUnit.Framework;
using Moq;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
using LCU.Api.Internal.CoreApiWrapper.Services;
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;

namespace LCU.Api.Internal.CoreApiWrapperTest.Service
{
    public class AccountUserFieldServiceTest
    {
        private readonly AccountUserFieldService _accountUserFieldService;
        private readonly Mock<IAccountService> _mockAccountService;
        private readonly Mock<IAccountUserFieldDao> _mockAccountUserFieldDao;

        public AccountUserFieldServiceTest()
        {
            _mockAccountService = new Mock<IAccountService>();
            _mockAccountUserFieldDao = new Mock<IAccountUserFieldDao>();
            _accountUserFieldService = new AccountUserFieldService(_mockAccountService.Object,_mockAccountUserFieldDao.Object);
        }

        [Test]
        public void GetAccountUserFieldCoreApiResponseAsync_ExceptionThrown()
        {
            _mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).Throws(new Exception("Oops"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _accountUserFieldService.GetAccountUserFieldCoreApiResponseAsync("testaccountiddsafasfsadfsdfsdafsd"));
        }

        [Test]
        public async Task GetAccountUserFieldCoreApiResponseAsync_UserFieldsReturned()
        {
            var accountUserFields = new List<AccountUserField>()
            {
                new AccountUserField()
                {
                  AccountNumber = 100001,
                   UserFieldCode = "TEST1",
                   Value = "Y"

                },
                new AccountUserField()
                {
                   AccountNumber = 100002,
                   UserFieldCode = "TEST2",
                   Value = "N"
                }
            };
            var coreMessageheader = new CoreMessageHeader();
            var accountUserFieldCoreApiResponse = new CoreApiMessage<IEnumerable<AccountUserField>>(coreMessageheader, accountUserFields);
            _mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).ReturnsAsync(accountUserFieldCoreApiResponse);


            var result = await _accountUserFieldService.GetAccountUserFieldCoreApiResponseAsync("testaccountidasfasdfsdfsadfsdfsdf");
            Assert.NotNull(result);
            Assert.AreEqual(2, result.MessageBody.Count());
        }

        [Test]
        public void UpdateAccountUserFieldAsync_ExceptionThrown()
        {
            _mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(), It.IsAny<string>(), It.IsAny<string>())).Throws(new Exception("Oops"));

            var accountUserUpdateRequest = new AccountUserFieldRequest()
            {
                AccountNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            Assert.ThrowsAsync<Exception>(async () =>
                await _accountUserFieldService.UpdateAccountUserFieldAsync(accountUserUpdateRequest, 10002312312, "testaccountidfdafdfasfdsf", "TEST1"));
        }

        [Test]
        public async Task UpdateAccountUserFieldAsync_UpdatedUserFieldsReturned()
        {
            var updatedAccountUserField = new AccountUserField()
            {
                AccountNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y",
                LastMaintained = Convert.ToDateTime("9/1/2001")
            };
            _mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
                                                                It.IsAny<string>(),
                                                                It.IsAny<string>())).ReturnsAsync(updatedAccountUserField);

            var accountUserUpdateRequest = new AccountUserFieldRequest()
            {
                AccountNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            var result = await _accountUserFieldService.UpdateAccountUserFieldAsync(accountUserUpdateRequest, 10002312312, "testaccountidfdafdfasfdsf", "TEST1");
            Assert.NotNull(result);
            Assert.AreEqual(updatedAccountUserField, result);
        }

        [Test]
        public void InsertAccountUserFieldAsync_ExceptionThrown()
        {
            _mockAccountUserFieldDao.Setup(x => x.InsertAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(), It.IsAny<string>())).Throws(new Exception("Oops"));

            var accountUserUpdateRequest = new AccountUserFieldRequest()
            {
                AccountNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            Assert.ThrowsAsync<Exception>(async () =>
                await _accountUserFieldService.InsertAccountUserFieldAsync(accountUserUpdateRequest, "testaccountidfdafdfasfdsf"));
        }

        [Test]
        public async Task InsertAccountUserFieldAsync_InsertUserFieldsReturned()
        {
            var createdAccountUserField = new AccountUserField()
            {
                AccountNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y",
                LastMaintained = Convert.ToDateTime("9/1/2001")
            };
            _mockAccountUserFieldDao.Setup(x => x.InsertAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
                                                                It.IsAny<string>())).ReturnsAsync(createdAccountUserField);

            var accountUserUpdateRequest = new AccountUserFieldRequest()
            {
                AccountNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            var result = await _accountUserFieldService.InsertAccountUserFieldAsync(accountUserUpdateRequest, "testaccountidfdafdfasfdsf");
            Assert.NotNull(result);
            Assert.AreEqual(createdAccountUserField, result);
        }

        [Test]
        public void UpdateAccountUserFieldsAsync_AccountNull_NullExceptionThrown()
        {
            var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
            {
                new AccountUserFieldRequest()
                {
                   AccountNumber = 100001,
                   UserFieldCode = "TEST1",
                   Value = "Y"

                },
                new AccountUserFieldRequest()
                {
                    AccountNumber = 100002,
                   UserFieldCode = "TEST2",
                   Value = "N"
                }
            };
            Account testAccount = null;
            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);

            Assert.ThrowsAsync<NullReferenceException>(async () =>
                 await _accountUserFieldService.UpdateAccountUserFieldsAsync(accountUserFieldUpdateRequests));
        }

        [Test]
        public void UpdateAccountUserFieldsAsync_ExistingUserFieldNull_NullExceptionThrown()
        {
            var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
            {
                new AccountUserFieldRequest()
                {
                   AccountNumber = 100001,
                   UserFieldCode = "TEST1",
                   Value = "Y"

                },
                new AccountUserFieldRequest()
                {
                    AccountNumber = 100002,
                   UserFieldCode = "TEST2",
                   Value = "N"
                }
            };
            Account testAccount = new Account()
            {
                Id = "TEST-adsfasdfas[]djfas"
            };
            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);

            IEnumerable<AccountUserField> accountUserFields = new List<AccountUserField>();
            CoreMessageHeader coreMessageHeader = new CoreMessageHeader();
            CoreApiMessage<IEnumerable<AccountUserField>> coreApiMessageAccountUserFields = new CoreApiMessage<IEnumerable<AccountUserField>>(coreMessageHeader, accountUserFields);
            _mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(),
                                                       It.IsAny<string>())).ReturnsAsync(coreApiMessageAccountUserFields);

            Assert.ThrowsAsync<NullReferenceException>(async () =>
                 await _accountUserFieldService.UpdateAccountUserFieldsAsync(accountUserFieldUpdateRequests));
        }

        [Test]
        public void UpdateAccountUserFieldsAsync_UpdateUserFieldNull_NullExceptionThrown()
        {
            var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
            {
                new AccountUserFieldRequest()
                {
                   AccountNumber = 100001,
                   UserFieldCode = "TEST1",
                   Value = "Y"

                },
                new AccountUserFieldRequest()
                {
                    AccountNumber = 100002,
                   UserFieldCode = "TEST2",
                   Value = "N"
                }
            };
            Account testAccount = new Account()
            {
                Id = "TEST-adsfasdfas[]djfas"
            };
            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);

            IEnumerable<AccountUserField> accountUserFields = new List<AccountUserField>()
            {
                new AccountUserField()
                {
                    Id = "TEST1",
                    AccountNumber = 100001,
                    UserFieldCode = "TEST1",
                    Value = "N"
                },
                new AccountUserField()
                {
                    Id = "TEST2",
                    AccountNumber = 100002,
                    UserFieldCode = "TEST2",
                    Value = "Y"
                }
            };
            CoreMessageHeader coreMessageHeader = new CoreMessageHeader(1122000321);
            CoreApiMessage<IEnumerable<AccountUserField>> coreApiMessageAccountUserFields = new CoreApiMessage<IEnumerable<AccountUserField>>(coreMessageHeader, accountUserFields);
            _mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(),
                                                       It.IsAny<string>())).ReturnsAsync(coreApiMessageAccountUserFields);

            AccountUserField updatedAccountUserField = null;
            _mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
                                                                It.IsAny<string>(),
                                                                It.IsAny<string>())).ReturnsAsync(updatedAccountUserField);

            Assert.ThrowsAsync<NullReferenceException>(async () =>
                 await _accountUserFieldService.UpdateAccountUserFieldsAsync(accountUserFieldUpdateRequests));
        }

        [Test]
        public async Task UpdateAccountUserFieldsAsync_ListofUpdateduserfields()
        {
            var request1 = new AccountUserFieldRequest()
            {
                AccountNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"

            };
            var request2 = new AccountUserFieldRequest()
            {
                AccountNumber = 100002,
                UserFieldCode = "TEST2",
                Value = "N"
            };

            var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
            {
                request1,
                request2
            };

            Account testAccount = new Account()
            {
                Id = "TEST-adsfasdfas[]djfas"
            };
            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);


            var accountUserField1 = new AccountUserField()
            {
                Id = "TEST1",
                AccountNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "N"
            };
            var accountUserField2 = new AccountUserField()
            {
                Id = "TEST2",
                AccountNumber = 100002,
                UserFieldCode = "TEST2",
                Value = "Y"
            };

            IEnumerable<AccountUserField> accountUserFields = new List<AccountUserField>()
            {
                accountUserField1,
                accountUserField2
            };
            CoreMessageHeader coreMessageHeader = new CoreMessageHeader(1122000321);
            CoreApiMessage<IEnumerable<AccountUserField>> coreApiMessageAccountUserFields = new CoreApiMessage<IEnumerable<AccountUserField>>(coreMessageHeader, accountUserFields);
            _mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(),
                                                       It.IsAny<string>())).ReturnsAsync(coreApiMessageAccountUserFields);

            AccountUserField updatedAccountUserField1 = new AccountUserField()
            {
                AccountNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            _mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
                                                                It.IsAny<string>(),
                                                                accountUserField1.Id)).ReturnsAsync(updatedAccountUserField1);

            AccountUserField updatedAccountUserField2 = new AccountUserField()
            {
                AccountNumber = 100002,
                UserFieldCode = "TEST2",
                Value = "N"
            };
            _mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
                                                                It.IsAny<string>(),
                                                                accountUserField2.Id)).ReturnsAsync(updatedAccountUserField2);

            var result = await _accountUserFieldService.UpdateAccountUserFieldsAsync(accountUserFieldUpdateRequests);

            Assert.NotNull(result);
            Assert.AreEqual(2, result.Count());
            var result1 = result.FirstOrDefault(r => r.UserFieldCode == "TEST1");
            Assert.NotNull(result1);
            Assert.AreEqual("Y", result1.Value);
            Assert.AreEqual(100001, result1.AccountNumber);

            var result2 = result.FirstOrDefault(r => r.UserFieldCode == "TEST2");
            Assert.NotNull(result2);
            Assert.AreEqual("N", result2.Value);
            Assert.AreEqual(100002, result2.AccountNumber);
        }

        [Test]
        public void InsertAccountUserFieldsAsync_AccountNull_NullExceptionThrown()
        {
            var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
            {
                new AccountUserFieldRequest()
                {
                   AccountNumber = 100001,
                   UserFieldCode = "TEST1",
                   Value = "Y"

                },
                new AccountUserFieldRequest()
                {
                    AccountNumber = 100002,
                   UserFieldCode = "TEST2",
                   Value = "N"
                }
            };
            Account testAccount = null;
            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);

            Assert.ThrowsAsync<NullReferenceException>(async () =>
                 await _accountUserFieldService.InsertAccountUserFieldsAsync(accountUserFieldUpdateRequests));
        }

        [Test]
        public async Task InsertAccountUserFieldsAsync_ListofInsertedUserfields()
        {

            var testAccount = new Account()
            {
                Id = "TEST-adsfasdfas[]djfas"
            };
            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);

            var messageHeader = new CoreMessageHeader() { };
            var accountUserFieldRequest1 = new AccountUserFieldRequest()
            {
                AccountNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            var coreApiMessage = new CoreApiMessage<AccountUserFieldRequest>(messageHeader, accountUserFieldRequest1);
            var createdAccountUserField1 = new AccountUserField()
            {
                AccountNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            _mockAccountUserFieldDao.Setup(x => x.InsertAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
                                                                testAccount.Id)).ReturnsAsync(createdAccountUserField1);          

            var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
            {
                accountUserFieldRequest1
            };
            var result = await _accountUserFieldService.InsertAccountUserFieldsAsync(accountUserFieldUpdateRequests);

            Assert.NotNull(result);
            Assert.AreEqual(1, result.Count());
            var result1 = result.FirstOrDefault(r => r.UserFieldCode == "TEST1");
            Assert.NotNull(result1);
            Assert.AreEqual("Y", result1.Value);
            Assert.AreEqual(100001, result1.AccountNumber);
        }
    }
}