using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using LCU.API.Internal.Operations.IncentiveApi.Services;
using Microsoft.AspNetCore.Mvc;
using Moq;
using NUnit.Framework;
using LCU.API.Internal.Operations.IncentiveApi.Controllers;
using LCU.API.Internal.Operations.IncentiveApiLib.Services;
using LCU.API.Internal.Operations.IncentiveApiLib.Persistence;
using LCU.API.Internal.Operations.IncentiveApi.Services.AutoDecision;
using LCU.Library.Internal.IncentiveApiModels.Common;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using LCU.API.Internal.Operations.IncentiveApi.Models;
using LCU.API.Internal.Operations.IncentiveApi.Exceptions;
using LCU.API.Internal.Operations.IncentiveApi.Models.DataTransfer;

namespace Application.UnitTests.Controllers
{
    public class ActivityControllerTest
    {
        private ActivityController _controller;
        private Mock<IActivityService> _mockActivityService;
        private Mock<IActivityDetailService> _mockActivityDetailService;
        private Mock<IUserService> _mockUserService;
        private Mock<ICurrentUserService> _mockCurrentUserService;
        private Mock<IDashboardService> _mockDashboardService;
        private Mock<IActivityDecisionService> _mockActivityDecisionService;
        private Mock<IEStatementService> _mockEStatementService;

        [SetUp]
        public void Setup()
        {
            _mockActivityService = new Mock<IActivityService>();
            _mockActivityDetailService = new Mock<IActivityDetailService>();
            _mockUserService = new Mock<IUserService>();
            _mockCurrentUserService = new Mock<ICurrentUserService>();
            _mockDashboardService = new Mock<IDashboardService>();
            _mockActivityDecisionService = new Mock<IActivityDecisionService>();
            _mockEStatementService = new Mock<IEStatementService>();
            _controller = new ActivityController(_mockActivityService.Object, _mockActivityDetailService.Object, _mockUserService.Object,
                _mockCurrentUserService.Object, _mockDashboardService.Object, _mockActivityDecisionService.Object, _mockEStatementService.Object);
        }

