using HH.WCS.JuShi.api;
using HH.WCS.JuShi.device;
using HH.WCS.JuShi.process;
using HH.WCS.JuShi.util;
using HH.WCS.JuShi.wms;
using Newtonsoft.Json;
using NLog.Fluent;
using Opc.Ua;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using static HH.WCS.JuShi.device.S7Helper;

namespace HH.WCS.JuShi.core
{
    internal class WMSCore
    {
        /// <summary>
        /// 遍历定版的发货单，生产分拣单主表和子表（也可以手动调接口触发）
        /// </summary>
        internal static void CheckShippingOrder()
        {
            //1.0、获取已经定版的发货单，生产分拣单子表和主表，设置【发货单】的业务状态 N_B_STATE = 1（待分拣）
            //2.0、如果发货单C_AUTO_SORTING=Y，则自动将分拣单状态设置为开始配货

        }
        /// <summary>
        /// 开始配货创建分拣单明细(改成调接口触发)
        /// </summary>
        internal static void CheckSortingOrder()
        {
            //new SortingOrder().N_B_STATE
            //1.0、获取 N_B_STATE = 1 (开始配货)状态的分拣单
            //2.0、遍历分拣单子表，创建分拣单明细，更新分拣单子表的明细汇总F_ACC_S_QTY
            //3.0、全部分拣单子表的明细创建完毕，子表明细汇总和子表数量一致，更新分拣单状态，N_B_STATE = 2配货完成
            //4.0、如果分拣单是自动作业，就直接更新到 N_B_STATE = 3开始作业
            //WMSHelper.GetWaitingSortingOrderList();

        }

        /// <summary>
        /// 遍历分拣单明细创建出库作业
        /// </summary>
        internal static void CheckSortingTask()
        {
            //new SortingOrder().N_B_STATE
            //遍历N_B_STATE = 3的分拣单创建作业
            //或 遍历分拣单明细创建分拣作业，因为一个分拣单里面的明细都是批量生成的
            var list = WMSHelper.GetWaitingSortingOperationList();
            if (list.Count > 0)
            {
                list.ForEach(a =>
                {
                    if (a.Details != null)
                    {
                        WMSHelper.CreateSortingOperation(a);
                    }
                });
            }


        }

        ///// <summary>
        ///// 作业启动，创建子任务
        ///// </summary>
        //internal static void Start()
        //{

        //    List<WMSTask> list = WMSHelper.GetWaitingOperationList();
        //    if (list.Count > 0)
        //    {
        //        //如果是出库的作业锁定托盘的时候已经明确起点了，如果发货单或分拣单指定了终点，
        //        //如果没有作业、任务的顺序限制就可以启动，创建子任务了
        //        list.ForEach(a =>
        //        {
        //            if (a.N_TYPE == 1)
        //            {
        //                //入库有终点就可以执行
        //                if (string.IsNullOrEmpty(a.S_END_LOC))
        //                {
        //                    //计算终点
        //                    Location end = WMSHelper.GetEnd(a);
        //                    if (end != null)
        //                    {
        //                        a.S_END_LOC = end.S_CODE;
        //                        WMSHelper.UpdateTaskEnd(a);
        //                        LocationHelper.LockLoc(end.S_CODE, 1);
        //                    }
        //                }
        //                if (!string.IsNullOrEmpty(a.S_END_LOC))
        //                {
        //                    //创建wcs任务
        //                    var wcsTask = new WCSTask
        //                    {
        //                        S_OP_CODE = a.S_CODE,
        //                        S_OP_NAME = "入库",
        //                        S_CODE = WCSHelper.GenerateTaskNo(),
        //                        S_TYPE = "堆垛机入库",
        //                        S_START_LOC = a.S_START_LOC,
        //                        S_END_LOC = a.S_END_LOC,
        //                        S_SCHEDULE_TYPE = "杭奥",

        //                        S_CNTR_CODE = a.S_CNTR_CODE,

