using HH.WCS.Hexafluo.util;
using HH.WCS.Hexafluo.wms;
using HH.WCS.SJML.Bll;
using HH.WCS.SJML.Dto;
using HH.WCS.SJML.Entitys;
using HH.WCS.ZCQTJ.Dto;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;

namespace HH.WCS.Hexafluo.core
{
    /// <summary>
    /// 定时轮询任务
    /// </summary>
    public class MesKtTask
    {
        private static object locko9 = new object();
        /// <summary>
        /// 检查是否有自管任务，自动子任务
        /// </summary>
        public static void MesKtTaskIssued()
        {
            try
            {
                lock (locko9)
                {
                    var chi = new SqlHelper<object>().GetInstance();
                    var newDb2 = chi.CopyNew();
                    DateTime currentTime = DateTime.Now;
                    TimeSpan fiveMinutes = TimeSpan.FromMinutes(5);
                    DateTime newTime = currentTime - fiveMinutes;
                    var transportTask1 = newDb2.Queryable<MesKtTaskDto>().Where(e => e.NeedTrig == "Y").ToList();
                    if (transportTask1.Any())
                    {

                        //超时的全部处理
                        //foreach (var item in transportTask1.ToArray())
                        //{
                        //    if (item.T_CREATE < currentTime.AddDays(-1))
                        //    {
                        //        try
                        //        {
                        //            newDb2.BeginTran();
                        //            var I = newDb2.Updateable<MesKtTaskDto>().SetColumns(it => new MesKtTaskDto()
                        //            {
                        //                NeedTrig = "N"
                        //            }).Where(x => x.S_ID == item.S_ID).ExecuteCommand();
                        //            LogHelper.DanInfo("任务下发", $"空托缓存任务{item.task_no} 超时1天没处理 系统自动处理");
                        //            newDb2.CommitTran();
                        //        }
                        //        catch (Exception ex)
                        //        {
                        //            newDb2.RollbackTran();
                        //        }
                        //    }
                        //}


                        var transportTask = transportTask1.FindAll(e => e.Task_State == "智能空桶").ToList();
                        if (transportTask.Any())
                        {
                            transportTask = transportTask.OrderBy(e => e.T_CREATE).ToList();
                            foreach (var task in transportTask)
                            {
                                var gg = task.CreateDate;
                                DateTime cfff = gg + fiveMinutes;
                                if (currentTime > cfff)
                                {
                                    BLLCreator.Create<ZCBLL>().MesKtTaskIssued(transportTask);
                                }
                            }
                        }
                        var transportTask2 = transportTask1.FindAll(e => e.Task_State == "接驳位至线边点对点").ToList();
                        if (transportTask2.Any())
                        {
                            var transportTask4 = transportTask2.GroupBy(e => e.Location_To).Select(d => d.First()).ToList();
                            transportTask4 = transportTask4.OrderBy(e => e.T_CREATE).ToList();
                            foreach (var sendTaskEntity in transportTask4)
                            {
                                LogHelper.DanInfo("MES", "接驳位至线边点对点 开始执行 任务号:" + JsonConvert.SerializeObject(sendTaskEntity.task_no));
                                var Kklock = newDb2.Queryable<FunctionEntitys>().Where(e => e.Autoindex == "空托自动出库到接驳位")?.First();
                                if (Kklock != null && Kklock.TransportLock == "Y")
                                {
                                    var Stabit = newDb2.Queryable<JbTrayNumberEntitys>().Where(e => e.S_IS_USE == "N").ToList();
                                    //去除有任务的托盘
                                    if (Stabit.Count() > 0)
                                    {
                                        var State = new List<string> { "完成", "取消" };
                                        var tasks = newDb2.Queryable<WMSTask>().Where(e => Stabit.Select(c => c.S_CNTR_CODE).ToList().Contains(e.S_CNTRS) && !State.Contains(e.S_B_STATE) && e.S_NOTE == "agv任务").ToList();
                                        if (tasks.Count() > 0)
                                        {
                                            foreach (var item in tasks)
                                            {
                                                Stabit.RemoveAll(e => e.S_CNTR_CODE == item.S_CNTRS);
                                            }
                                        }
                                    }
                                    if (Stabit.Count > 0)
                                    {
                                        var fiff = Stabit.FirstOrDefault();
                                        Stabit = Stabit.OrderBy(e => e.T_CREATE).ToList();
                                        //走点对点
                                        List<OutWorkAreaEntity> outWorkAreas = new List<OutWorkAreaEntity>
                                {
                               new OutWorkAreaEntity() {
                        taskNo=sendTaskEntity.task_no,
                        startBit = fiff.S_LOC_CODE,
                        endBit = sendTaskEntity.Location_To,
                        priority = sendTaskEntity.Priority,
                        trayCode= fiff.S_CNTR_CODE,
                        TaskOrderType = "MES点对点",
                        NoAssist = "Y",
                        S_TransAgv = "Y"
                               }
                            };
                                        var transport = newDb2.Queryable<ConfigJsonEntitys>().Where(e => e.Autoindex == "点对点任务管控")?.First();
                                        List<string> ListString = new List<string>();
                                        if (transport != null)
                                        {
                                            ListString = JsonConvert.DeserializeObject<List<string>>(transport.TypeJson);
                                        }
                                        if (ListString.Contains(sendTaskEntity.Location_To))
                                        {
                                            List<string> state = new List<string> { "完成", "取消" };
                                            var tasks = newDb2.Queryable<WMSTask>().Where(e => e.S_END_LOC == sendTaskEntity.Location_To && !(state.Contains(e.S_B_STATE))).ToList();
                                            if (tasks.Count > 0)
                                            {
                                                LogHelper.DanInfo("MES", "终点货位" + sendTaskEntity.Location_To + ",最多只能同时存在一条任务 任务" + JsonConvert.SerializeObject(tasks?.FirstOrDefault()?.S_TASK_NO));
                                                throw new Exception("终点货位" + sendTaskEntity.Location_To + ",最多只能同时存在一条任务!" + JsonConvert.SerializeObject(tasks?.FirstOrDefault()?.S_TASK_NO));
                                            }
                                        }
                                        var resulte = BLLCreator.CreateSingleton<OutWorkAreaBll>().OutWorkArea(outWorkAreas);
                                        if (resulte.Success)
                                        {
                                            try
                                            {
                                                newDb2.BeginTran();
                                                var I = newDb2.Updateable<JbTrayNumberEntitys>().SetColumns(it => new JbTrayNumberEntitys()
                                                {
                                                    S_IS_USE = "Y"
                                                }).Where(x => x.S_ID == fiff.S_ID).ExecuteCommand();
                                                I = newDb2.Updateable<MesKtTaskDto>().SetColumns(it => new MesKtTaskDto()
                                                {
                                                    NeedTrig = "N"
                                                }).Where(x => x.S_ID == sendTaskEntity.S_ID).ExecuteCommand();

                                                newDb2.CommitTran();
                                            }
                                            catch (Exception ex)
                                            {
                                                LogHelper.DanInfo("MES", "点对点任务管控" + ex.Message);
                                                newDb2.RollbackTran();
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        //胎圈出库缓存
                        var transportTask3 = transportTask1.FindAll(e => e.Task_State == "胎圈空托出库缓存").ToList();
                        if (transportTask3.Any())
                        {
                            var transportTask4 = transportTask3.GroupBy(e => e.Location_To).Select(d => d.First()).ToList();
                            foreach (var receuveTask in transportTask4)
                            {
                                MesTaskDto req = new MesTaskDto()
                                {
                                    task_no = receuveTask.task_no,
                                    Task_type = receuveTask.Task_type,
                                    TurnCardNum = receuveTask.TurnCardNum,
                                    PROD_NO = receuveTask.PROD_NO,
                                    PROD_TECH = receuveTask.PROD_TECH,
                                    PROD_SPEC = receuveTask.PROD_SPEC,
                                    PROD_BOM = receuveTask.PROD_BOM,
                                    PROD_Feature = receuveTask.PROD_Feature,
                                    TOOLS_NO = receuveTask.TOOLS_NO,
                                    ST_AMOUNT = receuveTask.ST_AMOUNT,
                                    CURRENT_AMOUNT = receuveTask.CURRENT_AMOUNT,
                                    Location_From = receuveTask.Location_From,
                                    Location_To = receuveTask.Location_To,
                                    PRODUCE_TIME = receuveTask.PRODUCE_TIME,
                                    SHELF_LIFE_TIME = receuveTask.SHELF_LIFE_TIME,
                                    EXPIRED_TIME = receuveTask.EXPIRED_TIME,
                                    SHELF_REP = receuveTask.SHELF_REP,
                                    EXPIRED_REP = receuveTask.EXPIRED_REP,
                                    CHECK_CODE = receuveTask.CHECK_CODE,
                                    CHECK_INFO = receuveTask.CHECK_INFO,
                                    Priority = receuveTask.Priority,
                                    Data_status = receuveTask.Data_status,
                                    NeedTrig = "Y",
                                    CreateDate = DateTime.Now,
                                    standardWeight = receuveTask.standardWeight,
                                    BUSI_TYPE = receuveTask.BUSI_TYPE,
                                    TOOLS_TPYE = receuveTask.TOOLS_TPYE,
                                    Givewayto = receuveTask.Task_PDA,
                                    applyProdSpecList = receuveTask.applyProdSpecList,
                                    frequency = 0
                                };
                                var resulte = BLLCreator.Create<ZCBLL>().ExecTransferTask(req);
                                if (resulte.Success)
                                {
                                    try
                                    {
                                        newDb2.BeginTran();
                                        var I = newDb2.Updateable<MesKtTaskDto>().SetColumns(it => new MesKtTaskDto()
                                        {
                                            NeedTrig = "N"
                                        }).Where(x => x.S_ID == receuveTask.S_ID).ExecuteCommand();
                                        newDb2.CommitTran();
                                    }
                                    catch (Exception ex)
                                    {
                                        LogHelper.DanInfo("MES", "点对点任务管控" + ex.Message);
                                        newDb2.RollbackTran();
                                    }
                                }
                            }
                        }

                    }
                }
            }
            catch (System.Exception ex)
            {
                LogHelper.DanInfo("MES", ex.Message);
            }
        }
    }
}