using Microsoft.Extensions.Logging;
using Moq;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.Service;
using WIDESEAWCS_Tasks;

namespace WIDESEAWCS_Tests;

public class StackerCraneTaskSelectorTests
{
    [Fact]
    public void SelectTask_ShouldCallTransferCheck_ForOutboundTask_AndReturnRelocationTask()
    {
        var taskService = new Mock<ITaskService>();
        var routerService = new Mock<IRouterService>();
        var stackerCrane = new Mock<IStackerCrane>();

        stackerCrane.SetupGet(x => x.DeviceCode).Returns("SC01");
        stackerCrane.SetupGet(x => x.LastTaskType).Returns((int?)null);

        var outboundTask = new Dt_Task
        {
            TaskNum = 1001,
            TaskType = (int)TaskOutboundTypeEnum.Outbound,
            Roadway = "SC01",
            NextAddress = "OUT-01"
        };

        var relocationTask = new Dt_Task
        {
            TaskNum = 2001,
            TaskType = (int)TaskRelocationTypeEnum.Relocation,
            Roadway = "SC01",
            NextAddress = "R-01"
        };

        taskService
            .Setup(x => x.QueryStackerCraneTask("SC01", ""))
            .Returns(outboundTask);
        taskService.Setup(x => x.QueryByTaskNum(2001)).Returns((Dt_Task?)null);
        taskService.Setup(x => x.AddData(It.IsAny<Dt_Task>())).Returns(WebResponseContent.Instance.OK());

        var transferCheckCalledCount = 0;
        var mockLogger = new Mock<ILogger>();
        var selector = new StackerCraneTaskSelector(
            taskService.Object,
            routerService.Object,
            taskNum =>
            {
                transferCheckCalledCount++;
                Assert.Equal(1001, taskNum);
                return relocationTask;
            },
            mockLogger.Object);

        var selectedTask = selector.SelectTask(stackerCrane.Object);

        Assert.NotNull(selectedTask);
        Assert.Equal(relocationTask.TaskNum, selectedTask!.TaskNum);
        Assert.Equal(1, transferCheckCalledCount);
        taskService.Verify(x => x.AddData(It.Is<Dt_Task>(t => t.TaskNum == 2001)), Times.Once);
    }

    [Fact]
    public void SelectTask_ShouldAddTaskToTable_WhenTransferCheckReturnsNewOutboundTask()
    {
        var taskService = new Mock<ITaskService>();
        var routerService = new Mock<IRouterService>();
        var stackerCrane = new Mock<IStackerCrane>();

        stackerCrane.SetupGet(x => x.DeviceCode).Returns("SC01");
        stackerCrane.SetupGet(x => x.LastTaskType).Returns((int?)null);

        var outboundTask = new Dt_Task
        {
            TaskNum = 1101,
            TaskType = (int)TaskOutboundTypeEnum.Outbound,
            Roadway = "SC01",
            NextAddress = "OUT-01"
        };

        var newOutboundTask = new Dt_Task
        {
            TaskNum = 2101,
            TaskType = (int)TaskOutboundTypeEnum.Outbound,
            Roadway = "SC01",
            NextAddress = "OUT-02"
        };

        taskService.Setup(x => x.QueryStackerCraneTask("SC01", "")).Returns(outboundTask);
        taskService.Setup(x => x.QueryByTaskNum(2101)).Returns((Dt_Task?)null);
        taskService.Setup(x => x.AddData(It.IsAny<Dt_Task>())).Returns(WebResponseContent.Instance.OK());
        taskService
            .Setup(x => x.UpdateTaskExceptionMessage(It.IsAny<int>(), It.IsAny<string>()))
            .Returns(WebResponseContent.Instance.OK());
        taskService.Setup(x => x.QueryStackerCraneOutTasks("SC01", It.IsAny<List<string>>())).Returns(new List<Dt_Task>());
        taskService.Setup(x => x.QueryStackerCraneInTask("SC01", "")).Returns((Dt_Task?)null);

        routerService
            .Setup(x => x.QueryNextRoute("SC01", "OUT-02", (int)TaskOutboundTypeEnum.Outbound))
            .Returns((WIDESEAWCS_QuartzJob.Models.Dt_Router?)null);
        routerService
            .Setup(x => x.QueryNextRoutes("SC01", "OUT-01", (int)TaskOutboundTypeEnum.Outbound))
            .Returns(new List<WIDESEAWCS_QuartzJob.Models.Dt_Router>());

        var mockLogger = new Mock<ILogger>();
        var selector = new StackerCraneTaskSelector(
            taskService.Object,
            routerService.Object,
            _ => newOutboundTask,
            mockLogger.Object);

        _ = selector.SelectTask(stackerCrane.Object);

        taskService.Verify(x => x.AddData(It.Is<Dt_Task>(t => t.TaskNum == 2101)), Times.Once);
    }
}