using System;
using System.Linq;
using System.Collections.Generic;
using System.Threading.Tasks;
using NUnit.Framework;
using AutoMapper;
using Moq;
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.Enums;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.PostalAddresses;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Identifications;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Phones;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Organizations;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Mixed;

namespace LCU.Api.Internal.CoreApiWrapperTest.Service
{
    public class MemberServiceTest
    {
        private readonly MemberService _memberService;
        private readonly IMapper _mapper;
        private readonly Mock<IPersonService> _mockPersonService;
        private readonly Mock<IAccountService>  _mockAccountService;
        private readonly Mock<IOrganizationService> _mockOrganizationService;

        public MemberServiceTest()
        {
            if (_mapper == null)
            {
                var mappingConfig = new MapperConfiguration(mc =>
                {
                    mc.AddProfile(new MemberOwnerMapper());
                    mc.AddProfile(new MemberMapper());
                    mc.AddProfile(new AddressMapper());
                });
                IMapper mapper = mappingConfig.CreateMapper();
                _mapper = mapper;
            }
            _mockPersonService = new Mock<IPersonService>();
            _mockAccountService = new Mock<IAccountService>();
            _mockOrganizationService = new Mock<IOrganizationService>();

            _memberService = new MemberService(_mapper,
                                               _mockPersonService.Object,
                                               _mockAccountService.Object,
                                               _mockOrganizationService.Object);
        }

        [Test]
        public async Task GetMember_Returns_FilledOutMember()
        {
            var testPostalAddress = new PostalAddress()
            {
                AddressUseCode = AddressConstants.PrimaryUseCode,
                AddressNumber = 11,
                AddressLine1 = "Test Street",
                AddressLine2 = "",
                AddressLine3 = "",
                CityName = "City Test",
                PostalCode = "53183",
                ZipPlus = "3123",
                CountrySubdivisionCode = "WI"
            };
            var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };

            var testId = 100;
            var testPersonResult = new Person()
            {
                PersonNumber = 1,
                FirstName = "Tester",
                MiddleName = "Person",
                LastName = "Guy",
                NameFull = "Tester Person Guy",
                Suffix = "",
                TaxId = "1231232132",
                BirthDate = "1/1/2021",
                MemberNumber = 111111111,
                PostalAddressList = testPostalAddressList
            };

