using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
using LCU.API.Internal.Operations.IncentiveApi.Extensions;
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.IncentiveApi.Services.ExternalActivity;
using LCU.API.Internal.Operations.IncentiveApiLib.Services;
using LCU.Library.Internal.IncentiveApiModels.Requests;

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

        [SetUp]
        public void SetUp()
        {
            _mockUserService = new Mock<IUserService>();
            _mockDepartmentRepository = new Mock<IDepartmentRepository>();
            var strategies = new List<IExternalActivityStrategy>()
            {
                new NewCheckingAccountActivityStrategy(_mockUserService.Object, _mockDepartmentRepository.Object),
                new NewIncentiveManagerActivityStrategy(_mockUserService.Object, _mockDepartmentRepository.Object),
                new NewAtmCheckCardActivityStrategy(_mockUserService.Object, _mockDepartmentRepository.Object),
                new NewMortgageActivityStrategy(_mockUserService.Object, _mockDepartmentRepository.Object)
            };
            _externalActivityService = new ExternalActivityService(strategies);
        }

        [Test]
        public async Task NewAtmCheckCardActivityStrategy_ATM_OK()
        {
            var externalActivity = new NewAtmCheckCardActivity()
            {
                CardType = "ATM",
                AccountNbr = 1,
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                ResponsiblePersonNbr = 1234,
                AgreementNbr = 10111,
                OwnerPersonNbr = "5678",
                AcctStateAtActivity = "ACT",
                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.TryMapExternalActivity(externalActivity);
            Assert.True(activity.Product == Product.ATMCard);
            Assert.True(activity.Type == ActivityType.Other);
            Assert.AreEqual(10, activity.DepartmentId);
            Assert.AreEqual("7624", activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.IsAny<string>()), Times.Exactly(1));
        }

        [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.TryMapExternalActivity(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.GetAllUsersAsync(It.IsAny<UserSearchRequest>()), Times.Never);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.Is<AppUser>(x => x.EmployeeId == "7624")), Times.Once);
        }

        [TestCase("Atm Card", Product.ATMCard)]
        [TestCase("Check Card Referral", Product.CheckCard)]
        [TestCase("Checking Referral", Product.NewChecking)]
        [TestCase("Mortgage Referral", Product.Mortgage)]
        [TestCase("Direct Deposit", Product.DirectDeposit)]
        [TestCase("CC Balance Transfer", Product.CreditCardBalanceTransfer)]
        public async Task NewIncentiveManagerActivityStrategy_Ok(string campaign, Product product)
        {
            var externalActivity = new NewActivityManagerReferral()
            {
                OriginatingBranchName = "MEQUON",
                OriginatorPersNbr = 5,
                OriginatorUserId = "JSMITHB",
                ReferredPersonNbr = "1234",
                ReferredPersOrgNbr = null,
                ReferralStation= "Submitted",
                StationDateTime = DateTime.Today.StartOfMonth(),
                Campaign = campaign,
                OriginationDateTime = DateTime.Parse("2021-03-10"),
                OriginatorFirstName = "John",
                OriginatorLastName = "Smith",
                OriginatorMiddleInitial = "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.FindDepartmentByBranchName(It.IsAny<string>())).ReturnsAsync(
                new Department()
                {
                    Id = 10
                }
            );

            var activity = await _externalActivityService.TryMapExternalActivity(externalActivity);
            Assert.True(activity.Product == product);
            Assert.True(activity.Type == ActivityType.Referral);
            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);
            _mockDepartmentRepository.Verify(x => x.FindDepartmentByBranchName(It.Is<string>(x => x == "MEQUON")), Times.Once);
        }

        [Test]
        public async Task NewMortgageActivityStrategy_Ok()
        {
            var externalActivity = new NewLoanSaleActivity()
            {
                SubjectAccountNbr = 1,
                OriginatingPersonNbr = 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",
                MinorAccountType = "FE01"
            };

            _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.TryMapExternalActivity(externalActivity);
            Assert.True(activity.Product == Product.Mortgage);
            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.GetAllUsersAsync(It.IsAny<UserSearchRequest>()), Times.Never);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.Is<AppUser>(x => x.EmployeeId == "7624")), Times.Once);
        }

    }
}