using CtuDeviceLib;
using Mushiny;
using OnlineStore.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using System.Web.UI.WebControls;
using System.Xml.Linq;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.TrackBar;

namespace DeviceLibrary.CtuService
{


    /// <summary>
    /// 任务管理
    /// </summary>
    public class TaskUtil
    {
        /// <summary>
        /// 原材料出库任务
        /// </summary>
        public static List<FinishedCtuTask> ShelfToLineTasks = new List<FinishedCtuTask>();

        /// <summary>
        /// 原材料所有入库
        /// </summary>
        public static List<FinishedCtuTask> LineToShelfTasks = new List<FinishedCtuTask>();

        /// <summary>
        /// 出料机构工单出库执行的最低层数
        /// </summary>
        public static int OutEquipOutStoreMinRow = 1;
        /// <summary>
        /// 出料机构工单任务切换到手动线
        /// </summary>

        public static bool OutEquipOutLineSwitchToManual = false;
        /// <summary>
        /// 出料机构手动线任务切换到工单任务
        /// </summary>

        public static bool OutEquipManualSwitchToOutLine = false;

        /// <summary>
        /// 屏蔽的巷道
        /// </summary>
        public static string[] disabledLancode { get { return ConfigAppSettings.GetValue("DisabledLanCode", new string[] { "" }); } }



        static Task getInstoreTask = null;
        static DateTime getInstoreTime = DateTime.Now;
        /// <summary
        /// 原材料-获取所有入库任务
        /// </summary>
        /// <param name="robot"></param>
        /// <returns></returns>
        public static void GetLineToShelfTasks()
        {
            if (getInstoreTask == null || getInstoreTask.IsCompleted)
            {
                if ((DateTime.Now - getInstoreTime).TotalSeconds < 1)
                {
                    return;
                }
                getInstoreTime = DateTime.Now;
                getInstoreTask = Task.Factory.StartNew(() =>
                {
                    try
                    {
                        LineToShelfTasks = SMFManager.GetLineToShelfTasks("", MushinyManager.ServerBase);
                    }
                    catch (Exception ex)
                    {
                        LogUtil.error("从服务器拉取LineToShelfTasks任务异常", ex);
                    }
                });

            }

        }



        static Task getOutstoreTask = null;
        static DateTime getOutstoreTime = DateTime.Now;
        /// <summary>
        /// 原材料-获取所有出库任务
        /// </summary>
        /// <returns></returns>
        public static void GetAllShelfToLineTasks()
        {
            if (getOutstoreTask == null || getOutstoreTask.IsCompleted)
            {
                if ((DateTime.Now - getOutstoreTime).TotalSeconds < 1)
                {
                    return;
                }
                getOutstoreTime = DateTime.Now;
                getOutstoreTask = Task.Factory.StartNew(() =>
                {
                    try
                    {
                        ShelfToLineTasks = SMFManager.GetAllShelfToLineTasks();
                    }
                    catch (Exception ex)
                    {
                        LogUtil.error("从服务器拉取ShelfToLineTasks任务异常", ex);
                    }
                });

            }
        }

        /// <summary>
        /// 所有空格口的箱子
        /// </summary>
        public static List<InletOutBox> AllEmptyBox = new List<InletOutBox>();
        static DateTime lastGetEmptyBoxTime = DateTime.Now;
        static Task getEmptyBoxTask = null;
        /// <summary>
        /// 获取所有空格口的箱子
        /// </summary>
        /// <returns></returns>
        public static void GetInletEmptyBoxes()
        {
            if (getEmptyBoxTask == null || getEmptyBoxTask.IsCompleted)
            {
                if ((DateTime.Now - lastGetEmptyBoxTime).TotalSeconds < 5)
                    return;
                lastGetEmptyBoxTime = DateTime.Now;
                getEmptyBoxTask = Task.Factory.StartNew(new Action(() =>
                {
                    try
                    {
                        var empBoxs = SMFManager.getAllEmptyBox();
                        if (empBoxs == null)
                        {
                            AllEmptyBox = new List<InletOutBox>();
                            return;
                        }
                        empBoxs.FindAll(s =>
                        {
                            var allCtus = CTUManager.GetEnabledCTUs();
                            var find = allCtus.Find(ctu => ctu.CtuTask != null && s.box.Equals(ctu.CtuTask));
                            if (find != null)//有车执行该料箱
                            {
                                return false;
                            }
                            else
                            {
                                return true;
                            }
                        });
                        AllEmptyBox = empBoxs?.ToList();
                    }
                    catch (Exception ex)
                    {

                    }
                }));

            }

        }

        public static List<string> EmptyPos = new List<string>();
        static DateTime lastGetEmptyPosTime = DateTime.Now;
        static Task getEmptyPosTaks = null;

