using Moq;
using NUnit.Framework;
using LCU.API.Internal.Operations.IncentiveApi.Services;
using LCU.API.Internal.Operations.IncentiveApi.Services.AutoDecision;
using LCU.API.Internal.Operations.IncentiveApi.Services.ExternalActivity;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.API.Internal.Operations.IncentiveApi.Models.ExternalActivities;
using LCU.API.Internal.Operations.IncentiveApi.Exceptions;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using System.Collections.Generic;
using System;
using System.Threading.Tasks;

namespace Application.UnitTests.Services
{
    public class DnaActivitySyncServiceTest
    {
        private Mock<IActivityService> _mockActivityService;
        private Mock<IActivityDecisionService> _mockActivityDecisionService;
        private Mock<IExternalActivityService> _mockExternalActivityservice;
        private Mock<IProcessorHistoryService> _mockProcessorHistoryService;
        private DnaActivitySyncService _dnaSyncService;
        private Mock<IDeadActivityService> _mockDeadActivityService;

    //    [SetUp]
    //    public void Setup()
    //    {
    //        _mockActivityService = new Mock<IActivityService>();
    //        _mockActivityDecisionService = new Mock<IActivityDecisionService>();
    //        _mockProcessorHistoryService = new Mock<IProcessorHistoryService>();
    //        _mockExternalActivityservice = new Mock<IExternalActivityService>();
    //        _mockDeadActivityService = new Mock<IDeadActivityService>();

    //        _dnaSyncService = new DnaActivitySyncService(
    //            _mockActivityService.Object,
    //            _mockProcessorHistoryService.Object,
    //            _mockActivityDecisionService.Object,
    //            _mockDeadActivityService.Object,
    //            _mockExternalActivityservice.Object);
    //    }

    //    [Test]
    //    public async Task HandleIncomingActivityDecision_SaveDeadActivity_OK()
    //    {
    //        _mockActivityService.Setup(x => x.SaveActivityAsync(It.IsAny<Activity>()))
    //           .ThrowsAsync(new DeadActivityException("Missing Employee ID"));

    //        _mockDeadActivityService.Setup(x => x.SaveDeadActivity(It.IsAny<DeadActivity>()))
    //            .ReturnsAsync(new DeadActivity("6", SystemType.Dna, DeadActivityReason.Other, "Test") { Id = 5 });

    //        var testActivity = new Activity()
    //        {
    //            SourceId = "10",
    //            Detail = new ActivityDetail()
    //            {
    //                AccountNumber = "12345"
    //            },
    //            EmployeeId = null,
    //            DepartmentId = -1,
    //            EmployeeEmail = "Test@test.com"
    //        };

    //        await _dnaSyncService.HandleIncomingActivityDecision(testActivity, Product.NewChecking, ActivityType.Sale);

    //        _mockDeadActivityService.Verify(x => x.SaveDeadActivity(It.Is<DeadActivity>(x =>
    //            x.Reason == DeadActivityReason.MissingRequiredField &&
    //            x.ReasonNote == "Missing Employee ID" &&
    //            x.SourceId == "10" &&
    //            x.DeadDetail.AccountNumber == "12345" &&
    //            x.EmployeeId == null &&
    //            x.DepartmentId == null &&
    //            x.EmployeeEmail == "Test@test.com"
    //        )), Times.Once);
    //    }

    //    [Test]
    //    public async Task HandleMapExternalActivities_OK()
    //    {

    //        var activities =
    //            new List<IExternalActivity>()
    //            {
    //                new NewLoanSaleActivity()
    //                {
    //                    ActivityNbr = 5,
    //                    MinorAccountType = "DV01"
    //                },
    //                new NewLoanSaleActivity()
    //                {
    //                    ActivityNbr = 6,
    //                    MinorAccountType = "DV01"
    //                },
    //                new NewLoanSaleActivity()
    //                {
    //                    ActivityNbr = 7,
    //                    MinorAccountType = "DV01"
    //                }
    //            };

    //        var result = await _dnaSyncService.HandleMapExternalActivities(activities, Product.Vehicle, ActivityType.Sale);

    //        Assert.NotNull(result);
    //    }

    //    [Test]
    //    public async Task UpdateProcessorHistory_Ok()
    //    {
    //        var testProcess = new ProcessorHistoryRecord()
    //        {
    //            Process = Process.ImportAtmCheckCardSalesFromDna,
    //            LastProcessedRecordId = 200,
    //            LastProcessedRecordTimestamp = DateTime.Parse("2021-07-10"),
    //            LastSuccessfulRunTime = DateTime.Parse("2021-07-10")
    //        };

    //        _mockProcessorHistoryService.Setup(x => x.GetProcessorHistory(It.IsAny<Process>())).ReturnsAsync(testProcess).Verifiable();

    //        await _dnaSyncService.UpdateProcessorHistory(Process.ImportAtmCheckCardSalesFromDna, 200, DateTime.Parse("2021-07-10"));

    //        _mockProcessorHistoryService.Verify(mock => mock.SaveProcessorHistory(It.IsAny<ProcessorHistoryRecord>()), Times.Once);
    //    }

    //    [Test]
    //    public async Task RunLatestDnaActivitySales_No_New_Activities()
    //    {
    //        _mockProcessorHistoryService.Setup(x => x.GetProcessorHistory(It.IsAny<Process>())).ReturnsAsync(
    //            new ProcessorHistoryRecord()
    //            {
    //                Process = Process.ImportAtmCheckCardSalesFromDna,
    //                LastProcessedRecordId = 200,
    //                LastProcessedRecordTimestamp = DateTime.Parse("2021-07-10"),
    //                LastSuccessfulRunTime = DateTime.Parse("2021-07-10")
    //            }).Verifiable();

    //        _mockActivityService.Setup(
    //            x => x.FilterExternalActivitiesByExistingSourceId(It.IsAny<List<IExternalActivity>>())).ReturnsAsync(new List<IExternalActivity>() { });

    //        var result = await _dnaSyncService.GetLastActivityProcessedData(Process.ImportAtmCheckCardSalesFromDna);
    //        Assert.NotNull(result);

    //        _mockProcessorHistoryService.Verify(x => x.GetProcessorHistory(It.Is<Process>(process => process == Process.ImportAtmCheckCardSalesFromDna)), Times.Once);
    //        _mockProcessorHistoryService.Verify(x => x.GetProcessorHistory(It.IsAny<Process>()), Times.Once);
    //        _mockProcessorHistoryService.Verify(mock => mock.SaveProcessorHistory(It.IsAny<ProcessorHistoryRecord>()), Times.Never);
    //    }
    }
}