        [Test]
        public async Task Get_OK()
        {
            var filter = new ActivityFilter()
            {
                Limit = 999,
                Page = 1
            };
            var results = new PagedResult<Activity>();
            results.Items = new List<Activity>()
            {
                new Activity()
                {
                    Id = 1
                }
            };
            results.Total = 1;

            _mockActivityService
                .Setup(service => service.ListByFilterAsync(filter)).ReturnsAsync(results);
            var result = await _controller.Get(filter);
            Assert.NotNull(result);

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task POST_OK()
        {
            var activity = new Activity()
            {
                Product = Product.CheckCard,
                State = ActivityState.Created,
                EmployeeId = "55",
                DepartmentId = 55,
                SourceId = "444",
                SourceSystem = SystemType.Dna
            };
            _mockActivityService
                .Setup(service => service.SaveActivityAsync(activity)).ReturnsAsync(1);

            var result = await _controller.CreateActivity(activity);
            Assert.NotNull(result);

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task Get_CurrentUserActivity_OK()
        {
            var user1 = new ApplicationUser()
            {
                Email = "tester@test.com",
                FirstName = "Test",
                LastName = "McTester"
            };
            var user = new AppUser()
            {
                Role = Role.Admin,
                AdEmail = "tester@test.com",
                BaseRole = "Tester",
                EmployeeId = "11771",
                FullName = "Test McTester",
                HomeDepartment = "HOME",
                PersonId = 565
            };
            var range = new MonthRange(2021,1,2021,2);
            var goals = new EmployeeProgress(user, range, new List<IPayoutRule>());

            _mockCurrentUserService.Setup(service => service.GetCurrentUser()).Returns(user1);
            _mockUserService.Setup(service => service.GetUserByAdEmailAsync(user1.Email)).ReturnsAsync(user);
            _mockDashboardService
                .Setup(service => service.GetEmployeeProgressForMonthRangeAsync(goals.Employee, range))
                .ReturnsAsync(goals);

            var result = await _controller.GetCurrentUserProgress(range.FromMonth, range.FromYear, range.ToMonth, range.ToYear);
            Assert.NotNull(result);

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task Get_CurrentUserDepartmentProgress_OK()
        {
            var user1 = new ApplicationUser()
            {
                Email = "tester@test.com",
                FirstName = "Test",
                LastName = "McTester"
            };
            var user = new AppUser()
            {
                Role = Role.Admin,
                AdEmail = "tester@test.com",
                BaseRole = "Tester",
                EmployeeId = "11771",
                FullName = "Test McTester",
                HomeDepartment = "HOME",
                PersonId = 565,
                Departments = new List<UserDepartment> {
                    new UserDepartment {
                        DepartmentId = 1,
                        StartDate = new DateTime(2021, 7, 1),
                        EndDate = new DateTime(2021, 7, 31)
                    }
                }
            };
            var range = new MonthRange(2021,1,2021,2);
            var goals = new List<DepartmentProgress> { new DepartmentProgress(1, range) };

            _mockCurrentUserService.Setup(service => service.GetCurrentUser()).Returns(user1);
            _mockUserService.Setup(service => service.GetUserByAdEmailAsync(user1.Email)).ReturnsAsync(user);
            _mockActivityService
                .Setup(service => service.GetDepartmentActivityForMonthRangeAsync(user.Departments, range))
                .ReturnsAsync(goals);

            var result = await _controller.GetCurrentUserProgress(range.FromMonth, range.FromYear, range.ToMonth, range.ToYear);
            Assert.NotNull(result);

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task Get_CurrentUserRegionProgress_OK()
        {
            var user1 = new ApplicationUser()
            {
                Email = "tester@test.com",
                FirstName = "Test",
                LastName = "McTester"
            };
            var user = new AppUser()
            {
                Role = Role.RegionalManager,
                AdEmail = "tester@test.com",
                BaseRole = "Tester",
                EmployeeId = "11771",
                FullName = "Test McTester",
                HomeDepartment = "HOME",
                PersonId = 565,
                Departments = new List<UserDepartment> {
                    new UserDepartment {
                        DepartmentId = 1,
                        StartDate = new DateTime(2021, 7, 1),
                        EndDate = new DateTime(2021, 7, 31),
                        Role = Role.RegionalManager,
                        Department = new Department()
                        {
                            Id = 5,
                            State = DepartmentState.Active,
                            DepartmentName = "Dept 1",
                            RegionCode = Region.North.Code
                        }
                    }
                }
            };
            var range = new MonthRange(2021,1,2021,2);
            var progress = new RegionProgress(Region.North, range);

            _mockCurrentUserService.Setup(service => service.GetCurrentUser()).Returns(user1);
            _mockUserService.Setup(service => service.GetUserByAdEmailAsync(user1.Email)).ReturnsAsync(user);
            _mockDashboardService
                .Setup(service => service.GetRegionProgressForMonthRangeAsync(Region.North, range))
                .ReturnsAsync(progress);

            var result = await _controller.GetRegionProgress(range.FromMonth, range.FromYear, range.ToMonth, range.ToYear, Region.East.Code);
            Assert.NotNull(result);

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task GetActivityStateChanges_OK()
        {
            _mockActivityService
                .Setup(service => service.GetActivityStateChanges(It.IsAny<int>())).ReturnsAsync(
                    new List<ActivityStateChange>()
                    {
                        new ActivityStateChange()
                        {
                            Id = 1,
                            ActivityId = 5
                        },
                        new ActivityStateChange()
                        {
                            Id = 2,
                            ActivityId = 5
                        },
                        new ActivityStateChange()
                        {
                            Id = 3,
                            ActivityId = 5
                        }
                    });

            var result = await _controller.GetActivityStateChanges(5);
            Assert.NotNull(result);

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);


            var value = okResult.Value as IReadOnlyCollection<ActivityStateChange>;
            Assert.NotNull(value);
            Assert.AreEqual(3, value.Count);
        }

        [Test]
        public async Task GetActivityStateChanges_Exception()
        {
            _mockActivityService.Setup(x => x.GetActivityStateChanges(It.IsAny<int>()))
                .ThrowsAsync(new Exception("oops"));

            var result = await _controller.GetActivityStateChanges(5);
            Assert.NotNull(result);

            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);
        }

        [Test]
        public async Task Get_Single_Ok()
        {

            _mockActivityService.Setup(x => x.GetActivity(5))
                .ReturnsAsync(new Activity()
                {
                    Id = 5,
                });

            var result = await _controller.Get(5);
            Assert.NotNull(result);

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);


            var value = okResult.Value as Activity;
            Assert.NotNull(value);
            Assert.AreEqual(5, value.Id);
        }

        [Test]
        public async Task Get_Single_NotFound()
        {
            _mockActivityService.Setup(x => x.GetActivity(1))
                .ThrowsAsync(new NotFoundException("Not Found"));

            var result = await _controller.Get(1);
            Assert.NotNull(result);

            var badRequestResult = result as BadRequestObjectResult;
            Assert.NotNull(badRequestResult);
            Assert.AreEqual(400, badRequestResult.StatusCode);
            Assert.AreEqual("Activity Not Found.", badRequestResult.Value);
        }

        [Test]
        public async Task Get_Single_Exception()
        {
            _mockActivityService.Setup(x => x.GetActivity(1))
                .ThrowsAsync(new Exception("Internal Server Error"));

            var result = await _controller.Get(1);
            Assert.NotNull(result);

            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);
        }

        [Test]
        public async Task ManuallyUpdateActivityState_Ok()
        {
            var stateChange = new ActivityStateChange
            {
                ActivityId = 11,
                Note = "Change",
                State = ActivityState.Accepted
            };
            var activityResult = new Activity
            {
                Id = 11,
                State = ActivityState.Accepted
            };
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                .Returns(new ApplicationUser { Email = "user@landmarkcu.com" });
            _mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "user@landmarkcu.com")))
                .ReturnsAsync(new AppUser());
            _mockActivityService.Setup(mock => mock.ValidateCanApplyActivityStateChange(It.IsAny<AppUser>(), stateChange));
            _mockActivityService.Setup(mock => mock.ApplyStateChange(stateChange,true))
                .ReturnsAsync(activityResult);

