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 NewAtmCheckCardActivityStrategyTest
    {
        private  Mock<IUserService> _mockUserService;
        private  Mock<IDepartmentRepository> _mockDepartmentRepository;
        private  NewAtmCheckCardActivityStrategy _externalActivityService;
        [SetUp]
        public void Setup()
        {
            _mockUserService = new Mock<IUserService>();
            _mockDepartmentRepository = new Mock<IDepartmentRepository>();
            _externalActivityService = new NewAtmCheckCardActivityStrategy(_mockUserService.Object, _mockDepartmentRepository.Object);
        }

        [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.MapToActivityManagerActivity(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 NewAtmCheckCardActivityStrategy_CheckCard_OK()
        {
            var externalActivity = new NewAtmCheckCardActivity()
            {
                CardType = "Check Card",
                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.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.CheckCard);
            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 NewAtmCheckCardActivityStrategy_NoEmail_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",
            };

            _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.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.Never);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Once);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.IsAny<AppUser>()), Times.Once);
        }

        [Test]
        public async Task NewAtmCheckCardActivityStrategy_ATM_NoDepartment_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((Department) null);

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.ATMCard);
            Assert.True(activity.Type == ActivityType.Other);
            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.IsAny<AppUser>()), Times.Once);
        }

        //NewAtmCheckCard uses Users Home Department to assign branch.
        [Test]
        public async Task NewAtmCheckCardActivityStrategy_ATM_NoUser_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((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.ATMCard);
            Assert.True(activity.Type == ActivityType.Other);
            Assert.AreEqual(-1, activity.DepartmentId);
            Assert.AreEqual(null, 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.IsAny<AppUser>()), Times.Never);
        }

        [Test]
        public async Task NewAtmCheckCardActivityStrategy_ExceptionReturnsBasic()
        {
            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>())).ThrowsAsync(new Exception("Oops"));
            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>())).ReturnsAsync(new Department()
            {
                Id = 10
            });


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

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

    }
}