using System;
using System.Linq;
using Moq;
using NUnit.Framework;
using System.Collections.Generic;
using System.Threading.Tasks;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.AccessChannelPersons;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;
using LCU.Library.Internal.DataCleanUpModel.Enum;
using LCU.Library.Internal.DataCleanUpModel.Models;
using LCU.Api.Internal.DataCleanUp.Services;
using LCU.Api.Internal.DataCleanUp.DataAccess;

namespace LCU.Api.Internal.DataCleanUpTest.Services;

public class HyphenatedUserIdCleanUpServiceTest
{
    private HyphenatedUserIdCleanUpService _hyphenatedUserIdCleanUpService;
    private Mock<ICoreApiWrapperService> _mockCoreApiWrapperService;

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

    [Test]
    public async Task CleanUp_Success()
    {
        //Set Up GetAgreePersonsWithHyphenatedUserIds
        var testAgreePersons = new List<AgreePerson>()
            {
                new AgreePerson()
                {
                    PersonNumber = 1,
                    UserId = "1-1",
                    AgreeNumber = 1
                }
            };
        _mockCoreApiWrapperService.Setup(x => x.GetAgreePersonsWithHyphenatedUserIds()).ReturnsAsync(testAgreePersons);

        //Set Up GetCoreApiMessageAccessChannelPersons
        var coreMessageHeader = new CoreMessageHeader()
        {
            UpdateKey = 12312312323123
        };
        var testAccessChannelPersons = new List<AccessChannelPerson>()
            {
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId = "2312312312"
                },
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId= "1-1"
                }
            };
        var coreApiMessage = new CoreApiMessage<IEnumerable<AccessChannelPerson>>(coreMessageHeader, testAccessChannelPersons);
        _mockCoreApiWrapperService.Setup(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()))
                                    .ReturnsAsync(coreApiMessage);

        //Set Up UpdateAccessChannelPersons
        var testAccessChannelPerson = new AccessChannelPerson()
        {
            PersonNumber = 1,
            UserId = "1C1"
        };
        _mockCoreApiWrapperService.Setup(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()))
                                    .ReturnsAsync(testAccessChannelPerson);

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.HyphenatedUserId
        };
        var result = await _hyphenatedUserIdCleanUpService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsTrue(result.Successful);
        Assert.IsEmpty(result.ResponseStack);
        _mockCoreApiWrapperService.Verify(x => x.GetAgreePersonsWithHyphenatedUserIds(), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()), Times.Once);
    }

    [Test]
    public async Task CleanUp_Success_NoHyphenatedUserIds()
    {
        //Set Up GetAgreePersonsWithHyphenatedUserIds
        var testAgreePersons = new List<AgreePerson>()
            {
            };
        _mockCoreApiWrapperService.Setup(x => x.GetAgreePersonsWithHyphenatedUserIds()).ReturnsAsync(testAgreePersons);        

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.HyphenatedUserId
        };
        var result = await _hyphenatedUserIdCleanUpService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsTrue(result.Successful);
        Assert.IsEmpty(result.ResponseStack);
        _mockCoreApiWrapperService.Verify(x => x.GetAgreePersonsWithHyphenatedUserIds(), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()), Times.Never);
        _mockCoreApiWrapperService.Verify(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()), Times.Never);
    }

    [Test]
    public async Task CleanUp_Result_Fail_DetermineAccessChannelPersonUpdateDetails_ExceptionThrown()
    {
        //Set Up GetAgreePersonsWithHyphenatedUserIds
        _mockCoreApiWrapperService.Setup(x => x.GetAgreePersonsWithHyphenatedUserIds()).ThrowsAsync(new Exception("Oops"));

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.HyphenatedUserId
        };
        var result = await _hyphenatedUserIdCleanUpService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.GetAgreePersonsWithHyphenatedUserIds(), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()), Times.Never);
        _mockCoreApiWrapperService.Verify(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()), Times.Never);
    }

    [Test]
    public async Task CleanUp_Result_Fail_DetermineAccessChannelPersonUpdateDetails_CoreApiMessage_Null()
    {
        //Set Up GetAgreePersonsWithHyphenatedUserIds
        var testAgreePersons = new List<AgreePerson>()
            {
                new AgreePerson()
                {
                    PersonNumber = 1,
                    UserId = "1-1",
                    AgreeNumber = 1
                }
            };
        _mockCoreApiWrapperService.Setup(x => x.GetAgreePersonsWithHyphenatedUserIds()).ReturnsAsync(testAgreePersons);

        //Set Up GetCoreApiMessageAccessChannelPersons        
        CoreApiMessage<IEnumerable<AccessChannelPerson>>? coreApiMessage = null;
        _mockCoreApiWrapperService.Setup(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()))
                                    .ReturnsAsync(coreApiMessage);

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.HyphenatedUserId
        };
        var result = await _hyphenatedUserIdCleanUpService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.GetAgreePersonsWithHyphenatedUserIds(), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()), Times.Never);
    }

    [Test]
    public async Task CleanUp_Result_Fail_DetermineAccessChannelPersonUpdateDetails_CoreApiMessage_MessageHeader_Null()
    {
        //Set Up GetAgreePersonsWithHyphenatedUserIds
        var testAgreePersons = new List<AgreePerson>()
            {
                new AgreePerson()
                {
                    PersonNumber = 1,
                    UserId = "1-1",
                    AgreeNumber = 1
                }
            };
        _mockCoreApiWrapperService.Setup(x => x.GetAgreePersonsWithHyphenatedUserIds()).ReturnsAsync(testAgreePersons);

        //Set Up GetCoreApiMessageAccessChannelPersons        
        CoreMessageHeader? coreMessageHeader = null;
        var testAccessChannelPersons = new List<AccessChannelPerson>()
            {
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId = "2312312312"
                },
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId= "1-1"
                }
            };
        var coreApiMessage = new CoreApiMessage<IEnumerable<AccessChannelPerson>>(coreMessageHeader, testAccessChannelPersons);
        _mockCoreApiWrapperService.Setup(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()))
                                    .ReturnsAsync(coreApiMessage);     

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.HyphenatedUserId
        };
        var result = await _hyphenatedUserIdCleanUpService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.GetAgreePersonsWithHyphenatedUserIds(), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()), Times.Never);
    }

    [Test]
    public async Task CleanUp_Result_Fail_DetermineAccessChannelPersonUpdateDetails_CoreApiMessage_UpdateKey_Null()
    {
        //Set Up GetAgreePersonsWithHyphenatedUserIds
        var testAgreePersons = new List<AgreePerson>()
            {
                new AgreePerson()
                {
                    PersonNumber = 1,
                    UserId = "1-1",
                    AgreeNumber = 1
                }
            };
        _mockCoreApiWrapperService.Setup(x => x.GetAgreePersonsWithHyphenatedUserIds()).ReturnsAsync(testAgreePersons);

        //Set Up GetCoreApiMessageAccessChannelPersons        
        var coreMessageHeader = new CoreMessageHeader() 
        { 
            UpdateKey = null
        };
        var testAccessChannelPersons = new List<AccessChannelPerson>()
            {
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId = "2312312312"
                },
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId= "1-1"
                }
            };
        var coreApiMessage = new CoreApiMessage<IEnumerable<AccessChannelPerson>>(coreMessageHeader, testAccessChannelPersons);
        _mockCoreApiWrapperService.Setup(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()))
                                    .ReturnsAsync(coreApiMessage);       

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.HyphenatedUserId
        };
        var result = await _hyphenatedUserIdCleanUpService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.GetAgreePersonsWithHyphenatedUserIds(), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()), Times.Never);
    }

    [Test]
    public async Task CleanUp_Result_Fail_DetermineAccessChannelPersonUpdateDetails_CoreApiMessage_MessageBody_Null()
    {
        //Set Up GetAgreePersonsWithHyphenatedUserIds
        var testAgreePersons = new List<AgreePerson>()
            {
                new AgreePerson()
                {
                    PersonNumber = 1,
                    UserId = "1-1",
                    AgreeNumber = 1
                }
            };
        _mockCoreApiWrapperService.Setup(x => x.GetAgreePersonsWithHyphenatedUserIds()).ReturnsAsync(testAgreePersons);

        //Set Up GetCoreApiMessageAccessChannelPersons
        var coreMessageHeader = new CoreMessageHeader()
        {
            UpdateKey = 12312312323123
        };
        List<AccessChannelPerson>? testAccessChannelPersons = null;
        var coreApiMessage = new CoreApiMessage<IEnumerable<AccessChannelPerson>>(coreMessageHeader, testAccessChannelPersons);
        _mockCoreApiWrapperService.Setup(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()))
                                    .ReturnsAsync(coreApiMessage);     

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.HyphenatedUserId
        };
        var result = await _hyphenatedUserIdCleanUpService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.GetAgreePersonsWithHyphenatedUserIds(), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()), Times.Never);
    }

    [Test]
    public async Task CleanUp_Result_Fail_DetermineAccessChannelPersonUpdateDetails_AccessChannelWithHypenateduserId_Null()
    {
        //Set Up GetAgreePersonsWithHyphenatedUserIds
        var testAgreePersons = new List<AgreePerson>()
            {
                new AgreePerson()
                {
                    PersonNumber = 1,
                    UserId = "1-1",
                    AgreeNumber = 1
                }
            };
        _mockCoreApiWrapperService.Setup(x => x.GetAgreePersonsWithHyphenatedUserIds()).ReturnsAsync(testAgreePersons);

        //Set Up GetCoreApiMessageAccessChannelPersons
        var coreMessageHeader = new CoreMessageHeader()
        {
            UpdateKey = 12312312323123
        };
        var testAccessChannelPersons = new List<AccessChannelPerson>()
            {
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId = "2312312312"
                },
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId= "3-3"
                }
            };
        var coreApiMessage = new CoreApiMessage<IEnumerable<AccessChannelPerson>>(coreMessageHeader, testAccessChannelPersons);
        _mockCoreApiWrapperService.Setup(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()))
                                    .ReturnsAsync(coreApiMessage);

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.HyphenatedUserId
        };
        var result = await _hyphenatedUserIdCleanUpService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.GetAgreePersonsWithHyphenatedUserIds(), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()), Times.Never);
    }

    [Test]
    public async Task CleanUp_Result_Fail_HandleUpdateOfHyphenatedUserId_UpdatedAccessChannelPerson_Null()
    {
        //Set Up GetAgreePersonsWithHyphenatedUserIds
        var testAgreePersons = new List<AgreePerson>()
            {
                new AgreePerson()
                {
                    PersonNumber = 1,
                    UserId = "1-1",
                    AgreeNumber = 1
                }
            };
        _mockCoreApiWrapperService.Setup(x => x.GetAgreePersonsWithHyphenatedUserIds()).ReturnsAsync(testAgreePersons);

        //Set Up GetCoreApiMessageAccessChannelPersons
        var coreMessageHeader = new CoreMessageHeader()
        {
            UpdateKey = 12312312323123
        };
        var testAccessChannelPersons = new List<AccessChannelPerson>()
            {
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId = "2312312312"
                },
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId= "1-1"
                }
            };
        var coreApiMessage = new CoreApiMessage<IEnumerable<AccessChannelPerson>>(coreMessageHeader, testAccessChannelPersons);
        _mockCoreApiWrapperService.Setup(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()))
                                    .ReturnsAsync(coreApiMessage);

        //Set Up UpdateAccessChannelPersons
        AccessChannelPerson? testAccessChannelPerson = null;
        _mockCoreApiWrapperService.Setup(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()))
                                    .ReturnsAsync(testAccessChannelPerson);

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.HyphenatedUserId
        };
        var result = await _hyphenatedUserIdCleanUpService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.GetAgreePersonsWithHyphenatedUserIds(), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()), Times.Once);
    }

    [Test]
    public async Task CleanUp_Result_Fail_HandleUpdateOfHyphenatedUserId_UpdatedAccessChannelPerson_UserId_DoesNotMatch_NewUserId()
    {
        //Set Up GetAgreePersonsWithHyphenatedUserIds
        var testAgreePersons = new List<AgreePerson>()
            {
                new AgreePerson()
                {
                    PersonNumber = 1,
                    UserId = "1-1",
                    AgreeNumber = 1
                }
            };
        _mockCoreApiWrapperService.Setup(x => x.GetAgreePersonsWithHyphenatedUserIds()).ReturnsAsync(testAgreePersons);

        //Set Up GetCoreApiMessageAccessChannelPersons
        var coreMessageHeader = new CoreMessageHeader()
        {
            UpdateKey = 12312312323123
        };
        var testAccessChannelPersons = new List<AccessChannelPerson>()
            {
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId = "2312312312"
                },
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId= "1-1"
                }
            };
        var coreApiMessage = new CoreApiMessage<IEnumerable<AccessChannelPerson>>(coreMessageHeader, testAccessChannelPersons);
        _mockCoreApiWrapperService.Setup(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()))
                                    .ReturnsAsync(coreApiMessage);

        //Set Up UpdateAccessChannelPersons
        var testAccessChannelPerson = new AccessChannelPerson()
        {
            PersonNumber = 1,
            UserId = "1B1"
        };
        _mockCoreApiWrapperService.Setup(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()))
                                    .ReturnsAsync(testAccessChannelPerson);

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.HyphenatedUserId
        };
        var result = await _hyphenatedUserIdCleanUpService.CleanUp(testRequest);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsFalse(result.Successful);
        Assert.AreEqual(1, result.ResponseStack.Count());
        _mockCoreApiWrapperService.Verify(x => x.GetAgreePersonsWithHyphenatedUserIds(), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()), Times.Once);
    }

    [Test]
    public async Task HandleUpdateOfHyphenatedUserId_Success()
    {
        //Set Up GetCoreApiMessageAccessChannelPersons
        var coreMessageHeader = new CoreMessageHeader()
        {
            UpdateKey = 12312312323123
        };
        var testAccessChannelPersons = new List<AccessChannelPerson>()
            {
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId = "2312312312"
                },
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId= "1-1"
                }
            };
        var coreApiMessage = new CoreApiMessage<IEnumerable<AccessChannelPerson>>(coreMessageHeader, testAccessChannelPersons);
        _mockCoreApiWrapperService.Setup(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()))
                                    .ReturnsAsync(coreApiMessage);

        //Set Up UpdateAccessChannelPersons
        var testAccessChannelPerson = new AccessChannelPerson()
        {
            PersonNumber = 1,
            UserId = "1C1"
        };

        _mockCoreApiWrapperService.Setup(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()))
                                    .ReturnsAsync(testAccessChannelPerson);

        var testRequest = new DataCleanUpRequest()
        {
            CleanUpType = CleanUpTypes.HyphenatedUserId
        };
        var dataCleanUpResult = new DataCleanUpResult(testRequest, true, new List<string>());
        var testAgreePerson = new AgreePerson()
        {
            PersonNumber = 1,
            UserId = "1-1",
            AgreeNumber = 1
        };
        var result = await _hyphenatedUserIdCleanUpService.HandleUpdateOfHyphenatedUserId(dataCleanUpResult, testAgreePerson);

        Assert.NotNull(result);
        Assert.AreEqual(testRequest, result.Request);
        Assert.IsTrue(result.Successful);
        Assert.IsEmpty(result.ResponseStack);
        _mockCoreApiWrapperService.Verify(x => x.GetAgreePersonsWithHyphenatedUserIds(), Times.Never);
        _mockCoreApiWrapperService.Verify(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()), Times.Once);
    }

    [Test]
    public async Task DetermineAccessChannelPersonUpdateDetails_Success()
    {
        //Set Up GetCoreApiMessageAccessChannelPersons
        var coreMessageHeader = new CoreMessageHeader()
        {
            UpdateKey = 12312312323123
        };

        var accessChannelPersonResult = new AccessChannelPerson()
        {
            PersonNumber = 1,
            UserId = "1-1"
        };
        var testAccessChannelPersons = new List<AccessChannelPerson>()
            {
                new AccessChannelPerson()
                {
                    PersonNumber = 1,
                    UserId = "2312312312"
                },
                accessChannelPersonResult
            };
        var coreApiMessage = new CoreApiMessage<IEnumerable<AccessChannelPerson>>(coreMessageHeader, testAccessChannelPersons);
        _mockCoreApiWrapperService.Setup(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()))
                                    .ReturnsAsync(coreApiMessage);

        //Set Up UpdateAccessChannelPersons
        var testAccessChannelPerson = new AccessChannelPerson()
        {
            PersonNumber = 1,
            UserId = "1C1"
        };

        _mockCoreApiWrapperService.Setup(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()))
                                    .ReturnsAsync(testAccessChannelPerson);
       
        var testAgreePerson = new AgreePerson()
        {
            PersonNumber = 1,
            UserId = "1-1",
            AgreeNumber = 1
        };
        var result = await _hyphenatedUserIdCleanUpService.DetermineAccessChannelPersonUpdateDetails(testAgreePerson);

        Assert.NotNull(result);
        Assert.AreEqual(12312312323123, result.updateKey);
        Assert.AreEqual(accessChannelPersonResult, result.accessChannelPerson);
        _mockCoreApiWrapperService.Verify(x => x.GetAgreePersonsWithHyphenatedUserIds(), Times.Never);
        _mockCoreApiWrapperService.Verify(x => x.GetCoreApiMessageAccessChannelPersons(It.IsAny<AccessChannelPersonsByPersonRequest>()), Times.Once);
        _mockCoreApiWrapperService.Verify(x => x.UpdateAccessChannelPersons(It.IsAny<AccessChannelPerson>(), It.IsAny<long>()), Times.Never);
    }
}