        public static void GetEmptyPos()
        {
            if (getEmptyPosTaks == null || getEmptyPosTaks.IsCompleted)
            {
                if ((DateTime.Now - lastGetEmptyPosTime).TotalSeconds < 3)
                    return;
                lastGetEmptyPosTime = DateTime.Now;
                getEmptyPosTaks = Task.Factory.StartNew(() =>
                {
                    try
                    {
                        if (SMFManager.getEmptyPos(out List<string> emptyPos))
                        {
                            EmptyPos = emptyPos?.ToList();
                        }
                    }
                    catch (Exception ex)
                    {
                    }

                });
            }

        }
        /// <summary>
        /// 原材料-获取入料机构所有出库任务
        /// </summary>
        /// <returns></returns>
        //static List<FinishedCtuTask> GetInletOutStores()
        //{
        //    return GetAllShelfToLineTasks()?.FindAll(s => (s.toLoc.StartsWith("In")));
        //}
        /// <summary>
        /// 原材料-获取出料机构所有出库任务
        /// </summary>
        /// <returns></returns>
        //static List<FinishedCtuTask> GetOutletOutStores()
        //{
        //    return GetAllShelfToLineTasks()?.FindAll(s => (s.toLoc.StartsWith("Out")));
        //}
        /// <summary>
        /// 原材料-获取手动线出库任务
        /// </summary>
        /// <returns></returns>
        //static List<FinishedCtuTask> GetManualOutStores()
        //{
        //    return GetAllShelfToLineTasks()?.FindAll(s => (s.toLoc.StartsWith(Setting_Init.rawLine_in)));
        //}
        /// <summary>
        /// 原材料-获取手动线入库任务
        /// </summary>
        /// <returns></returns>
        static List<FinishedCtuTask> GetManualInStores()
        {
            return LineToShelfTasks?.FindAll(s => (s.fromLoc.StartsWith(Setting_Init.rawLine_out)));
        }
        /// <summary>
        /// 原材料-获取入料机构所有入库任务
        /// </summary>
        /// <returns></returns>
        //static List<FinishedCtuTask> GetInletInStores()
        //{
        //    return GetLineToShelfTasks()?.FindAll(s => (s.fromLoc.StartsWith("In")));
        //}
        /// <summary>
        /// 原材料-获取出料机构所有入库任务
        /// </summary>
        /// <returns></returns>
        static List<FinishedCtuTask> GetOutletInStores()
        {
            return LineToShelfTasks?.FindAll(s => (s.fromLoc.StartsWith("outLine")));
        }
        /// <summary>
        /// 手动线获取入库任务
        /// </summary>
        /// <returns></returns>
        public static FinishedCtuTask Manual_GetInStore(CTU ctu = null)
        {
            var instores = GetManualInStores();
            instores?.Sort((a, b) => { return (int)(b.createDate - a.createDate).TotalSeconds; });
            return instores?.Find(s =>
            {
                if(ctu!=null)
                {
                    var boxInBasket = ctu.GetFullBaskets()?.Find(basket => basket.BoxCode.Equals(s.boxCode));
                    if (boxInBasket != null)
                    {
                        return false;
                    }
                }

                var toPosInfo = PosInfos.GetPosInfoByName(s.toLoc);
                if (toPosInfo != null)
                {
                    if (disabledLancode.Contains(toPosInfo.Lanway))
                    {
                        Msg.add($"【{s.boxCode}】在手动线出口，巷道【{toPosInfo.Lanway}】被屏蔽，该任务无法执行，请手动处理", MsgLevel.warning, ErrInfo.DisabledLane);
                        return false;
                    }
                    return true;
                }
                return false;
            });
        }
        /// <summary>
        /// 出料机构获取所有入库任务
        /// </summary>
        /// <returns></returns>
        public static List<FinishedCtuTask> Outlet_GetInStores()
        {
            var instores = GetOutletInStores();
            instores?.Sort((a, b) => { return (int)(b.createDate - a.createDate).TotalSeconds; });
            return instores?.FindAll(s =>
            {
                var toPosInfo = PosInfos.GetPosInfoByName(s.toLoc);
                if (toPosInfo != null)
                {
                    if (disabledLancode.Contains(toPosInfo.Lanway))
                    {
                        Msg.add($"【{s.boxCode}】在出料【{s.fromLoc}】出口，巷道【{toPosInfo.Lanway}】被屏蔽，该任务无法执行，请手动处理", MsgLevel.warning, ErrInfo.DisabledLane);
                        return false;
                    }
                    return true;
                }
                return false;
            });
        }
        public static FinishedCtuTask Outlet_GetInStore(CTU ctu, string outletName)
        {
            if (string.IsNullOrEmpty(outletName)) return null;
            string prefix = outletName.Split('_')[0];
            var instores = GetOutletInStores();
            instores?.Sort((a, b) => { return (int)(b.createDate - a.createDate).TotalSeconds; });
            return instores?.Find(s =>
            {
                if (!s.fromLoc.StartsWith(prefix)) return false;
                var boxInBasket = ctu.GetFullBaskets()?.Find(basket => basket.BoxCode.Equals(s.boxCode));
                if (boxInBasket != null)
                {
                    return false;
                }
                var toPosInfo = PosInfos.GetPosInfoByName(s.toLoc);
                if (toPosInfo != null)
                {
                    if (disabledLancode.Contains(toPosInfo.Lanway))
                    {
                        Msg.add($"【{s.boxCode}】在出料【{s.fromLoc}】出口，巷道【{toPosInfo.Lanway}】被屏蔽，该任务无法执行，请手动处理", MsgLevel.warning, ErrInfo.DisabledLane);
                        return false;
                    }
                    return true;
                }
                return false;
            });
        }
        /// <summary>
        /// 获取无Ctu巷道的出库任务
        /// </summary>
        /// <param name="curCtuPos"></param>
        /// <param name="outTasks"></param>
        /// <returns></returns>
        public static FinishedCtuTask GetOutTaskWithNoCtuAtLane(uint curCtuPos, List<string> dsts, List<FinishedCtuTask> outTasks)
        {
            var filterTaks = new List<FinishedCtuTask>();
            if (dsts == null || dsts.Count == 0)
            {
                filterTaks.AddRange(outTasks);
            }
            else
            {
                foreach (var dst in dsts)
                {
                    var dstInfo = PosInfos.GetPosInfoByName(dst);
                    if (dstInfo == null) continue;
                    foreach (var outTask in outTasks)
                    {
                        var posInfo = PosInfos.GetPosInfoByName(outTask.fromLoc);
                        if (posInfo == null) continue;
                        if (dstInfo.Lanway == posInfo.Lanway) continue;
                        filterTaks.Add(outTask);
                    }
                }
            }
            return GetNearOutTask(curCtuPos, filterTaks);
        }
        /// <summary>
        /// 查找距离当前ctu最近的出库任务
        /// </summary>
        /// <param name="ctuPos"></param>
        /// <param name="outTasks"></param>
        /// <returns></returns>
        public static FinishedCtuTask GetNearOutTask(uint ctuPos, List<FinishedCtuTask> outTasks)
        {
            if (outTasks == null || outTasks.Count == 0) return null;
            var tmp = new Dictionary<int, FinishedCtuTask>();
            foreach (var item in outTasks)
            {
                var fromPos = PosInfos.GetPosInfoByName(item.fromLoc);
                if (fromPos == null) continue;
                tmp[PathManger.GetPToPDis(ctuPos, fromPos.PointCode)] = item;
            }
            var minDis = tmp.Keys.Min();
            return tmp[minDis];
        }
        /// <summary>
        /// 获取某个分拣机的出满箱任务,先算出每个分拣机要出多少箱，然后可以得出每个分拣机从第几箱开始取(所属分拣机任务的中间任务，例如3号分拣机取20-40箱，那么此任务返回第30个任务)
        /// 获取此任务后，需要根据此任务计算途经点是否有其他任务(GetNearestOutBoxInPath)， 如果有，将任务设置为途经点上的任务
        /// 
        /// 1 先随便找一个该巷道的出库任务
        /// 2 计算CTU到该箱子的路径点
        /// 3 判断其他任务的地标码是否在路径点中,如果在路径点中，那么截取路径点，更改任务目标和箱子号， 如果未在路径点中， 那么此点就是最近的点
        /// 4 
        /// </summary>
        /// <returns></returns>
        //public static FinishedCtuTask Outlet_GetNearestOutBoxTask(int outletIndex)
        //{
        //    List<FinishedCtuTask> allOutTasks = ShelfToLineTasks;
        //    var outLetOrManualTasks = allOutTasks
        //    .Where(task => Setting_Init.Out_FeedingInlet.Equals(task.toLoc) || Setting_Init.rawLine_in.Equals(task.toLoc))
        //    .OrderBy(task => task.fromLoc.Substring(1, 3))
        //    .ToList();

