using System;
using System.Threading.Tasks;
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using LCU.API.Internal.Operations.IncentiveApi.Models.ExternalActivities;
using Moq;
using NUnit.Framework;
using LCU.API.Internal.Operations.IncentiveApiLib.Services;
using LCU.API.Internal.Operations.IncentiveApi.Services.ExternalActivity;
using LCU.API.Internal.Operations.IncentiveApi.Models.DataTransfer;

namespace Application.UnitTests.Services.ExternalActivity
{
    public class NewCheckingAccountActivityStrategyTest
    {
        private  Mock<IUserService> _mockUserService;
        private  Mock<IDepartmentRepository> _mockDepartmentRepository;
        private  NewCheckingAccountActivityStrategy _externalActivityService;

        [SetUp]
        public void Setup()
        {
            _mockUserService = new Mock<IUserService>();
            _mockDepartmentRepository = new Mock<IDepartmentRepository>();
            _externalActivityService = new NewCheckingAccountActivityStrategy(_mockUserService.Object, _mockDepartmentRepository.Object);
        }

        [Test]
        public async Task NewCheckingAccountActivityStrategy_Ok()
        {
            var externalActivity = new NewCheckingAccountActivity()
            {
                SubjectAccountNbr = 1,
                ResponsiblePersonNbr = 1234,
                BranchOrgName = "West Bend-Main Branch",
                BranchOrgNbr = 400,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "John",
                AssociateLast = "Smith",
                AssociateMiddleInit = "B",
                EmployeeEmail = "JohnnySmith@landmarkcu.com"
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync(new AppUser()
            {
                AdEmail = "JohnnySmith@landmarkcu.com",
                EmployeeId = "7624"
            });
            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>())).ReturnsAsync(
                new Department()
                {
                    Id = 10
                }
            );

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.NewChecking);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(10, activity.DepartmentId);
            Assert.AreEqual("7624", activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.Is<string>(x => x == "JohnnySmith@landmarkcu.com")), Times.Once);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Never);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.Is<AppUser>(x => x.EmployeeId == "7624")), Times.Once);
        }

        [Test]
        public async Task NewCheckingAccountActivityStrategy_NoEmail_Ok()
        {
            var externalActivity = new NewCheckingAccountActivity()
            {
                SubjectAccountNbr = 1,
                ResponsiblePersonNbr = 1234,
                BranchOrgName = "West Bend-Main Branch",
                BranchOrgNbr = 400,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "John",
                AssociateLast = "Smith",
                AssociateMiddleInit = "B",
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync((AppUser) null);
           _mockUserService.Setup(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>())).ReturnsAsync(

               new AppUser()
               {
                   AdEmail = "JohnSmith@landmarkcu.com",
                   EmployeeId = "7624"
               });

           _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>())).ReturnsAsync(
                new Department()
                {
                    Id = 10
                }
            );

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.NewChecking);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(10, activity.DepartmentId);
            Assert.AreEqual("7624", activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.IsAny<string>()), Times.Never);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Once);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.Is<AppUser>(x => x.EmployeeId == "7624")), Times.Once);
        }

        [Test]
        public async Task NewCheckingAccountActivityStrategy_NoUser()
        {
            var externalActivity = new NewCheckingAccountActivity()
            {
                SubjectAccountNbr = 1,
                ResponsiblePersonNbr = 1234,
                BranchOrgName = "West Bend-Main Branch",
                BranchOrgNbr = 400,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "John",
                AssociateLast = "Smith",
                AssociateMiddleInit = "B",
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync((AppUser) null);
            _mockUserService
                .Setup(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()))
                .ReturnsAsync((AppUser)null);

            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>())).ReturnsAsync(
            new Department()
            {
                Id = 10
            });

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.NewChecking);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(-1, activity.DepartmentId);
            Assert.AreEqual(null, activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.IsAny<string>()), Times.Never);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Once);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.IsAny<AppUser>()), Times.Never());
        }

        [Test]
        public async Task NewCheckingAccountActivityStrategy_NoDepartment_Ok()
        {
            var externalActivity = new NewCheckingAccountActivity()
            {
                SubjectAccountNbr = 1,
                ResponsiblePersonNbr = 1234,
                BranchOrgName = "West Bend-Main Branch",
                BranchOrgNbr = 400,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "John",
                AssociateLast = "Smith",
                AssociateMiddleInit = "B",
                EmployeeEmail = "JohnnySmith@landmarkcu.com"
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync(new AppUser()
            {
                AdEmail = "JohnnySmith@landmarkcu.com",
                EmployeeId = "7624"
            });
            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>()))
                .ReturnsAsync((Department)null);

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.NewChecking);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(-1, activity.DepartmentId);
            Assert.AreEqual("7624", activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.Is<string>(x => x == "JohnnySmith@landmarkcu.com")), Times.Once);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Never);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.Is<AppUser>(x => x.EmployeeId == "7624")), Times.Once);
        }

        [Test]
        public async Task NewCheckingAccountActivityStrategy_ExceptionReturnsBasic()
        {
            var externalActivity = new NewCheckingAccountActivity()
            {
                SubjectAccountNbr = 1,
                ResponsiblePersonNbr = 1234,
                BranchOrgName = "West Bend-Main Branch",
                BranchOrgNbr = 400,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "John",
                AssociateLast = "Smith",
                AssociateMiddleInit = "B",
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ThrowsAsync(new Exception("OOPS"));
            _mockUserService
                .Setup(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()))
                .ThrowsAsync(new Exception("OOPS"));
            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>()))
                .ReturnsAsync((Department)null);

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.NewChecking);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(-1, activity.DepartmentId);
            Assert.AreEqual(null, activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.Is<string>(x => x == "JohnnySmith@landmarkcu.com")), Times.Never);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Once);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.IsAny<AppUser>()), Times.Never);
        }

        [Test]
        public async Task NewDigitalBankingCheckingAccountActivityStrategy_Ok()
        {
            var externalActivity = new NewCheckingAccountActivity()
            {
                SubjectAccountNbr = 1,
                ResponsiblePersonNbr = 1234,
                BranchOrgName = "Digital Banking",
                BranchOrgNbr = 1210,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2022-12-10"),
                AssociateFirst = "Digital",
                AssociateLast = "Banking",
                AssociateMiddleInit = "",
                EmployeeEmail = "DigitalBanking@landmarkcu.com"
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync(new AppUser()
            {
                AdEmail = "DigitalBanking@landmarkcu.com",
                EmployeeId = "DigitalBankingAppUserEmployeeId"
            });
            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>())).ReturnsAsync(
                new Department()
                {
                    Id = 43
                }
            );

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.NewChecking);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(43, activity.DepartmentId);
            Assert.AreEqual("DigitalBankingAppUserEmployeeId", activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.Is<string>(x => x == "DigitalBanking@landmarkcu.com")), Times.Once);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Never);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.Is<AppUser>(x => x.EmployeeId == "DigitalBankingAppUserEmployeeId")), Times.Once);
        }


        [Test]
        public async Task NewDigitalBankingCheckingAccountActivityStrategy_NoEmail_Ok()
        {
            var externalActivity = new NewCheckingAccountActivity()
            {
                SubjectAccountNbr = 1,
                ResponsiblePersonNbr = 1234,
                BranchOrgName = "Digital Banking",
                BranchOrgNbr = 1210,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "Digital",
                AssociateLast = "Banking",
                AssociateMiddleInit = ""
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync((AppUser)null);
            _mockUserService.Setup(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>())).ReturnsAsync(

                new AppUser()
                {
                    AdEmail = "DigitalBanking@landmarkcu.com",
                    EmployeeId = "DigitalBankingAppUserEmployeeId"
                });

            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>())).ReturnsAsync(
                 new Department()
                 {
                     Id = 43
                 }
             );

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.NewChecking);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(43, activity.DepartmentId);
            Assert.AreEqual("DigitalBankingAppUserEmployeeId", activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.IsAny<string>()), Times.Never);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Once);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.Is<AppUser>(x => x.EmployeeId == "DigitalBankingAppUserEmployeeId")), Times.Once);
        }

        [Test]
        public async Task NewDigitalBankingCheckingAccountActivityStrategy_NoUser()
        {
            var externalActivity = new NewCheckingAccountActivity()
            {
                SubjectAccountNbr = 1,
                ResponsiblePersonNbr = 1234,
                BranchOrgName = "Digital Banking",
                BranchOrgNbr = 1210,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "Digital",
                AssociateLast = "Banking",
                AssociateMiddleInit = ""
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync((AppUser)null);
            _mockUserService
                .Setup(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()))
                .ReturnsAsync((AppUser)null);

            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>())).ReturnsAsync(
            new Department()
            {
                Id = 43
            });

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.NewChecking);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(-1, activity.DepartmentId);
            Assert.AreEqual(null, activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.IsAny<string>()), Times.Never);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Once);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.IsAny<AppUser>()), Times.Never());
        }

        [Test]
        public async Task NewDigitalBankingCheckingAccountActivityStrategy_NoDepartment_Ok()
        {
            var externalActivity = new NewCheckingAccountActivity()
            {
                SubjectAccountNbr = 1,
                ResponsiblePersonNbr = 1234,
                BranchOrgName = "Digital Banking",
                BranchOrgNbr = 1210,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "Digital",
                AssociateLast = "Banking",
                AssociateMiddleInit = "",
                EmployeeEmail = "DigitalBanking@landmarkcu.com"
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync(new AppUser()
            {
                AdEmail = "DigitalBanking@landmarkcu.com",
                EmployeeId = "DigitalBankingAppUserEmployeeId"
            });
            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>()))
                .ReturnsAsync((Department)null);

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.NewChecking);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(-1, activity.DepartmentId);
            Assert.AreEqual("DigitalBankingAppUserEmployeeId", activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.Is<string>(x => x == "DigitalBanking@landmarkcu.com")), Times.Once);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Never);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.Is<AppUser>(x => x.EmployeeId == "DigitalBankingAppUserEmployeeId")), Times.Once);
        }

        [Test]
        public async Task NewDigitalBankingCheckingAccountActivityStrategy_ExceptionReturnsBasic()
        {
            var externalActivity = new NewCheckingAccountActivity()
            {
                SubjectAccountNbr = 1,
                ResponsiblePersonNbr = 1234,
                BranchOrgName = "Digital Banking",
                BranchOrgNbr = 1210,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "Digital",
                AssociateLast = "Banking",
                AssociateMiddleInit = ""
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ThrowsAsync(new Exception("OOPS"));
            _mockUserService
                .Setup(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()))
                .ThrowsAsync(new Exception("OOPS"));
            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>()))
                .ReturnsAsync((Department)null);

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.NewChecking);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(-1, activity.DepartmentId);
            Assert.AreEqual(null, activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.Is<string>(x => x == "DigitalBanking@landmarkcu.com")), Times.Never);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Once);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.IsAny<AppUser>()), Times.Never);
        }

    }
}