using System;
using System.Collections.Generic;
using NUnit.Framework;
using AutoMapper;
using Moq;
using System.Threading.Tasks;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
using LCU.Api.Internal.CoreApiWrapper.Mappers;
using LCU.Api.Internal.CoreApiWrapper.Services;
using LCU.Library.Internal.CoreApiWrapperModel.Constants;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.PostalAddresses;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.EmailAddress;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Phones;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;

namespace LCU.Api.Internal.CoreApiWrapperTest.Service
{
    public class IndividualServiceTest
    {
        private readonly IndividualService _individualService;        
        private readonly IMapper _mapper;
        private readonly Mock<IPersonService> _mockPersonService;
        private readonly Mock<IAgreePersonService> _mockAgreePersonService;

        public IndividualServiceTest()
        {
            if (_mapper == null)
            {
                var mappingConfig = new MapperConfiguration(mc =>
                {
                    mc.AddProfile(new IndividualMapper());
                    mc.AddProfile(new AddressMapper());
                    mc.AddProfile(new PhoneMapper());
                });
                IMapper mapper = mappingConfig.CreateMapper();
                _mapper = mapper;
            }
            _mockPersonService = new Mock<IPersonService>();
            _mockAgreePersonService = new Mock<IAgreePersonService>();

            _individualService = new IndividualService(_mapper, 
                                                       _mockPersonService.Object,
                                                       _mockAgreePersonService.Object);
        }

        [Test]
        public async Task GetIndividual_Returns_FilledOutIndividual()
        {
            var agreePerson = new AgreePerson() 
            { 
               AgreeNumber = 100,
               PersonNumber = 10,
               UserId = "1"
            };
            _mockAgreePersonService.Setup(x => x.GetByUserId(It.IsAny<string>())).ReturnsAsync(agreePerson);

            var testPostalAddress = new PostalAddress()
            {
                AddressUseCode = AddressConstants.PrimaryUseCode,
                AddressNumber = 11
            };
            var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };

            var email1 = new Email()
            {
                EmailAddress = "TestEmail1@test.com"
            };
            var email2 = new Email()
            {
                EmailAddress = "TestEmail2@test.com"
            };
            var testEmailAddressList = new List<Email>() { email1, email2 }; 

            var phone1 = new Phone()
            {
                IsPreferred = true,
                AreaCode = "262",
                Exchange = "789",
                PhoneNumber = "3321"
            };
            var phone2 = new Phone()
            {
                IsPreferred = false,
                AreaCode = "626",
                Exchange = "987",
                PhoneNumber = "1123"
            };
            var testPhoneList = new List<Phone>() { phone1, phone2 };
            
            var testPersonResult = new Person()
            {
                PersonNumber = 10,
                FirstName = "Tester",
                MiddleName = "Person",
                MiddleInitial = "P",
                LastName = "Guy",
                Suffix = "Jr",
                TaxId = "1231232132",
                BirthDate = "1/1/2021",
                PostalAddressList = testPostalAddressList,
                IsEmployee = true,
                EmailAddressList = testEmailAddressList,
                Phones = testPhoneList
            };
            var testPersonsResult = new List<Person>();
            testPersonsResult.Add(testPersonResult);
            _mockPersonService.Setup(x => x.GetPersonsBySearch(It.IsAny<CoreRequestParameters>(), 
                                                               It.IsAny<PersonSearchRequest>())).ReturnsAsync(testPersonsResult);

            var result = await _individualService.GetIndividualByUserId("1111");

            Assert.NotNull(result);
            Assert.AreEqual(10, result.IndividualId);
            Assert.AreEqual("Tester", result.FirstName);
            Assert.AreEqual("P", result.MiddleName);
            Assert.AreEqual("Guy", result.LastName);
            Assert.AreEqual("Jr", result.NameSuffix);
            Assert.AreEqual("1231232132", result.TaxId);
            Assert.AreEqual(Convert.ToDateTime("1/1/2021"), result.BirthDate);
            Assert.AreEqual(11, result.PrimaryAddressId);
            Assert.IsTrue(result.IsEmployee);
            Assert.AreEqual(1, result.Address.Count);
            Assert.AreEqual("TestEmail1@test.com", result.Email1);
            Assert.AreEqual(2, result.Phone.Count);
        }

        [Test]
        public void GetPersonsByMemberAgreementNbr_Exception_InGetByUserId()
        {         
            _mockAgreePersonService.Setup(x => x.GetByUserId(It.IsAny<string>())).Throws(new Exception());            
            var testId = "1";
            Assert.ThrowsAsync<Exception>(() => _individualService.GetIndividualByUserId(testId));
        }

        [Test]
        public void GetPersonsByMemberAgreementNbr_Exception_InGetPersonBySearch()
        {
            var agreePerson = new AgreePerson()
            {
                AgreeNumber = 100,
                PersonNumber = 10,
                UserId = "1"
            };
            _mockAgreePersonService.Setup(x => x.GetByUserId(It.IsAny<string>())).ReturnsAsync(agreePerson);            
            _mockPersonService.Setup(x => x.GetPersonsBySearch(It.IsAny<CoreRequestParameters>(),
                                                               It.IsAny<PersonSearchRequest>())).Throws(new Exception());

            var testId = "1";
            Assert.ThrowsAsync<Exception>(() => _individualService.GetIndividualByUserId(testId));
        }
    }
}