        //    int totalTaskCount = outLetOrManualTasks.Count;
        //    if (totalTaskCount > 0)
        //    {
        //        //总任务数/6=每个分拣机任务数
        //        int boxCountPerOutLet = totalTaskCount / 6;
        //        //每个分拣机从任务的中间开始取
        //        int outLetBoxIndex = boxCountPerOutLet * (outletIndex - 1) + boxCountPerOutLet / 2;

        //        var outBoxTask = outLetOrManualTasks[outletIndex];
        //        return outBoxTask;
        //    }
        //    return null;
        //}



        /// <summary>
        /// 出库分拣--查找路径中最近的出库任务
        /// </summary>
        /// <param name="pointCodes"></param>
        /// <returns></returns>
        //public static FinishedCtuTask Outlet_GetNearestOutBoxInPath(List<PointCode> pathPointCodes)
        //{
        //    var outLetOrManualTasks = Outlet_FilterOutStores();
        //    if (outLetOrManualTasks == null || outLetOrManualTasks.Count == 0) return null;
        //    FinishedCtuTask outBoxTask = null;
        //    List<PointCode> pointCodes = new List<PointCode>(pathPointCodes);

        //    foreach (var task in outLetOrManualTasks)
        //    {
        //        string taskPointCode = task.fromLoc.Substring(5, 8);
        //        uint pointCode = uint.Parse(taskPointCode);
        //        //路径中是否包含该位置
        //        int theCodeIndex = pointCodes.FindIndex(t => t.Id == pointCode);
        //        if (theCodeIndex != -1)
        //        {
        //            pointCodes = pointCodes.Take(theCodeIndex + 1).ToList();
        //            outBoxTask = task;
        //        }
        //    }
        //    return outBoxTask;
        //}

