namespace WIDESEA_StorageOutTaskServices;

public class Dt_TaskService : ServiceBase<Dt_Task, IDt_TaskRepository>, IDt_TaskService
{
    private readonly IUnitOfWorkManage _unitOfWorkManage;
    private readonly IDt_OutOrderService _outOrderService;
    private readonly IDt_BillGroupStockService _BillGroupStockService;
    private readonly IDt_Task_HtyService _Task_HtyService;
    private readonly IDt_OutOrderAndStockRepository _OutOrderAndStockRepository;
    private readonly IDt_OutOrderAndStock_HtyService _OutOrderAndStock_HtyService;
    private readonly IMapper _mapper;

    public Dt_TaskService(IDt_TaskRepository BaseDal,
                                IUnitOfWorkManage unitOfWorkManage,
                                IDt_OutOrderService outOrderService,
                                IDt_BillGroupStockService billGroupStockService,
                                IDt_OutOrderAndStockRepository dt_OutOrderAndStockRepository,
                                IDt_OutOrderAndStock_HtyService dt_OutOrderAndStock_HtyService,
                                IDt_Task_HtyService task_HtyService,
                                IMapper mapper) : base(BaseDal)
    {
        _unitOfWorkManage = unitOfWorkManage;
        _outOrderService = outOrderService;
        _BillGroupStockService = billGroupStockService;
        _OutOrderAndStockRepository = dt_OutOrderAndStockRepository;
        _OutOrderAndStock_HtyService = dt_OutOrderAndStock_HtyService;
        _Task_HtyService = task_HtyService;
        _mapper = mapper;
    }

    #region 外部接口方法

    /// <summary>
    /// 堆垛机任务完成
    /// </summary>
    /// <param name="saveModel">任务数据合集</param>
    /// <returns>返回结果集</returns>
    public async Task<WebResponseContent> CompleteStackTaskAsync(SaveModel saveModel)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            // 提取并验证主数据
            var barCode = saveModel.MainData.GetValueOrDefault("barCode")?.ToString();
            var taskNum = saveModel.MainData.GetValueOrDefault("taskNum")?.ObjToInt() ?? 0;
            var target = saveModel.MainData.GetValueOrDefault("target")?.ToString();

            // 获取任务和库存信息
            var task = await GetByTaskNum(taskNum);
            if (task == null)
            {
                return content.Error("任务不存在");
            }

            var stock = await _BillGroupStockService.GetStocks(palletCode: barCode);
            if (stock == null)
            {
                return content.Error("库存不存在");
            }

            // 更新库存状态
            stock.LocationCode = null;
            stock.LocationInfo.Status = LocationStateConst.LocationState_Empty;

            // 更新任务状态
            task.TaskState = TaskStateConst.StackerCompleted.ToString();
            task.CurrentAddress = task.NextAddress;
            task.NextAddress = target;
            task.TargetAddress = target;

            // 事务处理
            _unitOfWorkManage.BeginTran();
            var isStockUpdated = _BillGroupStockService.UpdateNavStock(stock);
            var isTaskUpdated = await Update(task);

