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.CoreRequests;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
using LCU.Library.Internal.Exceptions;

namespace LCU.Api.Internal.CoreApiWrapperTest.Service
{
    public class PersonUserFieldServiceTest
    {
        private readonly PersonUserFieldService _personUserFieldService;
        private readonly Mock<IPersonService> _mockPersonService;
        private readonly Mock<IPersonUserFieldDao> _mockPersonUserFieldDao;

        public PersonUserFieldServiceTest()
        {
            _mockPersonService = new Mock<IPersonService>();
            _mockPersonUserFieldDao = new Mock<IPersonUserFieldDao>();
            _personUserFieldService = new PersonUserFieldService(_mockPersonService.Object, _mockPersonUserFieldDao.Object);
        }

        [Test]
        public void GetPersonUserFieldCoreApiResponseAsync_ExceptionThrown()
        {
            _mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(), It.IsAny<int>())).Throws(new ServiceException("Nope"));

            Assert.ThrowsAsync<ServiceException>(async () =>
                await _personUserFieldService.GetPersonUserFieldCoreApiResponseAsync(00000000));
        }

        [Test]
        public async Task GetPersonUserFieldCoreApiResponseAsync_UserFieldsReturned()
        {
            var personUserFields = new List<PersonUserField>()
            {
                new PersonUserField()
                {
                   PersonNumber = 100001,
                   UserFieldCode = "TEST1",
                   Value = "Y"

                },
                new PersonUserField()
                {
                   PersonNumber = 200001,
                   UserFieldCode = "TEST2",
                   Value = "N"
                }
            };
            var coreMessageheader = new CoreMessageHeader();
            var personUserFieldCoreApiResponse = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageheader, personUserFields);
            _mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(), It.IsAny<int>())).ReturnsAsync(personUserFieldCoreApiResponse);


            var result = await _personUserFieldService.GetPersonUserFieldCoreApiResponseAsync(100001);
            Assert.NotNull(result);
            Assert.AreEqual(2, result.MessageBody.Count());
        }

        [Test]
        public void UpdatePersonUserFieldAsync_ExceptionThrown()
        {
            _mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(), It.IsAny<int>(), It.IsAny<string>())).Throws(new ServiceException("Nope"));

            var personUserUpdateRequest = new PersonUserFieldRequest()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            Assert.ThrowsAsync<ServiceException>(async () =>
                await _personUserFieldService.UpdatePersonUserFieldAsync(personUserUpdateRequest));
        }

        [Test]
        public async Task UpdatePersonUserFieldAsync_UpdatedUserFieldsReturned()
        {
            var testPerson = new Person()
            {
                PersonNumber = 100001
            };

            var updatedPersonUserField = new PersonUserField()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y",
                LastMaintained = Convert.ToDateTime("9/1/2001")
            };

            var listexistingPersonUserField = new List<PersonUserField>()
            {
                new PersonUserField()
                {
                    PersonNumber = 100001,
                    Id = updatedPersonUserField.Id,
                    UserFieldCode = "TEST1",
                    Value = "N",
                    LastMaintained = Convert.ToDateTime("8/1/2001")
                }
            };
            var coreMessageheader = new CoreMessageHeader();
            var coreApiResponse = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageheader, listexistingPersonUserField);
            
            _mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(),It.IsAny<int>())).ReturnsAsync(coreApiResponse);

            _mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
                                                                It.IsAny<int>(),
                                                                It.IsAny<string>())).ReturnsAsync(updatedPersonUserField);

            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(new List<Person>() { testPerson });

            var personUserUpdateRequest = new PersonUserFieldRequest()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            var result = await _personUserFieldService.UpdatePersonUserFieldAsync(personUserUpdateRequest);
            Assert.NotNull(result);
            Assert.AreEqual(updatedPersonUserField, result);
        }

        [Test]
        public void InsertPersonUserFieldAsync_ExceptionThrown()
        {
            _mockPersonUserFieldDao.Setup(x => x.InsertPersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(), It.IsAny<int>())).Throws(new ServiceException("Oops"));

            var personUserUpdateRequest = new PersonUserFieldRequest()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            Assert.ThrowsAsync<ServiceException>(async () =>
                await _personUserFieldService.InsertPersonUserFieldAsync(personUserUpdateRequest));
        }

        [Test]
        public async Task InsertPersonUserFieldAsync_InsertUserFieldsReturned()
        {
            var person = new Person()
            {
                Id = "TEST-adsfasdfas[]djfas"
            };

            var personList = new List<Person> { person };

            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);

            var createdPersonUserField = new PersonUserField()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y",
                LastMaintained = Convert.ToDateTime("9/1/2001")
            };
            _mockPersonUserFieldDao.Setup(x => x.InsertPersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
                                                                It.IsAny<int>())).ReturnsAsync(createdPersonUserField);

            var personUserUpdateRequest = new PersonUserFieldRequest()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            var result = await _personUserFieldService.InsertPersonUserFieldAsync(personUserUpdateRequest);
            Assert.NotNull(result);
            Assert.AreEqual(createdPersonUserField, result);
        }

        [Test]
        public void UpdatePersonUserFieldsAsync_NullPerson_ExceptionThrown()
        {
            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"

            };

            var personList = new List<Person>();
            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);

            Assert.ThrowsAsync<ServiceException>(async () =>
                 await _personUserFieldService.UpdatePersonUserFieldAsync(personUserFieldUpdateRequest));
        }

        [Test]
        public void UpdatePersonUserFieldsAsync_ExistingUserFieldNull_NullExceptionThrown()
        {
            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"

            };

            var person = new Person()
            {
                Id = "TEST-adsfasdfas[]djfas"
            };

            var personList = new List<Person> { person };

            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);

            IEnumerable<PersonUserField> PersonUserFields = new List<PersonUserField>();
            CoreMessageHeader coreMessageHeader = new CoreMessageHeader();
            CoreApiMessage<IEnumerable<PersonUserField>> coreApiMessagePersonUserFields = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageHeader, PersonUserFields);
            _mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(),
                                                       It.IsAny<int>())).ReturnsAsync(coreApiMessagePersonUserFields);

            Assert.ThrowsAsync<ServiceException>(async () =>
                 await _personUserFieldService.UpdatePersonUserFieldAsync(personUserFieldUpdateRequest));
        }

        [Test]
        public void UpdatePersonUserFieldsAsync_UpdateUserFieldNull_NullExceptionThrown()
        {
            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"

            };

            var personList = new List<Person>();

            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);

            IEnumerable<PersonUserField> PersonUserFields = new List<PersonUserField>()
            {
                new PersonUserField()
                {
                    Id = "TEST1",
                    PersonNumber = 100001,
                    UserFieldCode = "TEST1",
                    Value = "N"
                },
                new PersonUserField()
                {
                    Id = "TEST2",
                    PersonNumber = 100002,
                    UserFieldCode = "TEST2",
                    Value = "Y"
                }
            };
            CoreMessageHeader coreMessageHeader = new CoreMessageHeader(1122000321);
            CoreApiMessage<IEnumerable<PersonUserField>> coreApiMessagePersonUserFields = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageHeader, PersonUserFields);
            _mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(),
                                                       It.IsAny<int>())).ReturnsAsync(coreApiMessagePersonUserFields);

            PersonUserField updatedPersonUserField = null;
            _mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
                                                                It.IsAny<int>(),
                                                                It.IsAny<string>())).ReturnsAsync(updatedPersonUserField);

            Assert.ThrowsAsync<ServiceException>(async () =>
                 await _personUserFieldService.UpdatePersonUserFieldAsync(personUserFieldUpdateRequest));
        }

        [Test]
        public async Task UpdatePersonUserFieldsAsync_UpdatedUserField()
        {
            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"

            };

            var person = new Person()
            {
                Id = "TEST-adsfasdfas[]djfas"
            };

            var personList = new List<Person> { person };

            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);


            var personUserField1 = new PersonUserField()
            {
                Id = "TEST1",
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "N"
            };
            var personUserField2 = new PersonUserField()
            {
                Id = "TEST2",
                PersonNumber = 100002,
                UserFieldCode = "TEST2",
                Value = "Y"
            };

            IEnumerable<PersonUserField> personUserFields = new List<PersonUserField>()
            {
                personUserField1,
                personUserField2
            };
            CoreMessageHeader coreMessageHeader = new CoreMessageHeader(1122000321);
            CoreApiMessage<IEnumerable<PersonUserField>> coreApiMessagePersonUserFields = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageHeader, personUserFields);
            _mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(),
                                                       It.IsAny<int>())).ReturnsAsync(coreApiMessagePersonUserFields);

            PersonUserField updatedPersonUserField1 = new PersonUserField()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            _mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
                                                                It.IsAny<int>(),
                                                                personUserField1.Id)).ReturnsAsync(updatedPersonUserField1);

            PersonUserField updatedPersonUserField2 = new PersonUserField()
            {
                PersonNumber = 100002,
                UserFieldCode = "TEST2",
                Value = "N"
            };
            _mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
                                                                It.IsAny<int>(),
                                                                personUserField2.Id)).ReturnsAsync(updatedPersonUserField2);

            var result = await _personUserFieldService.UpdatePersonUserFieldAsync(personUserFieldUpdateRequest);

            Assert.NotNull(result);
            Assert.AreEqual("Y", result.Value);
            Assert.AreEqual(100001, result.PersonNumber);
        }

        [Test]
        public void InsertPersonUserFieldsAsync_NullPerson_ExceptionThrown()
        {
            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };

            var personList = new List<Person>();

            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);

            Assert.ThrowsAsync<ServiceException>(async () =>
                 await _personUserFieldService.InsertPersonUserFieldAsync(personUserFieldUpdateRequest));
        }

        [Test]
        public async Task InsertPersonUserFieldsAsync_InsertedUserField()
        {

            var person = new Person()
            {
                Id = "TEST-adsfasdfas[]djfas"
            };

            var personList = new List<Person> { person };

            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);

            var messageHeader = new CoreMessageHeader() { };
            var personUserFieldRequest = new PersonUserFieldRequest()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            var coreApiMessage = new CoreApiMessage<PersonUserFieldRequest>(messageHeader, personUserFieldRequest);
            var createdPersonUserField1 = new PersonUserField()
            {
                PersonNumber = 100001,
                UserFieldCode = "TEST1",
                Value = "Y"
            };
            _mockPersonUserFieldDao.Setup(x => x.InsertPersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
                                                                personUserFieldRequest.PersonNumber)).ReturnsAsync(createdPersonUserField1);


            var result = await _personUserFieldService.InsertPersonUserFieldAsync(personUserFieldRequest);

            Assert.NotNull(result);
            Assert.AreEqual("Y", result.Value);
            Assert.AreEqual(100001, result.PersonNumber);
        }
    }
}