        /// <summary>
        /// 出库线体/手动线获取未接的出库任务
        /// </summary>
        /// <returns></returns>
        public static List<FinishedCtuTask> Outlet_FilterOutStores()
        {
            List<FinishedCtuTask> allOutTasks = Outlet_GetOutStores();

            var hasTaskBoxs = new Dictionary<string, string>();
            CTUManager.GetEnabledCTUs()?.ForEach(s =>
            {
                if (s.CtuTask != null && s.CtuTask is TakeBoxBase)
                {
                    if (!string.IsNullOrEmpty(s.CtuTask.boxCode))
                    {
                        if (!hasTaskBoxs.ContainsKey(s.CtuTask.boxCode))
                            hasTaskBoxs.Add(s.CtuTask.boxCode, s.Name);
                    }

                }
            }
            );
            foreach (var item in hasTaskBoxs)
            {
                Msg.add($"{item.Value}正在执行取料箱{item.Key}", MsgLevel.info);
            }
            if (hasTaskBoxs.Count > 0)
                return allOutTasks?.FindAll(s => !hasTaskBoxs.ContainsKey(s.boxCode));
            else
            {
                return allOutTasks;
            }
        }

        /// <summary>
        /// 出库线体/手动线获取出库任务
        /// </summary>
        /// <returns></returns>
        public static List<FinishedCtuTask> Outlet_GetOutStores()
        {
            List<FinishedCtuTask> allOutTasks = ShelfToLineTasks;
            if (allOutTasks == null || allOutTasks.Count == 0) return null;
            var outLetOrManualTasks = allOutTasks
            .Where(task => Setting_Init.Out_FeedingInlet.Equals(task.toLoc) || Setting_Init.rawLine_in.Equals(task.toLoc))
            .OrderBy(task => task.fromLoc.Substring(1, 3))
            .ToList();
            //筛选
            outLetOrManualTasks = outLetOrManualTasks?.FindAll(s =>
            {
                var srcPosInfo = PosInfos.GetPosInfoByName(s.fromLoc);
                if (srcPosInfo != null)
                {
                    if (disabledLancode.Contains(srcPosInfo.Lanway)) return false;
                    return srcPosInfo.Row >= OutEquipOutStoreMinRow;
                }
                return false;
            });
            return outLetOrManualTasks;
        }

        //public static FinishedCtuTask Manual_GetNearestOutBoxInPath(List<PointCode> pathPointCodes)
        //{
        //    List<FinishedCtuTask> allOutTasks = Manual_GetOutStores();
        //    if (allOutTasks == null || allOutTasks.Count == 0) return null;
        //    var manualTasks = allOutTasks
        //    .OrderBy(task => task.fromLoc.Substring(1, 3))
        //    .ToList();

        //    FinishedCtuTask outBoxTask = null;
        //    List<PointCode> pointCodes = new List<PointCode>(pathPointCodes);

        //    foreach (var task in manualTasks)
        //    {
        //        string taskPointCode = task.fromLoc.Substring(5, 8);
        //        uint pointCode = uint.Parse(taskPointCode);
        //        //路径中是否包含该位置
        //        int theCodeIndex = pointCodes.FindIndex(t => t.Id == pointCode);
        //        if (theCodeIndex != -1)
        //        {
        //            pointCodes = pointCodes.Take(theCodeIndex + 1).ToList();
        //            outBoxTask = task;
        //        }
        //    }
        //    return outBoxTask;
        //}


    }
}