        //                    };
        //                    if (WCSHelper.CreateTask(wcsTask))
        //                    {
        //                        //更新作业状态为执行
        //                        a.N_B_STATE = 1;
        //                        a.S_B_STATE = "执行";
        //                        WMSHelper.UpdateTaskState(a);
        //                    }
        //                }
        //            }
        //            else if (a.N_TYPE == 2)
        //            {
        //                //出库有起点就可以执行
        //                if (string.IsNullOrEmpty(a.S_END_LOC))
        //                {
        //                    //首先获取起点的逻辑库区，找到逻辑库区的功能区
        //                    FunctionArea fa = null;
        //                    var zones = LocationHelper.GetZoneByLoc(a.S_START_LOC);
        //                    for (int i = 0; i < zones.Count; i++)
        //                    {
        //                        fa = LocationHelper.GetFunctionAreas("Zone", zones[i].S_ZONE_CODE, 11).FirstOrDefault();
        //                        if (fa != null)
        //                        {
        //                            break;
        //                        }
        //                    }
        //                    if (fa != null)
        //                    {
        //                        var loc = LocationHelper.GetLoc(fa.S_FA_CODE);
        //                        if (loc != null)
        //                        {
        //                            a.S_END_LOC = loc.S_CODE;
        //                            WMSHelper.UpdateTaskEnd(a);
        //                            LocationHelper.LockLoc(loc.S_CODE, 1);
        //                        }
        //                    }
        //                    if (!string.IsNullOrEmpty(a.S_END_LOC))
        //                    {
        //                        //创建wcs任务
        //                        var wcsTask = new WCSTask
        //                        {
        //                            S_OP_CODE = a.S_CODE,
        //                            S_OP_NAME = "出库",
        //                            S_CODE = WCSHelper.GenerateTaskNo(),
        //                            S_TYPE = "堆垛机出库",
        //                            S_START_LOC = a.S_START_LOC,
        //                            S_END_LOC = a.S_END_LOC,
        //                            S_SCHEDULE_TYPE = "杭奥",

        //                            S_CNTR_CODE = a.S_CNTR_CODE,

        //                        };
        //                        if (WCSHelper.CreateTask(wcsTask))
        //                        {
        //                            //更新作业状态为执行
        //                            a.N_B_STATE = 1;
        //                            a.S_B_STATE = "执行";
        //                            WMSHelper.UpdateTaskState(a);
        //                        }

        //                    }
        //                }
        //            }
        //        });

        //    }
        //}
        