            _mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
                                                                           It.IsAny<MemberNbrRequest>())).ReturnsAsync(testPersonResult);

            var result = await _memberService.GetMemberDetails(testId);

            Assert.NotNull(result); 
            Assert.AreEqual("Tester Person Guy", result.MemberName);
            Assert.AreEqual(111111111, result.MemberId);
            Assert.AreEqual("Test Street", result.Address.Line1);
            Assert.AreEqual("WI", result.Address.State);
            _mockOrganizationService.Verify(x => x.GetMemberByMemberAgreeNbr(111111111), Times.Never());
        }

        [Test]
        public void GetMemberDetails_Return_Exception()
        {
            var testId = 100;
            _mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
                                                            It.IsAny<MemberNbrRequest>())).Throws(new Exception());

            Assert.ThrowsAsync<Exception>(() => _memberService.GetMemberDetails(testId));
        }

        [Test]
        public async Task GetMemberByAccountNumber_Person_Returns_FilledOutMember()
        {
            var testAccountResult = new Account()
            {
                MemberAgreementNumber = 111111111,
                ReportingForPersonNumber = 1
            };
            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
                                                              It.IsAny<AcctNbrRequest>())).ReturnsAsync(testAccountResult);            

            var testPostalAddress = new PostalAddress()
            {
                AddressUseCode = AddressConstants.PrimaryUseCode,
                AddressNumber = 11,
                AddressLine1 = "Test Street",
                AddressLine2 = "",
                AddressLine3 = "",
                CityName = "City Test",
                PostalCode = "53183",
                ZipPlus = "3123",
                CountrySubdivisionCode = "WI"
            };
            var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };

            var testId = 100;
            var testPersonResult = new Person()
            {
                PersonNumber = 1,
                FirstName = "Tester",
                MiddleName = "Person",
                LastName = "Guy",
                NameFull = "Tester Person Guy",
                Suffix = "",
                TaxId = "1231232132",
                BirthDate = "1/1/2021",
                MemberNumber = 111111111,
                PostalAddressList = testPostalAddressList
            };

            _mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
                                                                           It.IsAny<MemberNbrRequest>())).ReturnsAsync(testPersonResult);

            var result = await _memberService.GetMemberByAccountNumber(testId);

            Assert.NotNull(result);
            Assert.AreEqual("Tester Person Guy", result.MemberName);
            Assert.AreEqual(111111111, result.MemberId);
            Assert.AreEqual("Test Street", result.Address.Line1);
            Assert.AreEqual("WI", result.Address.State);
        }

        [Test]
        public void GetMemberDetailsByAccountNumber_Return_Exception_OnGetAccountDetails()
        {
            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
                                                              It.IsAny<AcctNbrRequest>())).Throws(new Exception());
            var testId = 100;
            Assert.ThrowsAsync<Exception>(() => _memberService.GetMemberByAccountNumber(testId));
        }


        [Test]
        public void GetMemberDetailsByAccountNumber_Return_Exception_OnGetPersonsByMemberAgreementNbr()
        {
            var testAccountResult = new Account()
            {
                MemberAgreementNumber = 111111111
            };
            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
                                                              It.IsAny<AcctNbrRequest>())).ReturnsAsync(testAccountResult);
            var testId = 100;
            _mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
                                                            It.IsAny<MemberNbrRequest>())).Throws(new Exception());

            Assert.ThrowsAsync<Exception>(() => _memberService.GetMemberByAccountNumber(testId));
        }

        [Test]
        public async Task GetMemberOwner_Returns_FilledOutMemberOwner()
        {
            var testPostalAddress = new PostalAddress()
            {
                AddressUseCode = AddressConstants.PrimaryUseCode,
                AddressNumber = 11,
                AddressLine1 = "Test Street",
                AddressLine2 = "",
                AddressLine3 = "",
                CityName = "City Test",
                PostalCode = "53183",
                ZipPlus = "3123",
                CountrySubdivisionCode = "WI"
            };
            var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };

            var identification = new Identification()
            {
                TypeCode = ((int)IdentificationTypeEnum.UnexpiredDriversLicense).ToString(),
                CountryCode = AddressConstants.CountryUSA,
                StateCode = "WI",
                IdNumber = "A3243208fj213aupasdf"
            };
            var identificationList = new List<Identification>() { identification };


            var phone1 = new Phone()
            {
                IsPreferred = true,
                AreaCode = "262",
                Exchange = "789",
                PhoneNumber = "3321"
            };
            var testMemberAgreement = new MemberAgreement()
            {
                PrimaryPersonNumber = 1
            };

            var testId = 100;
            var testPersonResult = new Person()
            {
                PersonNumber = 1,
                FirstName = "Tester",
                MiddleName = "Person",
                LastName = "Guy",
                NameFull = "Tester Person Guy",
                Suffix = "",
                TaxId = "1231232132",
                BirthDate = "1/1/2021",
                PostalAddressList = testPostalAddressList,
                IsEmployee = true,
                MemberAgreement = testMemberAgreement,
                Identifications = identificationList
            };

            _mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
                                                                           It.IsAny<MemberNbrRequest>())).ReturnsAsync(testPersonResult);

            var results = await _memberService.GetMemberOwner(testId);

            Assert.NotNull(results);
            Assert.AreEqual(1, results.ToList().Count);
            var result = results.FirstOrDefault();

            Assert.AreEqual(1, result.IndividualId);
            Assert.AreEqual("Tester Person Guy", result.Name);
            Assert.AreEqual("1231232132", result.TaxId);
            Assert.AreEqual("1/1/2021", result.BirthDate);
            Assert.AreEqual("Primary", result.Type);
            Assert.AreEqual("Test Street, City Test, WI 53183-3123", result.Address);
            Assert.AreEqual("WI A3243208fj213aupasdf", result.DriverLicense);
        }

        [Test]
        public void GetMemberOwner_Return_Exception()
        {
            var testId = 100;
            _mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
                                                            It.IsAny<MemberNbrRequest>())).Throws(new Exception());

            Assert.ThrowsAsync<Exception>(() => _memberService.GetMemberOwner(testId));
        }

        [Test]
        public async Task GetMemberByAccountNumber_Organization_Returns_FilledOutMember()
        {
            // Arrange
            var testAccountResult = new Account()
            {
                MemberAgreementNumber = 111111111,
                ReportingForOrganizationNumber = 1
            };
            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
                                                              It.IsAny<AcctNbrRequest>())).ReturnsAsync(testAccountResult);

            var testPostalAddress = new PostalAddress()
            {
                AddressUseCode = AddressConstants.PrimaryUseCode,
                AddressNumber = 11,
                AddressLine1 = "Test Street",
                AddressLine2 = "",
                AddressLine3 = "",
                CityName = "City Test",
                PostalCode = "53183",
                ZipPlus = "3123",
                CountrySubdivisionCode = "WI"
            };
            var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };
            var testOrganization = new Organization
            {
                MemberAgreementNumber = 111111111,
                Name = "Test Organization Name",
                OrganizationNumber = 123,
                PostalAddressList = testPostalAddressList
            };

            _mockOrganizationService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(testOrganization);

            // Act
            var result = await _memberService.GetMemberByAccountNumber(1);

            // ASsert
            Assert.IsNotNull(result);
            Assert.AreEqual(result.MemberId, 111111111);
            Assert.AreEqual(result.MemberName, "Test Organization Name");
            Assert.AreEqual(result.PrimaryIndividualId, 123);
            Assert.AreEqual("Test Street", result.Address.Line1);
            Assert.AreEqual("WI", result.Address.State);
            _mockPersonService.Verify(x => x.GetPersonsByMemberAgreementNbr(new CoreRequestParameters(), new MemberNbrRequest()), Times.Never());
        }

        [Test]
        public async Task GetPersonOrOrganizationNumberByMemberId_PersonFound()
        {
            // Arrange
            _mockOrganizationService.Invocations.Clear();

            long personMemberNumber = 123;
            var personName = "John E Jacob Jr";

            var person = new Person()
            {
                PersonNumber = (int)personMemberNumber,
                FirstMiddleInitialLastSuffix = personName
            };

            _mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(person).Verifiable();

            // Act
            var result = await _memberService.GetPersonOrOrganizationNumberByMemberId(personMemberNumber);

            // Assert
            Assert.IsNotNull(result);
            Assert.AreEqual(result.PersonNumber, personMemberNumber.ToString());
            Assert.AreEqual(result.EntityName, personName);
            Assert.IsNull(result.OrganizationNumber);
            _mockOrganizationService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Never);
        }

        [Test]
        public async Task GetPersonOrOrganizationNumberByMemberId_OrganizationFound()
        {
            // Arrange
            _mockPersonService.Invocations.Clear();
            _mockOrganizationService.Invocations.Clear();

            long organizationMemberNumber = 123;
            var organizationName = "John E Consulting LLC";

            var organization = new Organization()
            {
                OrganizationNumber = organizationMemberNumber,
                Name = organizationName
            };

            _mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ThrowsAsync(new Exception());
            _mockOrganizationService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(organization).Verifiable();

            // Act
            var result = await _memberService.GetPersonOrOrganizationNumberByMemberId(organizationMemberNumber);

            // Assert
            Assert.IsNotNull(result);
            Assert.AreEqual(result.OrganizationNumber, organizationMemberNumber.ToString());
            Assert.AreEqual(result.EntityName, organizationName);
            Assert.IsNull(result.PersonNumber);
            _mockPersonService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Once);
            _mockOrganizationService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Once);
        }

        [Test]
        public void GetPersonOrOrganizationNumberByMemberId_NeitherFound_Exception()
        {
            // Arrange
            _mockPersonService.Invocations.Clear();
            _mockOrganizationService.Invocations.Clear();

            var person = new Person()
            {
                PersonNumber = 0
            };

            var organization = new Organization()
            {
                OrganizationNumber = 0
            };

            _mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(person).Verifiable();
            _mockOrganizationService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(organization).Verifiable();

            // Act

            // Assert
            Assert.ThrowsAsync<ArgumentNullException>(async () => await _memberService.GetPersonOrOrganizationNumberByMemberId(0));
            _mockPersonService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Once);
            _mockOrganizationService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Once);
        }
    }
}