using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LCU.API.Internal.DocumentIngestor.Services.AttributeDeterminingServices;
using LCU.API.Internal.DocumentIngestor.Services.MicroApiServices;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Agreements;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Mixed;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Tax;
using LCU.Library.Internal.DocumentIngestorModels.Entities;
using LCU.Library.Internal.DocumentIngestorModels.Enums;
using LCU.Library.Internal.Exceptions;
using Moq;
using NUnit.Framework;

namespace LCU.API.Internal.DocumentIngestorTests.Services.AttributeDeterminingServices;

public class PrimaryOwnerDeterminingServiceTest
{
	private PrimaryOwnerDeterminingService _primaryOwnerDeterminingService;
	private Mock<ICoreApiWrapperService> _mockCoreApiWrapperService;

	[SetUp]
	public void Setup()
	{
		_mockCoreApiWrapperService = new Mock<ICoreApiWrapperService>();
		_primaryOwnerDeterminingService = new PrimaryOwnerDeterminingService(_mockCoreApiWrapperService.Object);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_PersonNumberFound_Success()
	{
		var taxId = "123245";
		var fullName = "Tester Unit";
		var accountNumber = "9999";
		var personsTaxIdData = new List<PersonTaxIdDataResponse>
		{
			new()
			{
				PersonNumber = 1,
				NameLastFirstMiddleSuffix = fullName,
			}
		};
		_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, null);
		var resultPayload = result.Payload;
		Assert.True(result.Success);
		Assert.AreEqual("1", resultPayload.PersonNumber);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_PersonNumberNotFound_OrganizationFound_Success()
	{
		var taxId = "123245";
		var fullName = "Tester UnitOrg";
		var accountNumber = "9999";
		var personsTaxIdData = new List<PersonTaxIdDataResponse>();
		_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);

		var organizationTaxIdData = new List<OrganizationTaxIdDataResponse>
		{
			new()
			{
				OrganizationNumber = 2,
				Name = fullName
			}
		};
		_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(organizationTaxIdData);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, null);
		var resultPayload = result.Payload;
		Assert.True(result.Success);
		Assert.AreEqual("2", resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_PersonNumberNotFound_OrganizationNotFound_Failure()
	{
		var taxId = "123245";
		var fullName = "Tester UnitOrg";
		var accountNumber = "9999";
		var personsTaxIdData = new List<PersonTaxIdDataResponse>();
		_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);

		var organizationTaxIdData = new List<OrganizationTaxIdDataResponse>();
		_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(organizationTaxIdData);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, null);
		var resultPayload = result.Payload;
		Assert.IsFalse(result.Success);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_PersonNumberNotFound_FullNameNoMatch_Failure()
	{
		var taxId = "123245";
		var fullName = "Tester Unit";
		var accountNumber = "9999";
		var personsTaxIdData = new List<PersonTaxIdDataResponse>
		{
			new()
			{
				PersonNumber = 1,
				NameLastFirstMiddleSuffix = "Tester Unit Nope",
			}
		};
		_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);

