#region << 版 本 注 释 >>
/*----------------------------------------------------------------
 * 命名空间：WIDESEA_TaskInfoService
 * 创建者：胡童庆
 * 创建时间：2024/8/2 16:13:36
 * 版本：V1.0.0
 * 描述：
 *
 * ----------------------------------------------------------------
 * 修改人：
 * 修改时间：
 * 版本：V1.0.1
 * 修改说明：
 * 
 *----------------------------------------------------------------*/
#endregion << 版 本 注 释 >>

using AutoMapper;
using SqlSugar;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_DTO.Task;
using WIDESEA_IBasicService;
using WIDESEA_IInboundService;
using WIDESEA_IOutboundService;
using WIDESEA_IRecordService;
using WIDESEA_IStockService;
using WIDESEA_ITaskInfoService;
using WIDESEA_Model.Models;

namespace WIDESEA_TaskInfoService
{
    public partial class TaskService : ServiceBase<Dt_Task, IRepository<Dt_Task>>, ITaskService
    {
        private readonly IMapper _mapper;
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly IStockInfoService _stockInfoService;
        private readonly ILocationInfoService _locationInfoService;

        public IRepository<Dt_Task> Repository => BaseDal;

        private Dictionary<string, OrderByType> _taskOrderBy = new()
            {
                {nameof(Dt_Task.Grade),OrderByType.Desc },
                {nameof(Dt_Task.CreateDate),OrderByType.Asc},
            };

        public List<int> TaskTypes => typeof(TaskTypeEnum).GetEnumIndexList();

        public List<int> TaskOutboundTypes => typeof(TaskTypeEnum).GetEnumIndexList();

        public TaskService(IRepository<Dt_Task> BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, ILocationInfoService locationInfoService) : base(BaseDal)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
            _stockInfoService = stockInfoService;
            _locationInfoService = locationInfoService;
        }

        /// <summary>
        /// 创建任务（组盘入库任务、空托盘回库任务）
        /// </summary>
        /// <param name="taskDto">要创建的出库任务的详细信息。不能为null。</param>
        /// <returns>是否成功</returns>
        public async Task<WebResponseContent> CreateTaskInboundAsync(CreateTaskDto taskDto)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                if (string.IsNullOrWhiteSpace(taskDto.PalletCode) || string.IsNullOrWhiteSpace(taskDto.SourceAddress) || string.IsNullOrWhiteSpace(taskDto.TargetAddress) || string.IsNullOrWhiteSpace(taskDto.Roadway))
                {
                    return content.Error("Invalid task details.");
                }

                if (taskDto.TaskType != TaskTypeEnum.Inbound || taskDto.TaskType != TaskTypeEnum.InEmpty)
                {
                    return content.Error("Invalid task details.");
                }

                var task = new Dt_Task
                {
                    TaskNum = 0,
                    PalletCode = taskDto.PalletCode,
                    PalletType = taskDto.PalletType,
                    Roadway = taskDto.Roadway,
                    TaskType = taskDto.TaskType.GetHashCode(),
                    TaskStatus = TaskStatusEnum.New.GetHashCode(),
                    SourceAddress = taskDto.SourceAddress,
                    TargetAddress = taskDto.TargetAddress,
                    CurrentAddress = taskDto.SourceAddress,
                    NextAddress = taskDto.TargetAddress,
                    WarehouseId = taskDto.WarehouseId,
                    Grade = 1,
                    Creater = "system"
                };

