using MapsterMapper;
using System.Diagnostics.CodeAnalysis;
using WIDESEA_Core;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.Enums;
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.Models;

namespace WIDESEAWCS_TaskInfoService;

/// <summary>
/// TaskService 任务接收相关方法
/// </summary>
public partial class TaskService
{
    /// <summary>
    /// 接收WMS任务信息
    /// </summary>
    /// <param name="taskDTOs">WMS任务对象集合</param>
    /// <returns>返回处理结果</returns>
    public WebResponseContent ReceiveWMSTask([NotNull] List<WMSTaskDTO> taskDTOs)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            List<Dt_Task> tasks = new List<Dt_Task>();
            List<Dt_Task> duplicates = new List<Dt_Task>();
            foreach (var item in taskDTOs)
            {
                Dt_Task existingTask = BaseDal.QueryFirst(x => x.TaskNum == item.TaskNum || x.PalletCode == item.PalletCode);
                if (existingTask != null)
                {
                    duplicates.Add(existingTask);
                    continue;
                }
                Dt_Task task = _mapper.Map<Dt_Task>(item);
                task.Creater = "WMS";
                content = InitializeTaskOnReceive(task, item);
                if (!content.Status)
                    return content;
                tasks.Add(task);
            }
            // TOOD: 这里注意添加错误要返回错误
            BaseDal.AddData(tasks);

            _taskExecuteDetailService.AddTaskExecuteDetail(tasks.Select(x => x.TaskNum).ToList(), "接收WMS任务");

            // 将重复任务信息也一并返回
            tasks.AddRange(duplicates);
            var result = tasks;
            content = WebResponseContent.Instance.OK("成功", result);
        }
        catch (Exception ex)
        {
            content = WebResponseContent.Instance.Error($"任务接收错误,错误信息:{ex.Message}");
        }
        return content;
    }

    /// <summary>
    /// 根据托盘号、起始地址向WMS请求任务
    /// </summary>
    /// <param name="palletCode">托盘号</param>
    /// <param name="sourceAddress">起始地址</param>
    /// <returns></returns>
    public WebResponseContent RequestWMSTask(string palletCode, string sourceAddress)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            WMSTaskDTO taskDTO = new WMSTaskDTO()
            {
                TaskNum = Convert.ToInt32(DateTime.Now.ToString("HHmmss")),
                Grade = 1,
                PalletCode = palletCode,
                Roadway = "SC01",
                SourceAddress = sourceAddress,
                TargetAddress = "SC01",
                TaskStatus = (int)TaskInStatusEnum.InNew,
                Id = 0,
                TaskType = (int)TaskInboundTypeEnum.Inbound
            };

            content = ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
        }
        catch (Exception ex)
        {
            content = WebResponseContent.Instance.Error(ex.Message);
        }
        return content;
    }

    /// <summary>
    /// 按任务分组初始化任务接收信息。
    /// </summary>
    /// <param name="task">任务实体。</param>
    /// <param name="source">WMS原始任务对象。</param>
    private WebResponseContent InitializeTaskOnReceive(Dt_Task task, WMSTaskDTO source)
    {
        switch (task.TaskType.GetTaskTypeGroup())
        {
            case TaskTypeGroup.OutbondGroup:
                return _outboundTaskFlowService.InitializeOnReceive(task, source);
            case TaskTypeGroup.InboundGroup:
                return _inboundTaskFlowService.InitializeOnReceive(task, source);
            case TaskTypeGroup.RelocationGroup:
                return _relocationTaskFlowService.InitializeOnReceive(task, source);
            case TaskTypeGroup.OtherGroup:
                return _robotTaskFlowService.InitializeOnReceive(task, source);
            default:
                return WebResponseContent.Instance.Error("WCS不存在当前任务的任务类型");
        }
    }

    /// <summary>
    /// 接收WMS手动创建的任务，创建WCS任务
    /// </summary>
    /// <param name="taskDTOs">WMS任务对象集合</param>
    /// <returns>返回处理结果</returns>
    public WebResponseContent ReceiveManualTask([NotNull] List<WMSTaskDTO> taskDTOs)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            // 收集重复任务的信息
            var duplicateTasks = new List<DuplicateTaskDto>();
            // 倒序遍历，安全删除并收集被移除的项
            for (int i = taskDTOs.Count - 1; i >= 0; i--)
            {
                var item = taskDTOs[i];
                var exists = BaseDal.QueryFirst(x => x.TaskNum == item.TaskNum || x.PalletCode == item.PalletCode);
                if (exists != null)
                {
                    duplicateTasks.Add(new DuplicateTaskDto
                    {
                        TaskNum = exists.TaskNum,
                        PalletCode = exists.PalletCode,
                        TaskType = exists.TaskType,
                        TaskStatus = exists.TaskStatus
                    });
                    taskDTOs.RemoveAt(i);
                }
            }

            // 调用 ReceiveWMSTask 创建 WCS 任务
            content = ReceiveWMSTask(taskDTOs);

            // 如果有重复任务，修改返回结果
            if (duplicateTasks.Count > 0 && content.Status)
            {
                var result = new ReceiveTaskResultDto
                {
                    Success = true,
                    Message = content.Message + $"，其中{duplicateTasks.Count}个任务在WCS中已存在",
                    CreatedCount = taskDTOs.Count,
                    DuplicateTasks = duplicateTasks
                };
                content.Data = result;
            }

            return content;
        }
        catch (Exception ex)
        {
            content = WebResponseContent.Instance.Error($"手动任务接收错误,错误信息:{ex.Message}");
            return content;
        }
    }
}