using HH.WCS.Mobox3.AnGang.Devices;
using HH.WCS.Mobox3.AnGang.Dispatch;
using HH.WCS.Mobox3.AnGang.Models;
using HH.WCS.Mobox3.AnGang.process;
using HH.WCS.Mobox3.AnGang.config;
using HH.WCS.Mobox3.AnGang.Helper;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using static HH.WCS.Mobox3.AnGang.Controllers.ApiModel;
using static HH.WCS.Mobox3.AnGang.Dtos.Response.AgvResponse;
using static HH.WCS.Mobox3.AnGang.Dtos.Request.AgvRequest;

namespace HH.WCS.Mobox3.AnGang.ServiceCore
{
    internal class WCSCore
    {
        public static ReturnResult OperateAgvTaskStatus(AgvTaskState model)
        {
            var result = new ReturnResult();
            try
            {
                switch (model.state) {
                    case 1023:
                    case 1025:

                        break;
                    case 1012:
                        break;
                    case 1004:
                        break;
                    case 1103:
                        break;
                    default:
                        // AGV 执行任务的逻辑处理
                        if (!AgvTaskProcessOk(model)) {
                            // 执行不OK，说明没有找到任务
                            result.ResultCode = 1;
                            result.ResultMsg = $"根据Model.No未找到对应的任务，{model.task_no}";
                            LogHelper.Info(result.ResultMsg, "API");
                            return result;
                        }
                        break;
                }

                result.ResultCode = 0;
                result.ResultMsg = "success";
                LogHelper.Info(result.ResultMsg, "API");
                return result;
            }
            catch(Exception ex)
            {
                result.ResultCode = -1;
                result.ResultMsg = $"发生了异常：{ex.Message}";
                LogHelper.Info(result.ResultMsg, "Error");
                return result;
            }

        }

        /// <summary>
        /// 执行AGV任务，查询不到任务返回false
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        private static bool AgvTaskProcessOk(AgvTaskState model) {
            var TN_Task = WCSHelper.GetTask(model.task_no); // 根据当前model编号查询任务
            if (TN_Task == null) { return false; }

            if (model.state > 7) {
                //安全请求等
                TaskHelper.OperateReq(model.task_no, model.state, model.forklift_no, model.ext_data);
                return true;
            }
            
            // AGV 任务 134562(7) 状态处理
            switch (model.state) {
                case 1:
                    WCSHelper.Begin(TN_Task, model.forklift_no); // 已推送的任务的状态改成执行
                    break;
                case 3:
                    WCSHelper.UpdateStatus(TN_Task, "开始取货"); // 任务状态改成开始取货
                    break;
                case 4:
                    WCSHelper.UpdateStatus(TN_Task, "取货完成"); // 任务状态改成取货完成
                    TaskHelper.OperateStatus(TN_Task, 4); // 起点容器货位解绑,解锁起点
                    break;
                case 5:
                    WCSHelper.UpdateStatus(TN_Task, "开始卸货"); // 任务状态改成开始卸货
                    break;
                case 6:
                    WCSHelper.UpdateStatus(TN_Task, "卸货完成"); // 任务状态改成卸货完成
                    TaskHelper.OperateStatus(TN_Task, 6); // 终点容器货位绑定,解锁终点
                    break;
                case 2:
                    WCSHelper.End(TN_Task); // 任务状态改成结束
                    break;
                case 7:
                    TaskHelper.OperateStatus(TN_Task, 7); // 异常处理
                    WCSHelper.Fail(TN_Task); // 任务状态改成错误
                    break;
            }

            WCSHelper.AddActionRecord(model.task_no, model.state, model.forklift_no, model.ext_data);
            //调用第三方接口（如果有）TaskProcess.ReportStatus，添加任务动作关系表

            return true;
        }

        /// <summary>
        /// 任务分发，根据调度类型发给不同的调度系统
        /// </summary>
        internal static void Dispatch()
        {
            //查询任务
            //获取所有等待的任务
            var list = WCSHelper.GetWaitingTaskList();
            LogHelper.Info("等待任务信息" + JsonConvert.SerializeObject(list), "API");
            if (list.Count > 0)
            {
                list.ForEach(task =>
                {
                    //使用自定义任务推送
                    TaskHelper.SendTask(task);//调度NDC或杭奥或国自设备
                    //TaskProcess.SendGZTask(task);///调度国自设备

                });
            }
            else
            {
                LogHelper.Info("暂无任务");
            }
        }

        

        /// <summary>
        /// 空托下线堆叠
        /// </summary>
        /// <param name="tN_Task"></param>
        //public static void EmptyInStackArea(TN_Task tN_Task)
        //{
        //    if (tN_Task.S_TYPE == "满托出库上线")
        //    {
        //        var result = new SimpleResult();
        //        var db = DbHelper.GetDbClient();
        //        try
        //        {
        //            var startLocLists = 
        //                db.Queryable<TN_Location>().Where(a => a.S_AREA_CODE == Settings.Areas[6] && a.N_CURRENT_NUM >0 && a.N_LOCK_STATE==0 && a.S_LOCK_STATE == "无").ToList();

        //            if (startLocLists.Count == 0)
        //            {
        //                LogHelper.Info($"人工托盘区暂无已绑定的空托，需要满足：货位数量大于0，未锁定的，属于库区{Settings.Areas[6]}的货位");
        //                return;
        //            }

        //            foreach (var item in startLocLists)
        //            {
        //                //查询符合的未锁定已启用指定货区的当前数量合计后最接近容量的货位，终点
        //                var endLoc = db.Queryable<TN_Location>().
        //                    Where(a => a.N_CURRENT_NUM + item.N_CURRENT_NUM <= a.N_CAPACITY && a.S_AREA_CODE == Settings.Areas[3] && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y").
        //                    OrderBy(a => a.N_CURRENT_NUM + item.N_CURRENT_NUM - a.N_CAPACITY, OrderByType.Desc).First();

        //                if (endLoc == null)
        //                {
        //                    LogHelper.Info($"未找到合适的终点，需要满足：属于{Settings.Areas[3]}的未锁定的容量充足的货位");
        //                    continue;
        //                }
        //                var locCnt = db.Queryable<TN_Loc_Container>().First(a=>a.S_LOC_CODE == item.S_CODE);

        //                if (locCnt == null)
        //                {
        //                    LogHelper.Info($"货位{item.S_CODE}未绑定容器");
        //                    continue;
        //                }

        //                //创建空托下线堆叠任务
        //                if (WCSHelper.CreateTask(item.S_CODE, endLoc.S_CODE, "空托下线堆叠", 3, locCnt.S_CNTR_CODE))//创建搬送任务，起点终点容器
        //                {
        //                    LocationHelper.LockLoc(item.S_CODE, 2);//起点出库锁，
        //                    LocationHelper.LockLoc(endLoc.S_CODE, 1);//终点入库锁

        //                    LogHelper.Info($"生成空托下线堆叠任务成功，容器号{locCnt.S_CNTR_CODE}，起点{item.S_CODE}，终点{endLoc.S_CODE}");
        //                }
        //                else
        //                {
        //                    LogHelper.Info($"生成空托下线堆叠任务失败，容器号{locCnt.S_CNTR_CODE}，起点{item.S_CODE}，终点{endLoc.S_CODE}");
        //                    continue;
        //                }
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            LogHelper.Info($"发生了异常：{ex.Message}", "Error");
        //        }
        //    }
        //}

        
    }
}