            var result = await _controller.ManuallyUpdateActivityState(stateChange);

            Assert.NotNull(result);

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task ManuallyUpdateActivityState_AppUserNotFound()
        {
            var stateChange = new ActivityStateChange
            {
                ActivityId = 11,
                Note = "Change",
                State = ActivityState.Accepted
            };
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                .Returns((ApplicationUser)null);

            var result = await _controller.ManuallyUpdateActivityState(stateChange);
            Assert.NotNull(result);

            var unauthorizedResult = result as UnauthorizedObjectResult;
            Assert.NotNull(unauthorizedResult);
            Assert.AreEqual(401, unauthorizedResult.StatusCode);
            Assert.AreEqual("No AD User Found.", unauthorizedResult.Value);
        }

        [Test]
        public async Task ManuallyUpdateActivityState_UserNotFound()
        {
            var stateChange = new ActivityStateChange
            {
                ActivityId = 11,
                Note = "Change",
                State = ActivityState.Accepted
            };
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                .Returns(new ApplicationUser { Email = "user@landmarkcu.com" });
            _mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "user@landmarkcu.com")))
                .ReturnsAsync((AppUser)null);

            var result = await _controller.ManuallyUpdateActivityState(stateChange);
            Assert.NotNull(result);

            var unauthorizedResult = result as UnauthorizedObjectResult;
            Assert.NotNull(unauthorizedResult);
            Assert.AreEqual(401, unauthorizedResult.StatusCode);
            Assert.AreEqual("No AD User Found.", unauthorizedResult.Value);
        }

        [Test]
        public async Task ManuallyUpdateActivityState_BadActivityStateChangeException()
        {
            var stateChange = new ActivityStateChange
            {
                ActivityId = 11,
                Note = "Change",
                State = ActivityState.Accepted
            };
            var activityResult = new Activity
            {
                Id = 11,
                State = ActivityState.Accepted
            };
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                .Returns(new ApplicationUser { Email = "user@landmarkcu.com" });
            _mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "user@landmarkcu.com")))
                .ReturnsAsync(new AppUser());
            _mockActivityService.Setup(mock => mock.ValidateCanApplyActivityStateChange(It.IsAny<AppUser>(), stateChange))
                .ThrowsAsync(new BadActivityStateChangeException("Bad activity state change."));

            var result = await _controller.ManuallyUpdateActivityState(stateChange);

            Assert.NotNull(result);

            var badRequestResult = result as BadRequestObjectResult;
            Assert.NotNull(badRequestResult);
            Assert.AreEqual(400, badRequestResult.StatusCode);
            Assert.AreEqual("Bad activity state change.", badRequestResult.Value);
        }

        [Test]
        public async Task ManuallyUpdateActivityState_NotAuthorizedException()
        {
            var stateChange = new ActivityStateChange
            {
                ActivityId = 11,
                Note = "Change",
                State = ActivityState.Accepted
            };
            var activityResult = new Activity
            {
                Id = 11,
                State = ActivityState.Accepted
            };
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                .Returns(new ApplicationUser { Email = "user@landmarkcu.com" });
            _mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "user@landmarkcu.com")))
                .ReturnsAsync(new AppUser());
            _mockActivityService.Setup(mock => mock.ValidateCanApplyActivityStateChange(It.IsAny<AppUser>(), stateChange))
                .ThrowsAsync(new NotAuthorizedException("Not Authorized."));

            var result = await _controller.ManuallyUpdateActivityState(stateChange);

            Assert.NotNull(result);

            var objectResult = result as ObjectResult;
            Assert.NotNull(objectResult);
            Assert.AreEqual(403, objectResult.StatusCode);
            Assert.AreEqual("Not Authorized.", objectResult.Value);
        }

        [Test]
        public async Task ManuallyUpdateActivityState_NotFoundException()
        {
            var stateChange = new ActivityStateChange
            {
                ActivityId = 11,
                Note = "Change",
                State = ActivityState.Accepted
            };
            var activityResult = new Activity
            {
                Id = 11,
                State = ActivityState.Accepted
            };
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                .Returns(new ApplicationUser { Email = "user@landmarkcu.com" });
            _mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "user@landmarkcu.com")))
                .ReturnsAsync(new AppUser());
            _mockActivityService.Setup(mock => mock.ValidateCanApplyActivityStateChange(It.IsAny<AppUser>(), stateChange))
                .ThrowsAsync(new NotFoundException("Activity Not Found."));

            var result = await _controller.ManuallyUpdateActivityState(stateChange);

            Assert.NotNull(result);

            var badRequestResult = result as BadRequestObjectResult;
            Assert.NotNull(badRequestResult);
            Assert.AreEqual(400, badRequestResult.StatusCode);
            Assert.AreEqual("Activity Not Found.", badRequestResult.Value);
        }

        [Test]
        public async Task ManuallyUpdateActivityState_Exception()
        {
            var stateChange = new ActivityStateChange
            {
                ActivityId = 11,
                Note = "Change",
                State = ActivityState.Accepted
            };
            var activityResult = new Activity
            {
                Id = 11,
                State = ActivityState.Accepted
            };
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                .Returns(new ApplicationUser { Email = "user@landmarkcu.com" });
            _mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "user@landmarkcu.com")))
                .ReturnsAsync(new AppUser());
            _mockActivityService.Setup(mock => mock.ValidateCanApplyActivityStateChange(It.IsAny<AppUser>(), stateChange))
                .ThrowsAsync(new Exception("Internal Server Error."));

            var result = await _controller.ManuallyUpdateActivityState(stateChange);

            Assert.NotNull(result);

            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);
        }

        [Test]
        public async Task RequestTransfer_Ok()
        {
            var request = new ActivityTransferRequest
            {
                ActivityStateBeforeTransfer = ActivityState.Accepted,
                RequestedActivityId = 1,
                NewDepartmentId = 2,
                NewEmployeeId = "C0000"
            };

            var response = new ActivityTransferAction
            {
                ActivityStateBeforeTransfer = ActivityState.Accepted,
                RequestedActivityId = 1,
                NewActivity = new Activity
                {
                    Product = Product.CreditCard,
                    Type = ActivityType.Referral,
                    Detail = new ActivityDetail
                    {
                        Activity = new Activity
                        {
                            Product = Product.CreditCard,
                            Type = ActivityType.Referral,
                        },
                        AccountNumber = "1234567890"
                    }
                }
            };

            _mockActivityService.Setup(mock => mock.RequestTransfer(request)).ReturnsAsync(response).Verifiable();

            var result = await _controller.RequestTransfer(request);

            _mockActivityService.Verify();
            Assert.NotNull(result);
            var okResult = result as OkObjectResult;

            var activityTransfer = okResult.Value as ActivityTransferAction;

            Assert.NotNull(okResult);
            Assert.AreEqual("XXXXXX7890", activityTransfer.NewActivity.Detail.AccountNumber);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task RequestTransfer_NotFoundException()
        {
            var request = new ActivityTransferRequest
            {
                ActivityStateBeforeTransfer = ActivityState.Accepted,
                RequestedActivityId = 1,
                NewDepartmentId = 2,
                NewEmployeeId = "C0000"
            };
            _mockActivityService.Setup(mock => mock.RequestTransfer(It.IsAny<ActivityTransferRequest>()))
                .ThrowsAsync(new NotFoundException(""));

            var result = await _controller.RequestTransfer(request);

            Assert.NotNull(result);
            var badRequestResult = result as BadRequestObjectResult;
            Assert.NotNull(badRequestResult);
            Assert.AreEqual(400, badRequestResult.StatusCode);
            Assert.AreEqual("Activity Not Found.", badRequestResult.Value);
        }

        [Test]
        public async Task RequestTransfer_BadActivityTransferRequestException()
        {
            var request = new ActivityTransferRequest
            {
                ActivityStateBeforeTransfer = ActivityState.Accepted,
                RequestedActivityId = 1,
                NewDepartmentId = 2,
                NewEmployeeId = "C0000"
            };
            _mockActivityService.Setup(mock => mock.RequestTransfer(It.IsAny<ActivityTransferRequest>()))
                .ThrowsAsync(new BadActivityTransferActionException("Cannot complete request."));

            var result = await _controller.RequestTransfer(request);

            Assert.NotNull(result);
            var badRequestResult = result as BadRequestObjectResult;
            Assert.NotNull(badRequestResult);
            Assert.AreEqual(400, badRequestResult.StatusCode);
            Assert.AreEqual("Cannot complete request.", badRequestResult.Value);
        }

        [Test]
        public async Task RequestTransfer_Exception()
        {
            var request = new ActivityTransferRequest
            {
                ActivityStateBeforeTransfer = ActivityState.Accepted,
                RequestedActivityId = 1,
                NewDepartmentId = 2,
                NewEmployeeId = "C0000"
            };
            _mockActivityService.Setup(mock => mock.RequestTransfer(It.IsAny<ActivityTransferRequest>()))
                .ThrowsAsync(new Exception("Internal Server Error."));

            var result = await _controller.RequestTransfer(request);

            Assert.NotNull(result);
            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);
        }

        [Test]
        public async Task ApproveTransfer_Ok()
        {
            var approval = new ActivityTransferApprovalRequest
            {
                Id = 1,
                ApprovalState = ActivityTransferState.Accepted
            };
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                            .Returns(new ApplicationUser { Email = "user@landmarkcu.com" });
            _mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "user@landmarkcu.com")))
                .ReturnsAsync(new AppUser());
            _mockActivityService.Setup(mock => mock.ApproveTransfer(It.IsAny<AppUser>(), approval))
                .ReturnsAsync(new ActivityTransferAction { Id = 1 } );

            var result = await _controller.ApproveTransfer(approval);

            Assert.NotNull(result);
            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task ApproveTransfer_AppUserNotFound()
        {
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                .Returns((ApplicationUser)null);

            var result = await _controller.ApproveTransfer(new ActivityTransferApprovalRequest());

            Assert.NotNull(result);
            var unauthorizedResult = result as UnauthorizedObjectResult;
            Assert.NotNull(unauthorizedResult);
            Assert.AreEqual(401, unauthorizedResult.StatusCode);
            Assert.AreEqual("No AD User Found.", unauthorizedResult.Value);
        }

        [Test]
        public async Task ApproveTransfer_UserNotFound()
        {
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                .Returns(new ApplicationUser { Email = "user@landmarkcu.com" });
            _mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "user@landmarkcu.com")))
                .ReturnsAsync((AppUser)null);

            var result = await _controller.ApproveTransfer(new ActivityTransferApprovalRequest());

            Assert.NotNull(result);
            var unauthorizedResult = result as UnauthorizedObjectResult;
            Assert.NotNull(unauthorizedResult);
            Assert.AreEqual(401, unauthorizedResult.StatusCode);
            Assert.AreEqual("No AD User Found.", unauthorizedResult.Value);
        }

        [Test]
        public async Task ApproveTransfer_NotFoundException()
        {
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                .Returns(new ApplicationUser { Email = "user@landmarkcu.com" });
            _mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "user@landmarkcu.com")))
                .ReturnsAsync(new AppUser());
            _mockActivityService
                .Setup(mock => mock.ApproveTransfer(It.IsAny<AppUser>(), It.IsAny<ActivityTransferApprovalRequest>()))
                .ThrowsAsync(new NotFoundException(""));

            var result = await _controller.ApproveTransfer(new ActivityTransferApprovalRequest());

            Assert.NotNull(result);
            var badRequestResult = result as BadRequestObjectResult;
            Assert.NotNull(badRequestResult);
            Assert.AreEqual(400, badRequestResult.StatusCode);
            Assert.AreEqual("Activity Transfer Not Found.", badRequestResult.Value);
        }

        [Test]
        public async Task ApproveTransfer_BadActivityTransferActionException()
        {
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                .Returns(new ApplicationUser { Email = "user@landmarkcu.com" });
            _mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "user@landmarkcu.com")))
                .ReturnsAsync(new AppUser());
            _mockActivityService
                .Setup(mock => mock.ApproveTransfer(It.IsAny<AppUser>(), It.IsAny<ActivityTransferApprovalRequest>()))
                .ThrowsAsync(new BadActivityTransferActionException("Cannot complete request."));

            var result = await _controller.ApproveTransfer(new ActivityTransferApprovalRequest());

            Assert.NotNull(result);
            var badRequestResult = result as BadRequestObjectResult;
            Assert.NotNull(badRequestResult);
            Assert.AreEqual(400, badRequestResult.StatusCode);
            Assert.AreEqual("Cannot complete request.", badRequestResult.Value);
        }

        [Test]
        public async Task ApproveTransfer_Exception()
        {
            _mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
                            .Returns(new ApplicationUser { Email = "user@landmarkcu.com" });
            _mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "user@landmarkcu.com")))
                .ReturnsAsync(new AppUser());
            _mockActivityService
                .Setup(mock => mock.ApproveTransfer(It.IsAny<AppUser>(), It.IsAny<ActivityTransferApprovalRequest>()))
                .ThrowsAsync(new Exception("Internal Server Error."));

            var result = await _controller.ApproveTransfer(new ActivityTransferApprovalRequest());

            Assert.NotNull(result);
            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);
        }

        [Test]
        public async Task GetTransferAction_Ok()
        {
            var actionFromService = new ActivityTransferAction
            {
                Id = 1,
                State = ActivityTransferState.Requested
            };
            _mockActivityService.Setup(mock => mock.GetRequestedTransfer(1))
                .ReturnsAsync(actionFromService);

            var result = await _controller.GetTransferAction(1);

            Assert.NotNull(result);
            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);
        }

        [Test]
        public async Task GetTransferAction_Exception()
        {
            _mockActivityService.Setup(mock => mock.GetRequestedTransfer(1))
                .ThrowsAsync(new Exception("Internal Server Error."));

            var result = await _controller.GetTransferAction(1);

            Assert.NotNull(result);
            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);
        }
    }
}