                var result = await Repository.AddDataAsync(task) > 0 ? true : false;
                if (result)
                {
                    var WmstaskDto = _mapper.Map<WMSTaskDTO>(task);
                    return content.OK("任务创建成功", WmstaskDto);
                }
                else
                {
                    return content.Error("任务创建失败");
                }
            }
            catch (Exception ex)
            {
                return content.Error($"任务创建失败: {ex.Message}");
            }
        }


        /// <summary>
        /// 根据指定的任务详情异步创建新的出库任务。
        /// </summary>
        /// <param name="taskDto">要创建的出库任务的详细信息。不能为null。</param>
        /// <returns>表示异步操作的任务。任务结果包含表示已创建的出库任务的<see cref="WMSTaskDTO"/>，如果任务无法创建则为<see langword="null"/>。</returns>
        public async Task<WebResponseContent> CreateTaskOutboundAsync(CreateTaskDto taskDto)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {

                List<Dt_StockInfo>? stockResult = await _stockInfoService.GetStockInfoAsync(taskDto.WarehouseId);
                var taskList = new List<Dt_Task>();
                foreach (var item in stockResult)
                {
                    var taskInfo = new Dt_Task()
                    {
                        WarehouseId = item.WarehouseId,
                        PalletCode = item.PalletCode,
                        PalletType = item.PalletType,
                        SourceAddress = item.LocationCode,
                        TargetAddress = taskDto.TargetAddress,
                        Roadway = item.LocationDetails.RoadwayNo,
                        TaskType = TaskTypeEnum.Outbound.GetHashCode(),
                        TaskStatus = TaskStatusEnum.New.GetHashCode(),
                        Grade = 1,
                        TaskNum = 0,
                        CurrentAddress = item.LocationCode,
                        NextAddress = taskDto.TargetAddress,
                        Creater = "system",

                    };
                    taskList.Add(taskInfo);
                }

                var result = await BaseDal.AddDataAsync(taskList) > 0;
                var wmstaskDto = result ? _mapper.Map<WMSTaskDTO>(taskList) : null;
                return content.OK(result ? "任务创建成功" : "任务创建失败", wmstaskDto);
            }
            catch (Exception e)
            {
                return content.Error($"任务创建失败: {e.Message}");
            }
        }


        /// <summary>
        /// 获取可入库货位
        /// </summary>
        /// <param name="warehouseId"></param>
        /// <param name="taskType"></param>
        /// <returns></returns>
        public async Task<WebResponseContent> GetTasksLocationAsync(CreateTaskDto taskDto)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                var stockResult = await BaseDal.QueryFirstAsync(s => s.PalletCode == taskDto.PalletCode);
                if (stockResult == null) return content.Error("未找到对应的任务");


                var locationInfo = await _locationInfoService.GetLocationInfo(stockResult.Roadway);
                if (locationInfo == null) return content.Error("未找到对应的货位");

                // 更新货位信息
                locationInfo.LocationStatus = LocationStatusEnum.FreeLock.GetHashCode();

                // 跟新任务信息
                stockResult.CurrentAddress = taskDto.SourceAddress;
                stockResult.NextAddress = locationInfo.LocationCode;
                stockResult.TargetAddress = taskDto.TargetAddress;
                stockResult.TaskStatus = TaskStatusEnum.Line_Finish.GetHashCode();

                var updateResult = await BaseDal.UpdateDataAsync(stockResult);
                var locationResult = await _locationInfoService.UpdateLocationInfoAsync(locationInfo);

                return content.OK(updateResult && locationResult ? "任务更新成功" : "任务更新失败", locationInfo.LocationCode);
            }
            catch (Exception ex)
            {
                return content.Error($"获取任务失败: {ex.Message}");
            }
        }

        // 任务完成。添加库存，修改货位状态，删除任务数据，添加历史任务数据
        public async Task<WebResponseContent> FinishTaskAsync(CreateTaskDto taskDto)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                var taskResult = await BaseDal.QueryFirstAsync(s => s.PalletCode == taskDto.PalletCode);
                if (taskResult == null) return content.Error("未找到对应的任务");
                var locationResult = await _locationInfoService.GetLocationInfo(taskResult.Roadway, taskDto.PalletCode);
                if (locationResult == null) return content.Error("未找到对应的货位");

                // 添加库存信息
                var stockInfo = await _stockInfoService.GetStockInfoAsync(taskDto.PalletCode);
                stockInfo.LocationCode = locationResult.LocationCode;
                stockInfo.LocationId = locationResult.Id;
                stockInfo.OutboundDate = taskResult.Roadway.Contains("GW") ? DateTime.Now.AddHours(2) : taskResult.Roadway.Contains("CW") ? DateTime.Now.AddHours(1) : DateTime.Now.AddHours(0);

                // 修改货位状态
                locationResult.LocationStatus = LocationStatusEnum.InStock.GetHashCode();
                var updateLocationResult = await _locationInfoService.UpdateLocationInfoAsync(locationResult);
                var addStockResult = await _stockInfoService.UpdateStockAsync(stockInfo);
                if (!updateLocationResult || !addStockResult) return content.Error("任务完成失败");

                // 删除任务数据
                var deleteTaskResult = await BaseDal.DeleteDataAsync(taskResult);

                // 添加历史任务数据
                var historyTask = _mapper.Map<Dt_Task_Hty>(taskResult);
                historyTask.InsertTime = DateTime.Now;
                if (!deleteTaskResult) return content.Error("任务完成失败");
                return content.OK("任务完成");
            }
            catch (Exception ex)
            {
                return content.Error($"完成任务失败: {ex.Message}");
            }
        }
    }
}