            if (isStockUpdated && isTaskUpdated)
            {
                _unitOfWorkManage.CommitTran();
                return content.OK("任务完成成功");
            }
            else
            {
                _unitOfWorkManage.RollbackTran();
                return content.Error("任务或库存更新失败");
            }
        }
        catch (Exception err)
        {
            Console.WriteLine(err.Message);
            return content.Error(err.Message);
        }
    }

    /// <summary>
    /// 出库任务完成
    /// </summary>
    /// <param name="saveModel">任务数据合集</param>
    /// <returns>返回结果集</returns>
    public async Task<WebResponseContent> CompleteTaskAsync(SaveModel saveModel)
    {
        WebResponseContent content = new WebResponseContent();

        try
        {
            // 提取任务数据
            var barCode = saveModel.MainData.GetValueOrDefault("barCode")?.ToString();
            var taskNum = saveModel.MainData.GetValueOrDefault("taskNum")?.ObjToInt() ?? 0;

            // 验证任务是否存在
            var task = await GetByTaskNum(taskNum);
            if (task == null)
            {
                return content.Error("任务不存在");
            }

            // 验证库存是否存在
            var stock = await _BillGroupStockService.GetStocks(palletCode: barCode);
            if (stock == null)
            {
                return content.Error("库存不存在");
            }

            // 更新出库订单和库存信息
            var orderStock = await UpdateOrderAndStockAsync(stock, barCode);

            // 检查订单是否完成并处理后续操作
            if (IsOrderComplete(orderStock))
            {
                // 处理已完成订单
                await ProcessCompletedOrderAsync(orderStock, task);
            }
            else
            {
                // 处理未完成订单
                await ProcessUpdateOrderAsync(orderStock, task);
            }

            content.OK("任务完成");
        }
        catch (Exception err)
        {
            // 记录异常信息
            Console.WriteLine(err.Message.ToString());
            content.Error("任务完成失败");
        }

        return content;
    }

    #endregion 外部接口方法

    #region 内部调用方法

    /// <summary>
    /// 创建一个新的任务
    /// </summary>
    /// <param name="model">任务模型</param>
    /// <returns>创建的任务</returns>
    public async Task<Dt_Task> Create(Dt_Task model)
    {
        return await BaseDal.Create(model);
    }

    /// <summary>
    /// 批量创建任务
    /// </summary>
    /// <param name="models">任务模型列表</param>
    /// <returns>是否创建成功</returns>
    public async Task<bool> Create(List<Dt_Task> models)
    {
        return await BaseDal.Create(models);
    }

    /// <summary>
    /// 删除一个任务
    /// </summary>
    /// <param name="id">任务ID</param>
    /// <returns>是否删除成功</returns>
    public async Task<bool> Delete(int id)
    {
        return await BaseDal.Delete(id);
    }

    /// <summary>
    /// 批量删除任务
    /// </summary>
    /// <param name="ids">任务ID列表</param>
    /// <returns>是否删除成功</returns>
    public async Task<bool> Delete(List<int> ids)
    {
        return await BaseDal.Delete(ids);
    }

    /// <summary>
    /// 通过ID获取任务
    /// </summary>
    /// <param name="id">任务ID</param>
    /// <returns>任务模型</returns>
    public async Task<Dt_Task> GetById(int id)
    {
        return await BaseDal.GetById(id);
    }

    /// <summary>
    /// 获取所有任务列表
    /// </summary>
    /// <returns>任务模型列表</returns>
    public async Task<List<Dt_Task>> GetList()
    {
        return await BaseDal.GetList();
    }

    /// <summary>
    /// 根据出库订单ID获取任务列表
    /// </summary>
    /// <param name="outOrderId">出库订单ID</param>
    /// <returns>任务模型列表</returns>
    public async Task<List<Dt_Task>> GetListByOutOrder(int outOrderId)
    {
        return await BaseDal.GetListByOutOrder(outOrderId);
    }

    /// <summary>
    /// 根据出库订单ID和状态获取任务列表
    /// </summary>
    /// <param name="outOrderId">出库订单ID</param>
    /// <param name="status">任务状态</param>
    /// <returns>任务模型列表</returns>
    public async Task<List<Dt_Task>> GetListByOutOrderAndStatus(int outOrderId, int status)
    {
        return await BaseDal.GetListByOutOrderAndStatus(outOrderId, status);
    }

    /// <summary>
    /// 根据状态获取任务列表
    /// </summary>
    /// <param name="status">任务状态</param>
    /// <returns>任务模型列表</returns>
    public async Task<List<Dt_Task>> GetListByStatus(int status)
    {
        return await BaseDal.GetListByStatus(status);
    }

    /// <summary>
    /// 更新一个任务
    /// </summary>
    /// <param name="model">任务模型</param>
    /// <returns>是否更新成功</returns>
    public async Task<bool> Update(Dt_Task model)
    {
        return await BaseDal.Update(model);
    }

    /// <summary>
    /// 批量更新任务
    /// </summary>
    /// <param name="models">任务模型列表</param>
    /// <returns>是否更新成功</returns>
    public async Task<bool> Update(List<Dt_Task> models)
    {
        return await BaseDal.Update(models);
    }

    /// <summary>
    /// 检查任务是否存在
    /// </summary>
    /// <param name="palletCode">托盘编码</param>
    /// <returns>任务是否存在</returns>
    public bool IsExist(string palletCode)
    {
        return Db.Queryable<Dt_Task>().Any(x => x.PalletCode == palletCode);
    }

    /// <summary>
    /// 根据货位ID获取任务
    /// </summary>
    /// <param name="locationID"></param>
    /// <returns></returns>
    public async Task<Dt_Task> GetByLocation(string locationID)
    {
        return await Db.Queryable<Dt_Task>().Where(x => x.SourceAddress == locationID).FirstAsync();
    }

    /// <summary>
    /// 根据任务号获取任务
    /// </summary>
    /// <param name="taskNum"></param>
    /// <returns></returns>
    public async Task<Dt_Task> GetByTaskNum(int taskNum)
    {
        return await Db.Queryable<Dt_Task>().Where(x => x.TaskNum == taskNum).FirstAsync();
    }

    #endregion 内部调用方法

    #region private 内部方法

    /// <summary>
    /// 更新出库订单和库存信息
    /// </summary>
    /// <param name="stock">库存实例</param>
    /// <param name="barCode">条码</param>
    /// <returns>更新后的订单和库存信息</returns>
    private async Task<Dt_OutOrderAndStock> UpdateOrderAndStockAsync(Dt_BillGroupStock stock, string barCode)
    {
        var orderStock = await _OutOrderAndStockRepository.GetOrderAndStock(palletCode: barCode);

        orderStock.CompletedQuantity += stock.StockDetailList.PalletQuantity.Value;
        orderStock.OrderDetailList.CompletedQuantity += stock.StockDetailList.PalletQuantity.Value;

        return orderStock;
    }

    /// <summary>
    /// 判断订单是否完成
    /// </summary>
    /// <param name="orderStock">订单和库存信息</param>
    /// <returns>是否完成</returns>
    private bool IsOrderComplete(Dt_OutOrderAndStock orderStock)
    {
        return orderStock.CompletedQuantity == orderStock.OutboundQuantity;
    }

    /// <summary>
    /// 处理已完成的订单
    /// </summary>
    /// <param name="orderStock">订单和库存信息</param>
    /// <param name="task">任务数据</param>
    /// <returns>异步任务</returns>
    private async Task ProcessCompletedOrderAsync(Dt_OutOrderAndStock orderStock, Dt_Task task)
    {
        // 创建历史订单记录
        var stockHty = CreateHistoricalOrder(orderStock);

        // 创建获取历史任务
        var taskHty = CreateHistoricalTask(task);

        _unitOfWorkManage.BeginTran();

        try
        {
            // 添加历史任务
            var isTaskHtyAdd = _Task_HtyService.InsertTask(taskHty);

            // 删除任务数据
            var isTaskDelete = await Delete(task.TaskId);

            // 插入历史订单
            var isStockInsert = _OutOrderAndStock_HtyService.InsertNav(stockHty);

            // 删除原订单
            var isOrderStockDelete = _OutOrderAndStockRepository.DeleteNavOrderStock(orderStock);

            if (isStockInsert && isOrderStockDelete && isTaskHtyAdd && isTaskDelete)
            {
                _unitOfWorkManage.CommitTran();
            }
            else
            {
                _unitOfWorkManage.RollbackTran();
            }
        }
        catch
        {
            _unitOfWorkManage.RollbackTran();
            throw; // 重新抛出异常以供外部捕获
        }
    }

    /// <summary>
    /// 处理未完成订单
    /// </summary>
    /// <param name="orderStock">订单和库存信息</param>
    /// <param name="task">任务数据</param>
    /// <returns>异步任务</returns>
    private async Task ProcessUpdateOrderAsync(Dt_OutOrderAndStock orderStock, Dt_Task task)
    {
        // 创建获取历史任务
        var taskHty = CreateHistoricalTask(task);

        _unitOfWorkManage.BeginTran();
        try
        {
            // 添加历史任务
            var isTaskHtyAdd = _Task_HtyService.InsertTask(taskHty);

            // 删除任务数据
            var isTaskDelete = await Delete(task.TaskId);

            // 更新订单与库存
            var isOrderUpdated = _OutOrderAndStockRepository.UpdateNavOrderStock(orderStock);
            if (isTaskDelete && isTaskHtyAdd && isOrderUpdated)
            {
                _unitOfWorkManage.CommitTran();
            }
            else
            {
                _unitOfWorkManage.RollbackTran();
            }
        }
        catch (Exception err)
        {
            Console.WriteLine(err.Message.ToString());
            _unitOfWorkManage.RollbackTran();
            throw; // 重新抛出异常以供外部捕获
        }
    }

    /// <summary>
    /// 创建历史订单记录
    /// </summary>
    /// <param name="orderStock">订单和库存信息</param>
    /// <returns>历史订单记录</returns>
    private Dt_OutOrderAndStock_Hty CreateHistoricalOrder(Dt_OutOrderAndStock orderStock)
    {
        var stockHty = _mapper.Map<Dt_OutOrderAndStock_Hty>(orderStock);

        stockHty.StockDetailList.FinishTime = DateTime.Now;
        stockHty.StockDetailList.OperateType = "Finish";
        stockHty.StockDetailList.SourceId = orderStock.StockDetailList.GroupDetailId;
        stockHty.StockDetailList.GroupDetailId = 0;

        stockHty.StockList.FinishTime = DateTime.Now;
        stockHty.StockList.OperateType = "Finish";
        stockHty.StockList.SourceId = orderStock.StockList.GroupId;
        stockHty.StockList.GroupId = 0;

        stockHty.OrderDetailList.FinishTime = DateTime.Now;
        stockHty.OrderDetailList.OperateType = "Finish";
        stockHty.OrderDetailList.SourceId = orderStock.OrderDetailList.Id;
        stockHty.OrderDetailList.Id = 0;

        stockHty.OrderList.FinishTime = DateTime.Now;
        stockHty.OrderList.OperateType = "Finish";
        stockHty.OrderList.SourceId = orderStock.OrderList.Id;
        stockHty.OrderList.Id = 0;

        return stockHty;
    }

    private Dt_Task_Hty CreateHistoricalTask(Dt_Task task)
    {
        // 更新任务状态
        task.TaskState = TaskStateConst.TaskCompleted.ToString();
        task.CurrentAddress = task.NextAddress;

        // 创建历史任务
        var taskHty = _mapper.Map<Dt_Task_Hty>(task);
        taskHty.FinishTime = DateTime.Now;
        taskHty.OperateType = "Finish";
        taskHty.SourceId = task.TaskId;
        taskHty.TaskState = TaskStateConst.TaskCompleted.ToString();
        return taskHty;
    }

    #endregion private 内部方法
}