using HH.WCS.HangYang.dispatch;
using HH.WCS.HangYang.process;
using HH.WCS.HangYang.util;
using HH.WCS.HangYang.wms;
using System;
using System.Collections.Generic;
using System.Linq;
using static HH.WCS.HangYang.api.ApiModel;

namespace HH.WCS.HangYang.core
{
    internal class WCSCore
    {
        public static void OperateAgvTaskStatus(AgvTaskState model)
        {
            if (model == null) return;

            var task = WCSHelper.GetTask(model.No);
            if (task == null) return;

            if (model.State > 7) return;

            // 状态与操作的映射字典
            var stateActions = new Dictionary<int, Action>
            {
                [1] = () => WCSHelper.Begin(task),
                [2] = () => HandleTaskCompletion(task),
                [3] = () => WCSHelper.UpdateStatus(task, "开始取货"),
                [4] = () => HandlePickCompletion(task),
                [5] = () => WCSHelper.UpdateStatus(task, "开始卸货"),
                [6] = () => HandleUnloadCompletion(task),
                [7] = () => HandleTaskFailure(task)
            };

            if (stateActions.TryGetValue(model.State, out var action))
            {
                action.Invoke();
                WCSHelper.AddActionRecord(model.No, model.State, model.ForkliftNo, model.ExtData);
            }
        }

        // 处理任务完成逻辑
        private static void HandleTaskCompletion(WCSTask task)
        {
            WCSHelper.End(task);

            // 根据任务类型处理不同的完成逻辑
            if (Settings.CompleteTasks.taskType.Contains(task.S_TYPE))
            {
                WMSHelper.UpdateWmsTask(task, 2);
                WMSHelper.UpdateDistributionCntrState(2, 3, task.S_CNTR_CODE);
            }

            if (new List<string> { "料箱入库", "托盘入库" }.Contains(task.S_TYPE))
            {
                ContainerHelper.UpdateCntrItem(task.S_CNTR_CODE);
            }

            // 处理区域变更
            HandleAreaChange(task);
        }

        // 处理取货完成逻辑
        private static void HandlePickCompletion(WCSTask task)
        {
            WCSHelper.UpdateStatus(task, "取货完成");
            TaskProcess.OperateStatus(task, 4);
        }

        // 处理卸货完成逻辑
        private static void HandleUnloadCompletion(WCSTask task)
        {
            WCSHelper.UpdateStatus(task, "卸货完成");
            TaskProcess.OperateStatus(task, 6);
        }

        // 处理任务失败逻辑
        private static void HandleTaskFailure(WCSTask task)
        {
            TaskProcess.OperateStatus(task, 7);
            WCSHelper.Fail(task);
        }

        // 处理区域变更逻辑
        private static void HandleAreaChange(WCSTask task)
        {
            var areas = new List<string> { "TPLKQ", "LXLKQ" };
            var area = new List<string> { "配盘出库", "配盘缓存" };

            if (areas.Contains(task.S_START_AREA) && !area.Contains(task.S_TYPE))
            {
                WMSHelper.DeleteChange(task);
            }

            if (areas.Contains(task.S_END_AREA))
            {
                WMSHelper.AddChange(task);
            }
        }



        /// <summary>
        /// 任务分发，根据调度类型发给不同的调度系统
        /// </summary>
        internal static void Dispatch()
        {
            //查询任务
            //获取所有等待的任务
            var list = WCSHelper.GetTaskListByState("等待"); ;
            if (list.Count > 0)
            {
                list.ForEach(task =>
                {
                    //使用自定义任务推送
                    TaskProcess.SendGZTask(task);
                });
            }
        }


        #region 杭氧任务服务
        private static readonly object _jobLock = new object();
        /// <summary>
        /// 循环作业生成任务
        /// </summary>
        internal static void ExecuteJob()
        {
            try
            {
                lock (_jobLock)
                {
                    //查询任务
                    //获取所有等待的作业
                    var list = WMSHelper.GetWmsTaskListByState("等待");
                    if (list.Count > 0)
                    {
                        list.ForEach(async task =>
                        {
                            //生成入库任务
                            await TaskProcess.CreateInTask(task);
                        });
                    }
                    //查询任务
                    //获取所有执行的作业
                    var exelist = WMSHelper.GetWmsTaskListByState("执行");
                    if (exelist.Count > 0)
                    {
                        exelist.ForEach(task =>
                        {
                            //生成从分拣暂存区到集货托盘位的任务任务
                            TaskProcess.exeCreateInTask(task);
                        });
                    }
                }
                    
            }
            catch (Exception ex)
            {
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"CreateInTask获取作业创建入库任务出现错误！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
            }

        }


        /// <summary>
        /// 循环接驳位生成入库任务
        /// </summary>
        private static readonly object _inventoryLock = new object();
        internal static void ProcessZoneInventoryCycle()
        {
            try
            {
                lock (_inventoryLock)  // 加锁确保同一时间只有一个线程执行
                {
                    //循环入库暂存区生成合托或入库任务
                    TaskProcess.BatchInWork();
                }
            }
            catch (Exception ex)
            {
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"循环接驳位生成入库任务！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
            }

        }

        /// <summary>
        /// 根据配盘单生成出库任务
        /// </summary>
        internal static void GenerateFromPicking()
        {
            try
            {
                lock (_jobLock)
                {
                    //查询已配盘的配盘单
                    var list = WMSHelper.GetPickingListByState(1);
                    if (list.Count > 0)
                    {
                        TaskProcess.GenerateFromPicking(list);
                    }
                }
                    
            }
            catch (Exception ex)
            {
                var st = new System.Diagnostics.StackTrace(ex, true);
                var frame = st.GetFrame(0); // 获取第一个堆栈帧
                if (frame != null)
                {
                    LogHelper.Error($"根据配盘单生成出库任务！！", ex);
                    LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
                    LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
                    LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
                }
            }
        }
        #endregion
    }
}