        //监测摄像头处货位(送检入库区)空满状态 满的就叉到立库
        public static void MonitorFullStatus()
        {
            //bool result = false;
            //找送检入库区满托盘的货位
            var db = new SqlHelper<object>().GetInstance();
            try
            {
                var reservoirs = Settings.ReservoirAreas.Where(s => s.areaName == "送检入库区").FirstOrDefault();
                var reservoirs2 = Settings.ReservoirAreas.Where(s => s.areaName == "立库入库区").FirstOrDefault();
                //三表联查查出托盘满的 按创建时间顺序
                var locCntrs = db.Queryable<LocCntrRel>().LeftJoin<Container>((p, c) => p.S_CNTR_CODE == c.S_CODE)
                .Where((p, c) => c.C_FULL == "2")
                .OrderBy((p, c) => p.T_CREATE)
                .Select((p, c) => p.S_LOC_CODE) // 选择托盘物料表的数据
                .ToList();

                //找送检入库区内托盘满了的货位
                var locList = db.Queryable<Location>()
                    .Where(p => p.S_AREA_CODE == reservoirs.areaCode && p.N_LOCK_STATE == 0)
                    .Where(s => locCntrs.Contains(s.S_CODE.Trim()))
                    .ToList();

                if (locList.Any())
                {
                    LogHelper.Info($"任务摄像头监测空满状态找到货位{JsonConvert.SerializeObject(locList)}");
                    //建任务
                    var startLoc = locList.FirstOrDefault();
                    var endLoc = TaskProcess.InWorkTransport(reservoirs2.areaCode);
                    LogHelper.Info($"任务摄像头监测找到终点货位：{JsonConvert.SerializeObject(endLoc)}");
                    if (endLoc!=null)
                    {
                        var locCntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == startLoc.S_CODE).First();
                        LogHelper.Info($"任务摄像头监测找到托盘：{JsonConvert.SerializeObject(locCntrRel)}");

                        TaskProcess.CreateTransport(startLoc.S_CODE, endLoc.S_CODE, "摄像头监测", locCntrRel.S_CNTR_CODE, 1, 1);

                    }

                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("MonitorFullStatus:" + ex.Message + ex.StackTrace);
                LogHelper.Error("MonitorFullStatus:" + ex.Message, ex);
                throw;
            }


            //return result;


        }
        //常规送检空了自动从送检缓存区取一个送过去
        public static void AutoReplenish()
        {
            var db = new SqlHelper<object>().GetInstance();
            var isusinglist = db.Queryable<Isusing>().Where(a => a.S_TYPE == "自动补货").First();
            if (isusinglist.S_STATUS == 0)
            {
                return;
            }
            try
            {
                var cgreservoirs = Settings.ReservoirAreas.Where(s => s.areaName == "常规送检区").FirstOrDefault();
                //找到常规送检区没有锁且空着的货位
                var endloc = TaskProcess.InWorkTransport(cgreservoirs.areaCode);
                if (endloc != null)
                {
                    var hcreservoirs = Settings.ReservoirAreas.Where(s => s.areaName == "送检缓存区").FirstOrDefault();
                    //找送检缓存区有货的货位
                    var startloc = TaskProcess.OutWorkTransport(hcreservoirs.areaCode);
                    //LogHelper.Info($"AutoReplenish 自动补货 起点货位{JsonConvert.SerializeObject(startloc)}");
                    if (startloc != null)
                    {
                        //创建送检任务
                        var locCntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == startloc.S_CODE).First();
                        LogHelper.Info($"创建任务 起点:{startloc.S_CODE}终点:{endloc.S_CODE}", "自动补货");
                        var res = TaskProcess.CreateTransport(startloc.S_CODE, endloc.S_CODE, "自动补货", locCntrRel.S_CNTR_CODE, 1, 1);
                        if (!res)
                        {
                            LogHelper.Info($"任务 起点:{startloc.S_CODE}终点:{endloc.S_CODE}创建失败", "自动补货");
                        }
                    }

                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("AutoReplenish:" + ex.Message + ex.StackTrace);
                LogHelper.Error("AutoReplenish:" + ex.Message, ex);
                throw;
            }

        }
        //空托缓存区有绑定的托盘就送到拆托机
        public static void AutoSendMachine()
        {
            var db = new SqlHelper<object>().GetInstance();
            var isusinglist = db.Queryable<Isusing>().Where(a => a.S_TYPE == "自动送托").First();
            if (isusinglist.S_STATUS == 0)
            {
                return;
            }
            try
            {
                var reservoirs1 = Settings.ReservoirAreas.Where(s => s.areaName == "3min空托区").FirstOrDefault();
                var reservoirs2 = Settings.ReservoirAreas.Where(s => s.areaName == "6min空托区").FirstOrDefault();
                var linePlcInfo1 = Settings.linePlcInfos.Where(s => s.deviceNo == "1").FirstOrDefault();
                var linePlcInfo2 = Settings.linePlcInfos.Where(s => s.deviceNo == "2").FirstOrDefault();
                //找到空托缓存区的所有货位编号
                var locList = db.Queryable<Location>()
                    .Where(s => s.S_AREA_CODE == reservoirs1.areaCode || s.S_AREA_CODE == reservoirs2.areaCode)
                    .Where(s => s.N_LOCK_STATE == 0)
                    .OrderByDescending(s => s.N_ROW).OrderByDescending(s => s.N_COL).OrderBy(s => s.N_LAYER)
                    .Select(s => s.S_CODE)
                    .ToList();

                //找到绑了托盘的货位号
                var locCntrs = db.Queryable<LocCntrRel>()
                    .Where(s => locList.Contains(s.S_LOC_CODE.Trim()))
                    .Select(s => s.S_LOC_CODE)
                    .ToList();
                if (locCntrs.Any())
                {
                    //LogHelper.Info($"空托缓存区有绑定货位：{JsonConvert.SerializeObject(locCntrs)}");
                    //var loccode = locCntrs.First();
                    foreach (var loccode in locCntrs)
                    {
                        var loc = db.Queryable<Location>().Where(s => s.S_CODE == loccode).First();
                        //判断送往3寸还是6寸拆托机
                        string endLoc = null;
                        string dev = null;
                        if (loc.S_AREA_CODE == reservoirs1.areaCode)
                        {
                            endLoc = linePlcInfo1.inLoca;
                            dev = "1";
                        }
                        else if (loc.S_AREA_CODE == reservoirs2.areaCode)
                        {
                            endLoc = linePlcInfo2.inLoca;
                            dev = "2";
                        }
                        var endLocation = db.Queryable<Location>().Where(s => s.S_CODE == endLoc).First();
                        if (endLocation == null || endLocation.N_LOCK_STATE != 0)
                        {
                            //LogHelper.Info($"拆托机货位{endLoc}不存在或已被锁");
                            return;
                        }
                        var plcDeviceTable = S7Helper.plcDeviceTables;
                        LogHelper.Info($"自动送托 拆托机{dev}:{plcDeviceTable.requestPut1}");
                        if ((plcDeviceTable.requestPut1 && dev == "1") ||
                            (plcDeviceTable.requestPut2 && dev == "2"))
                        {
                            var locCntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == loccode).First();

                            LogHelper.Info($"创建任务 起点:{loccode}终点:{endLoc}");
                            var res = TaskProcess.CreateTransport(loccode, endLoc, "送托", locCntrRel.S_CNTR_CODE, 1, 1);
                            if (res)
                            {
                                LogHelper.Info($"起点:{loccode}终点:{endLoc}任务创建成功");
                            }
                            else
                            {
                                LogHelper.Info($"起点:{loccode}终点:{endLoc}任务创建失败");
                            }
                        }
                        else
                        {
                            LogHelper.Info($"拆托机{endLoc}不允许放框");
                        }
                    }

                }

            }
            catch (Exception ex)
            {
                Console.WriteLine("AutoReplenish:" + ex.Message + ex.StackTrace);
                LogHelper.Error("AutoReplenish:" + ex.Message, ex);
                throw;
            }



        }


    }
}