		var organizationTaxIdData = new List<OrganizationTaxIdDataResponse>();
		_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(organizationTaxIdData);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, null);
		var resultPayload = result.Payload;
		Assert.IsFalse(result.Success);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_PersonNumberNotFound_FullNameNoMatch_MessageContainsPersonTaxData()
	{
		const string taxId = nameof(taxId);
		var personNumbers = new Random(DateTime.Now.Millisecond);
		var personsTaxIdData = Enumerable.Repeat
			(
				() => new PersonTaxIdDataResponse
				{
					PersonNumber = personNumbers.Next(),
					NameLastFirstMiddleSuffix = Guid.NewGuid().ToString(),
					FirstName = Guid.NewGuid().ToString(),
					MiddleName = Guid.NewGuid().ToString(),
					LastName = Guid.NewGuid().ToString()
				},
				5
			)
			.Select(f => f())
			.ToArray();
		_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);
		_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(Enumerable.Empty<OrganizationTaxIdDataResponse>());

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), taxId, null!);

		var message = result.Message;
		Assert.IsNotNull(message);
		var personMessages = message!.Split("Person Detail:");
		foreach (var person in personsTaxIdData)
		{
			var personsMessages = personMessages
				.Where(o => o.Contains(person.PersonNumber.ToString()))
				.ToArray();
			Assert.AreEqual(1, personsMessages.Length);
			var personMessage = personsMessages.Single();
			StringAssert.Contains(person.FirstName, personMessage);
			StringAssert.Contains(person.MiddleName, personMessage);
			StringAssert.Contains(person.LastName, personMessage);
			if (Array.IndexOf(personMessages, personMessage) != personMessages.Length - 1)
			{
				StringAssert.EndsWith(" ", personMessage);
			}
		}
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_OrganizationNotFound_FullNameNoMatch_Failure()
	{
		var taxId = "123245";
		var fullName = "Tester UnitOrg";
		var accountNumber = "9999";
		var personsTaxIdData = new List<PersonTaxIdDataResponse>();
		_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);

		var organizationTaxIdData = new List<OrganizationTaxIdDataResponse>
		{
			new()
			{
				OrganizationNumber = 2,
				Name = "Tester UnitOrg Nope"
			}
		};
		_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(organizationTaxIdData);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, null);
		var resultPayload = result.Payload;
		Assert.IsFalse(result.Success);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_OrganizationNotFound_FullNameNoMatch_MessageContainsOrganziationTaxData()
	{
		const string taxId = nameof(taxId);
		var organizationNumbers = new Random(DateTime.Now.Millisecond);
		var organizationTaxIdData = Enumerable.Repeat
			(
				() => new OrganizationTaxIdDataResponse
				{
					OrganizationNumber = organizationNumbers.Next(),
					Name = Guid.NewGuid().ToString()
				},
				5
			)
			.Select(f => f())
			.ToArray();
		_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(Enumerable.Empty<PersonTaxIdDataResponse>());
		_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(organizationTaxIdData);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), taxId, null!);

		var message = result.Message;
		Assert.IsNotNull(message);
		var organizationMessages = message!.Split("Organization Detail:");
		foreach (var organization in organizationTaxIdData)
		{
			var organizationsMessages = organizationMessages
				.Where(o => o.Contains(organization.Name))
				.ToArray();
			Assert.AreEqual(1, organizationsMessages.Length);
			var organizationMessage = organizationsMessages.Single();
			StringAssert.Contains(organization.OrganizationNumber.ToString(), organizationMessage);
			if (Array.IndexOf(organizationMessages, organizationMessage) != organizationMessages.Length - 1)
			{
				StringAssert.EndsWith(" ", organizationMessage);
			}
		}
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_PersonFound_Success()
	{
		var fullName = "Bill B Billson";
		var accountNumber = "9999";
		var creationDate = new DateTime(2022, 01, 01);
		var accountOwnership = new List<AccountOwnership>
		{
			new()
			{
				PersonNumber = 1,
				FirstName = "Bill",
				MiddleInitial = "B",
				LastName = "Billson",
				IsPrimaryOwner = true
			}
		};
		_mockCoreApiWrapperService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, creationDate.ToShortDateString())).ReturnsAsync(accountOwnership);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, creationDate, null);
		var resultPayload = result.Payload;
		Assert.True(result.Success);
		Assert.AreEqual("1", resultPayload.PersonNumber);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByPersonName(It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByOrganizationName(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_PersonNumberNotFound_OrganizationNumberFound_Success()
	{
		var orgName = "The Big Company";
		var accountNumber = "9999";
		var creationDate = new DateTime(2022, 01, 01);

		var accountOwnership = new List<AccountOwnership>
		{
			new()
			{
				ByOrgNbr = 2,
				OrganizationName = orgName,
				IsPrimaryOwner = true
			}
		};
		_mockCoreApiWrapperService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, creationDate.ToShortDateString())).ReturnsAsync(accountOwnership);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(orgName, accountNumber, creationDate, null);
		var resultPayload = result.Payload;
		Assert.True(result.Success);
		Assert.AreEqual("2", resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
	}


	[Test]
	public async Task DeterminePrimaryOwnerAttribute_EntityNameDoesNotMatch_Failure()
	{
		var fullName = "Bill B Billson";
		var accountNumber = "9999";
		var creationDate = new DateTime(2022, 01, 01);

		var accountOwnership = new List<AccountOwnership>
		{
			new()
			{
				ByOrgNbr = 2,
				FirstName = "Pete",
				MiddleInitial = "P",
				LastName = "Peterson",
				IsPrimaryOwner = true
			}
		};
		_mockCoreApiWrapperService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, creationDate.ToShortDateString())).ReturnsAsync(accountOwnership);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, creationDate, null);
		var resultPayload = result.Payload;
		Assert.IsFalse(result.Success);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_PersonNumberNotFound_OrganizationNumberNotFound_Failure()
	{
		var fullName = "Bill B Billson";
		var accountNumber = "9999";
		var creationDate = new DateTime(2022, 01, 01);
		var accountOwnership = new List<AccountOwnership>();
		_mockCoreApiWrapperService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, creationDate.ToShortDateString())).ReturnsAsync(accountOwnership);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, creationDate, null);
		var resultPayload = result.Payload;
		Assert.IsFalse(result.Success);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_TooManyOwners_Failure()
	{
		var fullName = "Bill B Billson";
		var accountNumber = Guid.NewGuid().ToString();
		var creationDate = new DateTime(2022, 01, 01);
		var accountOwnership = new List<AccountOwnership>
		{
			new()
			{
				PersonNumber = 2,
				FirstName = "Bill",
				MiddleInitial = "B",
				LastName = "Billson",
				IsPrimaryOwner = true
			},
			new()
			{
				PersonNumber = 5,
				FirstName = "Bill",
				MiddleInitial = "B",
				LastName = "Billson",
				IsPrimaryOwner = true
			}
		};
		_mockCoreApiWrapperService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, creationDate.ToShortDateString())).ReturnsAsync(accountOwnership);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, creationDate, null);
		var resultPayload = result.Payload;
		Assert.IsFalse(result.Success);
		Assert.IsNull(result.EntityIsUnknown);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.IsNotNull(resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByPersonName(It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByOrganizationName(It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_NoPrimaryOwner_Failure()
	{
		var fullName = "Bill B Billson";
		var creationDate = new DateTime(2022, 01, 01);
		var accountNumber = "5";
		var accountOwnership = new List<AccountOwnership>
		{
			new()
			{
				PersonNumber = 2,
				FirstName = "Bill",
				MiddleInitial = "B",
				LastName = "Billson",
				IsPrimaryOwner = false
			}
		};
		_mockCoreApiWrapperService.Setup(x => x.GetOwnersByPersonName(fullName)).ReturnsAsync(accountOwnership);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, creationDate, null);
		var resultPayload = result.Payload;
		Assert.IsFalse(result.Success);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByPersonName(It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByOrganizationName(It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_OwnerOverridePerson_Success()
	{
		var taxId = "123245";
		var fullName = "Tester Unit";
		var accountNumber = "9999";
		var documentProcessingInfoId = 123;
		var personsTaxIdData = new List<PersonTaxIdDataResponse>
		{
			new()
			{
				PersonNumber = 1,
				NameLastFirstMiddleSuffix = fullName,
			}
		};
		var ownerOverride = new OwnerOverrideInfo()
		{
			DocumentProcessingInfoId = documentProcessingInfoId,
			UserName = "Test Tester",
			EntityId = "888888",
			EntityType = EntityTypes.Person
		};
		_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, ownerOverride);
		var resultPayload = result.Payload;
		Assert.True(result.Success);
		Assert.AreEqual("888888", resultPayload.PersonNumber);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_OwnerOverrideOrganization_Success()
	{
		var taxId = "123245";
		var fullName = "Tester Unit";
		var documentProcessingInfoId = 123;
		var accountNumber = "9999";
		var personsTaxIdData = new List<OrganizationTaxIdDataResponse>
		{
			new()
			{
				OrganizationNumber = 1,
				Name = fullName,
			}
		};
		var ownerOverride = new OwnerOverrideInfo()
		{
			DocumentProcessingInfoId = documentProcessingInfoId,
			UserName = "Test Tester",
			EntityId = "888888",
			EntityType = EntityTypes.Organization
		};
		_mockCoreApiWrapperService.Setup(x => x.GetOrganizationsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, ownerOverride);
		var resultPayload = result.Payload;
		Assert.True(result.Success);
		Assert.AreEqual("888888", resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttribute_OwnerOverrideUnknown_Success()
	{
		var taxId = "123245";
		var fullName = "Tester Unit";
		var accountNumber = "9999";
		var documentProcessingInfoId = 123;
		var personsTaxIdData = new List<PersonTaxIdDataResponse>
		{
			new()
			{
				PersonNumber = 1,
				NameLastFirstMiddleSuffix = fullName,
			}
		};
		var ownerOverride = new OwnerOverrideInfo()
		{
			DocumentProcessingInfoId = documentProcessingInfoId,
			UserName = "Test Tester",
			EntityId = "888888",
			EntityType = EntityTypes.Unknown
		};
		_mockCoreApiWrapperService.Setup(x => x.GetPersonsTaxIdData(taxId)).ReturnsAsync(personsTaxIdData);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttribute(fullName, accountNumber, taxId, ownerOverride);
		var resultPayload = result.Payload;
		Assert.True(result.Success);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.AreEqual(accountNumber, resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_PersonNumberFound_Success()
	{
		var memberNumberOrUserId = "M1234";
		var accountNumber = "9999";
		var docType = "LVI_LT_106_01";
		var creationDate = new DateTime(2022, 01, 01);

		var personOrganization = new PersonOrganization()
		{
			PersonNumber = "1",
			OrganizationNumber = null
		};

		_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId, accountNumber, docType, creationDate, null);
		var resultPayload = result.Payload;

		Assert.True(result.Success);
		Assert.AreEqual("1", resultPayload.PersonNumber);
		Assert.AreEqual(null, resultPayload.OrganizationNumber);
		Assert.AreEqual("9999", resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_OrganizationFound_Success()
	{
		var memberNumberOrUserId = "M1234";
		var accountNumber = "9999";
		var docType = "LVI_LT_106_01";
		var creationDate = new DateTime(2022, 01, 01);

		var personOrganization = new PersonOrganization()
		{
			PersonNumber = null,
			OrganizationNumber = "123"
		};

		_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId, accountNumber, docType, creationDate, null);
		var resultPayload = result.Payload;

		Assert.True(result.Success);
		Assert.AreEqual(null, resultPayload.PersonNumber);
		Assert.AreEqual("123", resultPayload.OrganizationNumber);
		Assert.AreEqual("9999", resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_AgreementFound_Success()
	{
		var memberNumberOrUserId = "1234";
		var accountNumber = "9999";
		var docType = "LVI_LT_106_01";
		var creationDate = new DateTime(2022, 01, 01);

		var agreement = new Agreement()
		{
			AgreementNumber = 123,
			ByOrgNbr = 0,
			FirstName = "Bill",
			MiddleInitial = "B",
			LastName = "Billson",
			PersonNumber = 1234
		};

		_mockCoreApiWrapperService.Setup(x => x.GetAgreementByUserId(It.IsAny<string>())).ReturnsAsync(agreement);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId, accountNumber, docType, creationDate, null);
		var resultPayload = result.Payload;

		Assert.True(result.Success);
		Assert.AreEqual("1234", resultPayload.PersonNumber);
		Assert.AreEqual(null, resultPayload.OrganizationNumber);
		Assert.AreEqual("9999", resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementAccountByAccountId(It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_AgreementMmStmxtFound_Success()
	{
		var memberNumberOrUserId = "1234";
		var accountNumber = "9999";
		var docType = "MM_STMXT";
		var creationDate = new DateTime(2022, 01, 01);

		var agreement = new Agreement()
		{
			AgreementNumber = 123,
			ByOrgNbr = 0,
			FirstName = "Bill",
			MiddleInitial = "B",
			LastName = "Billson",
			PersonNumber = 1234
		};

		var agreementAccount = new AgreementAccount()
		{
			AccountNumber = 9999,
			AccountDescription = "PREMIUM CHECKING",
			MajorAccountTypeCode = "CK",
			TaxReportForPersonNumber = 1234,
			TaxReportForOrgNumber = null,
			OvrDeliveryMethCD = "PRNT",
			AccountOwner = new AgreementAccountOwner
			{
				AccountNumber = 9999,
				AgreementNumber = 0,
				UserId = null,
				PersonNumber = 0
			}
		};

		var personOrganization = new PersonOrganization()
		{
			PersonNumber = "1234",
			OrganizationNumber = null
		};

		_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();
		_mockCoreApiWrapperService.Setup(x => x.GetAgreementAccountByAccountId(It.IsAny<string>())).ReturnsAsync(agreementAccount);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId, accountNumber, docType, creationDate, null);
		var resultPayload = result.Payload;

		Assert.True(result.Success);
		Assert.AreEqual("1234", resultPayload.PersonNumber);
		Assert.AreEqual(null, resultPayload.OrganizationNumber);
		Assert.AreEqual("9999", resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementAccountByAccountId(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_PersonNotFound_OrganizationNotFound_Failure()
	{
		var memberNumberOrUserId = "M1234";
		var accountNumber = "9999";
		var docType = "LVI_LT_106_01";
		var creationDate = new DateTime(2022, 01, 01);
		var accountOwnership = new List<AccountOwnership>
		{
			new()
			{
				PersonNumber = 1,
				FirstName = "Bill",
				MiddleInitial = "B",
				LastName = "Billson",
				IsPrimaryOwner = true
			}
		};

		var personOrganization = new PersonOrganization()
		{
			PersonNumber = null,
			OrganizationNumber = null
		};

		_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId, accountNumber, docType, creationDate, null);
		var resultPayload = result.Payload;

		Assert.IsFalse(result.Success);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_AgreementNotFound_Failure()
	{
		var memberNumberOrUserId = "1234";
		var accountNumber = "9999";
		var docType = "LVI_LT_106_01";
		var creationDate = new DateTime(2022, 01, 01);
		var accountOwnership = new List<AccountOwnership>
		{
			new()
			{
				PersonNumber = 1,
				FirstName = "Bill",
				MiddleInitial = "B",
				LastName = "Billson",
				IsPrimaryOwner = true
			}
		};

		_mockCoreApiWrapperService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, creationDate.ToShortDateString())).ReturnsAsync(accountOwnership);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId, accountNumber, docType, creationDate, null);
		var resultPayload = result.Payload;

		Assert.IsFalse(result.Success);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_PersonNumberDoesNotMatch_MM_STMXT_Failure()
	{

		var memberNumberOrUserId = "M1234";
		var accountNumber = "9999";
		var docType = "MM_STMXT";
		var creationDate = new DateTime(2022, 01, 01);
		var accountOwnership = new List<AccountOwnership>
		{
			new()
			{
				PersonNumber = 1,
				FirstName = "Bill",
				MiddleInitial = "B",
				LastName = "Billson",
				IsPrimaryOwner = true
			}
		};

		var personOrganization = new PersonOrganization()
		{
			PersonNumber = "2",
			OrganizationNumber = null
		};

		var agreementAccount = new AgreementAccount()
		{
			AccountNumber = 9999,
			AccountDescription = "PREMIUM CHECKING",
			MajorAccountTypeCode = "CK",
			TaxReportForPersonNumber = 5678,
			TaxReportForOrgNumber = null,
			OvrDeliveryMethCD = "PRNT",
			AccountOwner = new AgreementAccountOwner
			{
				AccountNumber = 9999,
				AgreementNumber = 0,
				UserId = null,
				PersonNumber = 0
			}
		};

		_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();
		_mockCoreApiWrapperService.Setup(x => x.GetAgreementAccountByAccountId(It.IsAny<string>())).ReturnsAsync(agreementAccount);

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
																												accountNumber,
																												docType,
																												creationDate,
																												null);

		Assert.IsFalse(result.Success);
		_mockCoreApiWrapperService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Success_Agreement()
	{
		var memberNumberOrUserId = Guid.NewGuid().ToString();
		var agreement = new Agreement()
		{
			UserId = memberNumberOrUserId,
			AgreementNumber = 123,
			ByOrgNbr = 0,
			FirstName = Guid.NewGuid().ToString(),
			MiddleInitial = Guid.NewGuid().ToString(),
			LastName = Guid.NewGuid().ToString(),
			Suffix = Guid.NewGuid().ToString(),
			PersonNumber = 1234
		};

		var entityName = $"{agreement.FirstName} {agreement.MiddleInitial} {agreement.LastName} {agreement.Suffix}";

		_mockCoreApiWrapperService.Setup(x => x.GetAgreementByUserId(It.IsAny<string>())).ReturnsAsync(agreement).Verifiable();

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
																												entityName,
																												null);
		var resultPayload = result.Payload;

		Assert.True(result.Success);
		Assert.AreEqual(agreement.PersonNumber.ToString(), resultPayload.PersonNumber);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Once);
	}


	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Success_Agreement_NoAgreement()
	{
		var memberNumberOrUserId = Guid.NewGuid().ToString();
		var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";
		Agreement nullAgreement = null;
		var personOrganization = new PersonOrganization()
		{
			PersonNumber = DateTime.Now.Millisecond.ToString(),
			OrganizationNumber = null,
			EntityName = entityName
		};

		_mockCoreApiWrapperService.Setup(x => x.GetAgreementByUserId(It.IsAny<string>())).ReturnsAsync(nullAgreement).Verifiable();
		_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
			entityName,
			null);
		var resultPayload = result.Payload;

		Assert.True(result.Success);
		Assert.AreEqual(personOrganization.PersonNumber, resultPayload.PersonNumber);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Success_PersonOrganization_PersonNumber()
	{
		var memberNumberOrUserId = $"M{Guid.NewGuid().ToString()}";
		var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";

		var personOrganization = new PersonOrganization()
		{
			PersonNumber = DateTime.Now.Millisecond.ToString(),
			OrganizationNumber = null,
			EntityName = entityName
		};

		_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
																												entityName,
																												null);
		var resultPayload = result.Payload;

		Assert.True(result.Success);
		Assert.AreEqual(personOrganization.PersonNumber, resultPayload.PersonNumber);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Success_PersonOrganization_OrganizationNumber()
	{
		var memberNumberOrUserId = $"M{Guid.NewGuid().ToString()}";
		var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";

		var personOrganization = new PersonOrganization
		{
			PersonNumber = null,
			OrganizationNumber = DateTime.Now.Millisecond.ToString(),
			EntityName = entityName
		};

		_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
																												entityName,
																												null);
		var resultPayload = result.Payload;

		Assert.True(result.Success);
		Assert.AreEqual(personOrganization.OrganizationNumber, resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.IsNull(resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Failure_PersonOrganization_IsNull()
	{
		var memberNumberOrUserId = $"M{Guid.NewGuid().ToString()}";
		var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";

		var personOrganization = new PersonOrganization
		{
			PersonNumber = null,
			OrganizationNumber = null,
			EntityName = entityName
		};

		_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
			entityName,
			null);
		var resultPayload = result.Payload;

		Assert.False(result.Success);
		Assert.IsNull(resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.IsNull(resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Failure_PersonOrganization_EntityNameDoesNotMatch()
	{
		var memberNumberOrUserId = $"M{Guid.NewGuid().ToString()}";
		var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";

		var personOrganization = new PersonOrganization
		{
			PersonNumber = null,
			OrganizationNumber = DateTime.Now.Millisecond.ToString(),
			EntityName = Guid.NewGuid().ToString()
		};

		_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>())).ReturnsAsync(personOrganization).Verifiable();

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
																												entityName,
																												null);

		Assert.False(result.Success);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Failure_PersonOrganization_Exception()
	{
		var memberNumberOrUserId = $"M{Guid.NewGuid().ToString()}";
		var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";

		_mockCoreApiWrapperService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()))
																			.ThrowsAsync(new ServiceException("Test")).Verifiable();

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
																												entityName,
																												null);

		Assert.IsFalse(result.Success);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Once);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
	}

	[Test]
	public async Task DeterminePrimaryOwnerAttributeByMemberNumberOrUserId_Success_PersonOrganization_OwnerOverride()
	{
		var memberNumberOrUserId = $"M{Guid.NewGuid().ToString()}";
		var entityName = $"{Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()} {Guid.NewGuid().ToString()}";

		var documentProcessingInfo = new DocumentProcessingInfo()
		{
			DocumentProcessingInfoId = DateTime.Now.Millisecond
		};

		var ownerOverrideInfo = new OwnerOverrideInfo()
		{
			DocumentProcessingInfoId = documentProcessingInfo.DocumentProcessingInfoId,
			EntityType = EntityTypes.Organization,
			EntityId = Guid.NewGuid().ToString(),
			UserName = Guid.NewGuid().ToString()
		};

		var result = await _primaryOwnerDeterminingService.DeterminePrimaryOwnerAttributeByMemberNumberOrUserId(memberNumberOrUserId,
																												entityName,
																												ownerOverrideInfo);
		var resultPayload = result.Payload;

		Assert.True(result.Success);
		Assert.AreEqual(ownerOverrideInfo.EntityId, resultPayload.OrganizationNumber);
		Assert.IsNull(resultPayload.PersonNumber);
		Assert.IsNull(resultPayload.AccountNumber);
		_mockCoreApiWrapperService.Verify(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<string>()), Times.Never);
		_mockCoreApiWrapperService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never);
	}
}