using iWareCommon.Utils;
using iWareSda_QQJF.RGV.RgvService;
using iWareSda_QQJF.RgvModel;
using iWareSda_QQJF.SRM.SrmModel;
using iWareSda_QQJF.SRM.SrmService;
using iWareSda_QQJF.SRMTRAN.SrmTranService;
using iWareSda_QQJF.SrmTranModel;
using iWareSda_QQJF.WCSNEW.EDM;
using logtxtWrite;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Speech.Synthesis;
using System.Text;
using System.Threading.Tasks;

namespace iWareSda_QQJF.WCSNEW
{
    public class Helper
    {
        static List<int> tranIdByRgv2 = new List<int> { 20, 29, 10, 21, 22, 23, 24, 25, 26, 27, 28, 33, 34, 19 };//2号RGV负责输送线号(除中转台)
        static List<int> tranIdByRgv1 = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 14, 15, 12 };//1号RGV负责输送线号
        static List<int> tranIdByRgv3 = new List<int> { 49, 50, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 47 };//3号RGV负责输送线号
        static List<int> tranIdByRgv4 = new List<int> { 44, 53, 54, 55, 56, 57, 58, 59, 60, 66, 67, 62, 63, 52 };//4号RGV负责输送线号
        static List<int> needLeaveTran = new List<int> { 14, 15, 17, 20, 8, 9, 10, 21, 42, 43, 44, 53, 52, 50 };
        /// <summary>
        /// 判断RGV是否干涉
        /// </summary>
        /// <returns></returns>
        public static bool IsTouch(int tranid, int rgvid)
        {
            using (Model edm = new Model())
            {
                TranLock tran = edm.TranLock.FirstOrDefault(x => x.TRANID == tranid);
                if (tran.ISLOCK == 1 && tran.LOCKDEVICEID != rgvid)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// 语音
        /// </summary>
        /// <param name="saying"></param>
        public static void Speaking(string saying)
        {
            string say = saying;
            Task task = new Task(() =>
            {
                SpeechSynthesizer speech = new SpeechSynthesizer();
                speech.Volume = 100; //音量
                CultureInfo keyboardCulture = System.Windows.Forms.InputLanguage.CurrentInputLanguage.Culture;
                InstalledVoice neededVoice = speech.GetInstalledVoices(keyboardCulture).FirstOrDefault();
                if (neededVoice == null)
                {
                    say = "未知的操作";
                }
                else
                {
                    speech.SelectVoice(neededVoice.VoiceInfo.Name);
                }

                speech.Speak(say);
            });
            task.Start();
        }

        /// <summary>
        /// 音调
        /// </summary>
        /// <param name="saying"></param>
        public static void Song(string saying, int length)
        {
            int hz = 0;
            switch (saying)
            {
                case "a": hz = 262; break;
                case "s": hz = 294; break;
                case "d": hz = 330; break;
                case "f": hz = 349; break;
                case "g": hz = 392; break;
                case "h": hz = 440; break;
                case "j": hz = 494; break;
                case "q": hz = 523; break;
                case "w": hz = 587; break;
                case "e": hz = 659; break;
                case "r": hz = 698; break;
                case "t": hz = 784; break;
                case "y": hz = 880; break;
                case "u": hz = 988; break;
                case "1": hz = 1046; break;
                case "2": hz = 1175; break;
                case "3": hz = 1318; break;
                case "4": hz = 1397; break;
                case "5": hz = 1568; break;
                case "6": hz = 1760; break;
                case "7": hz = 1976; break;
            }
            Console.Beep(hz, length);
        }


        /// <summary>
        /// 根据出口类型获取出库输送线
        /// </summary>
        /// <returns></returns>
        public static int GetOutTran(int outType, string sourcePlace)
        {
            try
            {
                using (Model edm = new Model())
                {
                    //获取每个口的任务占用数量
                    int tranNum1 = edm.TASK_TASK.Where(x => x.TOPLACE == "67" && x.HASFINISHED == 0).Count();//东分拣
                    int tranNum2 = edm.TASK_TASK.Where(x => x.TOPLACE == "51" && x.HASFINISHED == 0).Count();//东冲压1
                    int tranNum3 = edm.TASK_TASK.Where(x => x.TOPLACE == "64" && x.HASFINISHED == 0).Count();//东冲压2
                    int tranNum4 = edm.TASK_TASK.Where(x => x.TOPLACE == "34" && x.HASFINISHED == 0).Count();//西分拣
                    int tranNum5 = edm.TASK_TASK.Where(x => x.TOPLACE == "12" && x.HASFINISHED == 0).Count();//西空托盘
                    int tranNum6 = edm.TASK_TASK.Where(x => x.TOPLACE == "19" && x.HASFINISHED == 0).Count();//西焊装1
                    int tranNum7 = edm.TASK_TASK.Where(x => x.TOPLACE == "30" && x.HASFINISHED == 0).Count();//西焊装2

                    //比较任务占用数，选择小的（无故障的）
                    //根据出口类型分类

                    switch (outType)
                    {
                        case 1://1=西边焊接区
                            {
                                //if (tranNum6 <= tranNum7)
                                if (int.Parse(sourcePlace.Substring(0, 1)) > 5)//5号巷道以上走19
                                {
                                    return 19;
                                }
                                else
                                {
                                    return 30;
                                }
                            }
                        //case 2: return 34;//2=西边分拣区
                        //case 3: return 12;//3=西边空托盘出库
                        //case 4: return 67;//4=东边分拣区
                        case 5://5=东边冲压区
                            {
                                //if (tranNum2 <= tranNum3 && tranNum2 <= tranNum1)
                                if (int.Parse(sourcePlace.Substring(0, 1)) >= 5)//5号巷道以上走51
                                {
                                    return 51;
                                }
                                else if (tranNum3 <= tranNum1)
                                {
                                    return 64;
                                }
                                else
                                {
                                    return 67;
                                }
                            }
                        case 6: return 0;//6=东边空托盘出库(无此情况)
                        default: return 0;
                    }
                }
            }
            catch
            {
                return 0;
            }
        }

        /// <summary>
        /// 判断任务是否可以下发
        /// </summary>
        /// <param name="source"></param>
        /// <param name="to"></param>
        /// <param name="tasktype"></param>
        /// <returns></returns>
        public static bool TaskCouldSend(string source, string to, int tasktype, out int statusId, out int deviceId)
        {
            try
            {
                statusId = 0;
                deviceId = 0;

                iWareSda_QQJF.SRM.SrmService.SrmService srmService = new SRM.SrmService.SrmService();
                iWareSda_QQJF.SRMTRAN.SrmTranService.SrmTranService tranService = new SRMTRAN.SrmTranService.SrmTranService();

                //获取任务开始设备是否空闲
                if (tasktype == 1)
                {
                    if (!tranService.TranNotUse(int.Parse(source)))
                    {
                        statusId = 1;
                        deviceId = int.Parse(source);
                        return false;
                    }
                }
                else if (tasktype == 2 || tasktype == 3)
                {
                    int srmid = int.Parse(source.Substring(0, 1));
                    if (!srmService.IsNotUse(srmid))
                    {
                        statusId = 1;
                        deviceId = srmid;
                        return false;
                    }
                }
                //获取使用的所有设备是否可用

                return true;
            }
            catch (Exception e)
            {
                logtxt.txtWrite("类名：Helper/函数名：TaskCouldSend/ :" + e, 1);
            }

            statusId = 98;
            deviceId = 0;
            return false;
        }

        /// <summary>
        /// 根据RGV选择防干涉安全目的地
        /// </summary>
        /// <param name="rgvId"></param>
        /// <returns></returns>
        public static int GetSafeTranId(int rgvId)
        {
            switch (rgvId)
            {
                case 1: return 7;
                case 2: return 22;
                case 3: return 41;
                case 4: return 54;
                default: return 0;
            }
        }
        /// <summary>
        /// 任务锁定输送线
        /// </summary>
        /// <param name="i"></param>
        /// <param name="sourceLocal"></param>
        /// <param name="toLocal"></param>
        public static bool LockTran(int rgvId, long sourceLocal, long toLocal)
        {
            //加锁
            using (Model edm = new Model())
            {
                int isSouth = 0;
                int isEast = 0;
                switch (rgvId)
                {
                    case 2: isSouth = 1; isEast = 0; break;
                    case 1: isSouth = 0; isEast = 0; break;
                    case 3: isSouth = 0; isEast = 1; break;
                    case 4: isSouth = 1; isEast = 1; break;
                    default: break;
                }
                List<TranLock> tranList;
                if (isSouth == 1)
                {
                    tranList = edm.TranLock.Where(x => (x.LOCAL <= sourceLocal || x.LOCAL <= toLocal) && x.ISEAST == isEast).ToList();
                }
                else
                {
                    tranList = edm.TranLock.Where(x => (x.LOCAL >= sourceLocal || x.LOCAL >= toLocal) && x.ISEAST == isEast).ToList();
                }
                foreach (var tran in tranList)
                {
                    tran.ISLOCK = 1;
                    tran.ISERRORLOCK = 0;
                    tran.LOCKDEVICEID = rgvId;
                }
                //去除原先锁定但目前不用锁定的输送线
                List<TranLock> unLock = edm.TranLock.Where(x => x.LOCKDEVICEID == rgvId).ToList();
                foreach (var i in unLock)
                {
                    if (!tranList.Contains(i))
                    {
                        i.ISLOCK = 0;
                        i.LOCKDEVICEID = 0;
                    }
                }
                //if (edm.SaveChanges() > 0)
                //{
                edm.SaveChanges();
                return true;//有时锁定刚好就是一个不变
                //}
                //else
                //{
                //    return false;
                //}
            }
        }

        /// <summary>
        /// 根据输送线号获取相邻的输送线号
        /// </summary>
        /// <param name="tranid"></param>
        public static int GetNextTran(int tranid)
        {
            switch (tranid)
            {
                //case 46: return 47;
                //case 47: return 46;
                //case 45: return 45;
                case 47: return 46;
                case 46: return 47;
                case 45: return 68;
                case 68: return 45;
                case 48: return 49;
                case 49: return 48;
                case 61: return 62;
                case 62: return 61;
                case 65: return 66;
                case 66: return 65;
                case 32: return 33;
                case 33: return 32;
                case 15: return 14;
                case 14: return 15;
                case 20: return 19;
                case 19: return 20;
                case 34: return 34;
                case 67: return 67;
                case 30: return 29;
                case 29: return 30;
                case 12: return 11;
                case 11: return 12;
                case 64: return 63;
                case 63: return 64;
                case 51: return 50;
                case 50: return 51;


                default: return 0;
            }
        }

        /// <summary>
        /// 判断是否需要中转
        /// </summary>
        /// <param name="srmid"></param>
        /// <param name="tranid"></param>
        /// <returns></returns>
        public static bool NeedTwoRgv(int srmid, int tranid, int tasktype)
        {
            RgvService rgvService = new RgvService();
            bool isEast = GetIsEast(tranid);
            int source = 0;
            int to = 0;
            if (tasktype == 1)
            {
                source = GetNextTran(tranid);
                to = GetTranEnter(srmid, tasktype, isEast);
            }
            else if (tasktype == 2)
            {
                to = GetNextTran(tranid);
                source = GetTranEnter(srmid, tasktype, isEast);
            }
            int rgv1 = 0;
            int rgv2 = 0;

            using (Model edm = new Model())
            {
                int sourceLocal = edm.TranLock.FirstOrDefault(x => x.TRANID == source).LOCAL;
                int toLocal = edm.TranLock.FirstOrDefault(x => x.TRANID == to).LOCAL;
                int centerLocal = 0;
                if (isEast)
                {
                    centerLocal = edm.TranLock.FirstOrDefault(x => x.TRANID == 52).LOCAL;
                    rgv1 = 3;
                    rgv2 = 4;
                }
                else
                {
                    centerLocal = edm.TranLock.FirstOrDefault(x => x.TRANID == 17).LOCAL;
                    rgv1 = 1;
                    rgv2 = 2;
                }
                if ((sourceLocal >= centerLocal && toLocal <= centerLocal) || (sourceLocal <= centerLocal && toLocal >= centerLocal))//需要中转台
                {
                    bool rgvIsUse1 = rgvService.IsRgvUseful(rgv1);
                    bool rgvIsUse2 = rgvService.IsRgvUseful(rgv2);

                    if (rgvIsUse1 && rgvIsUse2)//设备非故障
                    {
                        return true;
                    }
                    else
                    {
                        if (!rgvIsUse1)
                        {
                            WZ.Useful.Commons.LogTextHelper.WriteLine("rgv1不可用", "", "");
                        }
                        else if (!rgvIsUse2)
                        {
                            WZ.Useful.Commons.LogTextHelper.WriteLine("rgv2不可用", "", "");
                        }
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// 根据起始目标计算调用RGV
        /// </summary>
        /// <param name="sourcePlace"></param>
        /// <param name="toPlace"></param>
        public static int GetRGVId(int sourcePlace, int toPlace)
        {
            RgvService rgvService = new RgvService();
            int rgvid1 = 0;//第一优先级RGV
            int rgvid2 = 0;//第二优先级RGV
            int resultRgv = 0;
            //获取排序两台RGV优先级
            if (tranIdByRgv1.Contains(sourcePlace) || tranIdByRgv1.Contains(toPlace))
            {
                rgvid1 = 1;
                rgvid2 = 2;
            }
            else if (tranIdByRgv2.Contains(sourcePlace) || tranIdByRgv2.Contains(toPlace))
            {
                rgvid1 = 2;
                rgvid2 = 1;
            }
            else if (tranIdByRgv3.Contains(sourcePlace) || tranIdByRgv3.Contains(toPlace))
            {
                rgvid1 = 3;
                rgvid2 = 4;
            }
            else if (tranIdByRgv4.Contains(sourcePlace) || tranIdByRgv4.Contains(toPlace))
            {
                rgvid1 = 4;
                rgvid2 = 3;
            }
            else
            {
                return resultRgv;
            }
            using (Model edm = new Model())
            {
                TranLock sourceTran = edm.TranLock.FirstOrDefault(x => x.TRANID == sourcePlace);
                TranLock toTran = edm.TranLock.FirstOrDefault(x => x.TRANID == sourcePlace);

                //第一优先级RGV是否可用
                if (rgvService.IsRgvUseful(rgvid1))
                {
                    resultRgv = rgvid1;
                }
                //第二RGV是否可用
                else
                {
                    if (rgvService.IsRgvUseful(rgvid2))
                    {
                        resultRgv = rgvid2;
                    }
                }
            }
            return resultRgv;
        }

        /// <summary>
        /// 创建RGV任务
        /// </summary>
        /// <param name="TASK_TASK"></param>
        /// <param name="srmTask"></param>
        /// <param name="tranid"></param>
        public static bool AddRGVTask(Model edm, TASK_TASK mainTask, int sourceTran, int toTran, int tasktype, RgvTask pretask, out int useRgv, out RgvTask task)
        {
            RgvTask rgvTask = new RgvTask();
            rgvTask.TASK_TASK = mainTask;
            rgvTask.ISRELEASED = 0;
            rgvTask.HASFINISHED = 0;
            rgvTask.PRERGVTASK = pretask;
            int rgvid = Helper.GetRGVId(sourceTran, toTran);
            useRgv = rgvid;
            if (rgvid == 0)//设备不可用
            {
                task = null;
                return false;
            }
            //int rgvTranid = GetTranEnter(srmId, mainTask.TASKTYPE, GetIsEast(tranid));
            //int enterTranId = GetNextTran(tranid);
            //Helper.GetRGVFromToAndId(rgvTranid, enterTranId, mainTask.TASKTYPE, out sourceplace, out toplace, out rgvid);
            rgvTask.SOURCEPLACE = sourceTran;
            rgvTask.TOPLACE = toTran;
            rgvTask.USERGVID = rgvid;
            rgvTask.TASKTYPE = tasktype;
            if (rgvTask.TASKTYPE == 1 && rgvTask.PRERGVTASK != null)//是入库有搬运有前置任务说明是运行完能动堆垛机
            {
                if (mainTask.TASKTYPE == 1)
                {
                    rgvTask.UPDATESRMTASK = 1;
                }
            }
            edm.RgvTask.Add(rgvTask);
            //输出使用的RGV编号及RGV任务号
            //taskId = edm.RgvTask.OrderByDescending(x => x.ID).FirstOrDefault(x => x.MainTask.ID == mainTask.ID).ID;//取出此主任务下的最后生成的一条分RGV任务（就是刚刚那条）
            task = rgvTask;

            //中转台及其附近输送线避让任务
            if (needLeaveTran.Contains(toTran))
            {
                int safeTran = Helper.GetSafeTranId(rgvid);

                RgvTask rgvTaskLeave = new RgvTask();
                rgvTaskLeave.TASK_TASK = mainTask;
                rgvTaskLeave.ISRELEASED = 0;
                rgvTaskLeave.HASFINISHED = 0;
                rgvTaskLeave.PRERGVTASK = rgvTask;
                rgvTaskLeave.SOURCEPLACE = toTran;
                rgvTaskLeave.TOPLACE = safeTran;
                rgvTaskLeave.USERGVID = rgvid;
                rgvTaskLeave.TASKTYPE = 2;
                edm.RgvTask.Add(rgvTaskLeave);
                task = rgvTaskLeave;
            }

            return true;
        }

        /// <summary>
        /// 设置任务为故障
        /// </summary>
        /// <param name="mainTask"></param>
        public static void SetTaskOver(TASK_TASK mainTask, int deviceid)
        {
            Model edmAnother = new Model();
            TASK_TASK mainTaskAnther = edmAnother.TASK_TASK.FirstOrDefault(x => x.ID == mainTask.ID);
            mainTask.HASREADED = 1;
            mainTask.HASFINISHED = 1;
            mainTask.ISERROR = 1;
            mainTask.ERRORDEVICEID = deviceid;
            mainTask.ERRORMSG = 3;
            edmAnother.SaveChanges();
        }

        /// <summary>
        /// 根据巷道和任务类型,以及东西，筛选输入库巷道
        /// </summary>
        /// <param name="srmid"></param>
        /// <param name="tasktype"></param>
        public static int GetTranEnter(int srmid, int tasktype, bool isEast)
        {
            if (isEast)
            {
                if (tasktype == 1)
                {
                    switch (srmid)
                    {
                        case 1: return 60;
                        case 2: return 58;
                        case 3: return 56;
                        case 4: return 54;
                        case 5: return 44;
                        case 6: return 42;
                        case 7: return 40;
                        case 8: return 38;
                        case 9: return 36;
                        default: return 0;
                    }
                }
                else if (tasktype == 2)
                {
                    switch (srmid)
                    {
                        case 1: return 59;
                        case 2: return 57;
                        case 3: return 55;
                        case 4: return 53;
                        case 5: return 43;
                        case 6: return 41;
                        case 7: return 39;
                        case 8: return 37;
                        case 9: return 35;
                        default: return 0;
                    }
                }
            }
            else
            {
                if (tasktype == 1)
                {
                    switch (srmid)
                    {
                        case 1: return 27;
                        case 2: return 25;
                        case 3: return 23;
                        case 4: return 21;
                        case 5: return 9;
                        case 6: return 7;
                        case 7: return 5;
                        case 8: return 3;
                        case 9: return 1;
                        default: return 0;
                    }
                }
                else if (tasktype == 2)
                {
                    switch (srmid)
                    {
                        case 1: return 28;
                        case 2: return 26;
                        case 3: return 24;
                        case 4: return 22;
                        case 5: return 10;
                        case 6: return 8;
                        case 7: return 6;
                        case 8: return 4;
                        case 9: return 2;
                        default: return 0;
                    }
                }
            }
            return 0;
        }


        /// <summary>
        /// 根据巷道和任务类型,以及东西，筛选输入库口
        /// </summary>
        /// <param name="srmid"></param>
        /// <param name="tasktype"></param>
        public static string GetSrmEnter(int srmid, int tasktype, bool isEast)
        {
            if (isEast)
            {
                if (tasktype == 1)
                {
                    switch (srmid)
                    {
                        case 1: return "02-19-01";
                        case 2: return "03-20-01";
                        case 3: return "03-19-01";
                        case 4: return "03-21-01";
                        case 5: return "02-20-01";
                        case 6: return "03-20-01";
                        case 7: return "03-24-01";
                        case 8: return "03-25-01";
                        case 9: return "03-23-01";
                        default: return "";
                    }
                }
                else if (tasktype == 2)
                {
                    switch (srmid)
                    {
                        case 1: return "01-19-01";
                        case 2: return "02-20-01";
                        case 3: return "02-19-01";
                        case 4: return "02-21-01";
                        case 5: return "01-20-01";
                        case 6: return "02-20-01";
                        case 7: return "02-24-01";
                        case 8: return "02-25-01";
                        case 9: return "02-23-01";
                        default: return "";
                    }
                }
            }
            else
            {
                if (tasktype == 1)
                {
                    switch (srmid)
                    {
                        case 1: return "01-01-01";
                        case 2: return "02-01-01";
                        case 3: return "02-01-01";
                        case 4: return "02-01-01";
                        case 5: return "01-01-01";
                        case 6: return "02-01-01";
                        case 7: return "02-01-01";
                        case 8: return "02-01-01";
                        case 9: return "02-01-01";
                        default: return "";
                    }
                }
                else if (tasktype == 2)
                {
                    switch (srmid)
                    {
                        case 1: return "02-01-01";
                        case 2: return "03-01-01";
                        case 3: return "03-01-01";
                        case 4: return "03-01-01";
                        case 5: return "02-01-01";
                        case 6: return "03-01-01";
                        case 7: return "03-01-01";
                        case 8: return "03-01-01";
                        case 9: return "03-01-01";
                        default: return "";
                    }
                }
            }
            return "";
        }


        /// <summary>
        /// 根据输送线号获取是否为东部任务
        /// </summary>
        /// <param name="tranid"></param>
        /// <returns></returns>
        public static bool GetIsEast(int tranid)
        {
            switch (tranid)
            {
                case 46: return true;
                case 47: return true;
                case 45: return true;
                case 48: return true;
                case 49: return true;
                case 61: return true;
                case 62: return true;
                case 65: return true;
                case 66: return true;
                case 67: return true;
                case 63: return true;
                case 64: return true;
                case 51: return true;
                case 50: return true;
                case 68: return true;

                case 32: return false;
                case 33: return false;
                case 34: return false;
                case 15: return false;
                case 14: return false;
                case 19: return false;
                case 20: return false;
                case 29: return false;
                case 30: return false;
                case 11: return false;
                case 12: return false;
                default: return false;
            }
        }

        /// <summary>
        /// 切换RGV可用时，修改输送线所动状态（暂定推至末端）
        /// </summary>
        /// <param name="rgvId"></param>
        public static void ResetTranLocal(int rgvId)
        {
            long local = 0;
            switch (rgvId)
            {
                case 1: local = 74983 - WCS.safeLength; break;
                case 2: local = 3874 + WCS.safeLength; break;
                case 3: local = 72883 - WCS.safeLength; break;
                case 4: local = 1876 + WCS.safeLength; break;
                default: break;
            }

            Helper.LockTran(rgvId, local, local);
        }

        ///// <summary>
        ///// 通过RGV任务删除关联任务
        ///// </summary>
        ///// <param name="RgvTaskId"></param>
        ///// <returns></returns>
        //public static bool DeleteAllByRgvTaskId(int RgvTaskId, out List<int> tranDoingId, out List<int> rgvDoingId, out List<int> srmDoingId)
        //{
        //    tranDoingId = new List<int>();
        //    rgvDoingId = new List<int>();
        //    srmDoingId = new List<int>();

        //    bool result = false;
        //    using (Model edm = new Model())
        //    {
        //        RgvTask rgvTask = edm.RgvTask.FirstOrDefault(x => x.ID == RgvTaskId);
        //        if (rgvTask != null)
        //        {
        //            MainTask mainTask = rgvTask.MainTask;
        //            result = DeleteAllTask(mainTask.TASKID, out tranDoingId, out rgvDoingId, out srmDoingId);

        //            mainTask.HASFINISHED = 1;
        //            mainTask.ISERROR = 1;
        //            mainTask.ERRORMSG = 2;
        //            edm.SaveChanges();
        //        }
        //        return result;
        //    }
        //}

        ///// <summary>
        ///// 通过堆垛机任务删除关联任务
        ///// </summary>
        ///// <param name="RgvTaskId"></param>
        ///// <returns></returns>
        //public static bool DeleteAllBySrmTaskId(int SrmTaskId, out List<int> tranDoingId, out List<int> rgvDoingId, out List<int> srmDoingId)
        //{
        //    tranDoingId = new List<int>();
        //    rgvDoingId = new List<int>();
        //    srmDoingId = new List<int>();
        //    bool result = false;
        //    using (Model edm = new Model())
        //    {
        //        SrmTask srmTask = edm.SrmTask.FirstOrDefault(x => x.ID == SrmTaskId);
        //        if (srmTask != null)
        //        {
        //            MainTask mainTask = srmTask.MainTask;
        //            result = DeleteAllTask(mainTask.TASKID, out tranDoingId, out rgvDoingId, out srmDoingId);

        //            mainTask.HASFINISHED = 1;
        //            mainTask.ISERROR = 1;
        //            mainTask.ERRORMSG = 3;
        //            edm.SaveChanges();

        //        }
        //        return result;
        //    }
        //}

        ///// <summary>
        ///// 通过输送线任务删除关联任务
        ///// </summary>
        ///// <param name="RgvTaskId"></param>
        ///// <returns></returns>
        //public static bool DeleteAllByTranTaskId(int tranTaskId, out List<int> tranDoingId, out List<int> rgvDoingId, out List<int> srmDoingId)
        //{
        //    tranDoingId = new List<int>();
        //    rgvDoingId = new List<int>();
        //    srmDoingId = new List<int>();
        //    bool result = false;
        //    using (Model edm = new Model())
        //    {
        //        TranTask tranTask = edm.TranTask.FirstOrDefault(x => x.ID == tranTaskId);
        //        if (tranTask != null)
        //        {
        //            MainTask mainTask = tranTask.MainTask;
        //            result = DeleteAllTask(mainTask.TASKID, out tranDoingId, out rgvDoingId, out srmDoingId);

        //            mainTask.HASFINISHED = 1;
        //            mainTask.ISERROR = 1;
        //            mainTask.ERRORMSG = 1;
        //            edm.SaveChanges();
        //        }
        //        return result;
        //    }
        //}

        /// <summary>
        /// 获取异常设备，并锁定
        /// </summary>
        /// <returns></returns>
        public static void GetAlarmDevice(int mainId)
        {
            using (Model edm = new Model())
            {
                TASK_TASK task = edm.TASK_TASK.FirstOrDefault(x => x.ID == mainId);
                List<RgvTask> rgvTaskList = edm.RgvTask.Where(x => x.FASTHERTASKID == task.ID).ToList();
                int srmDevice = edm.SrmTask.FirstOrDefault(x => x.FASTHERTASKID == task.ID).USESRMID;
                TranTask tranTask = edm.TranTask.FirstOrDefault(x => x.FASTHERTASKID == task.ID);
                //默认异常
                task.ISERROR = 1;
                task.ERRORDEVICEID = 0;
                task.ERRORMSG = 0;
                //RGV
                foreach (var i in rgvTaskList)
                {
                    if (Rgv_CacheEntity.Rgvs[i.USERGVID - 1].ararm == 1)
                    {
                        task.ISERROR = 1;
                        task.ERRORDEVICEID = i.USERGVID;
                        task.ERRORMSG = 2;
                    }
                }

                //堆垛机
                if (Srm_CacheEntity.Srms[srmDevice - 1].Ralarm == 1)
                {
                    task.ISERROR = 1;
                    task.ERRORDEVICEID = srmDevice;
                    task.ERRORMSG = 3;
                }
                if (tranTask != null)
                {
                    //输送线
                    if (SrmTran_CacheEntity.SrmTrans[tranTask.SOURCEPLACE - 1].state)
                    {
                        task.ISERROR = 1;
                        task.ERRORDEVICEID = tranTask.SOURCEPLACE;
                        task.ERRORMSG = 1;
                    }
                    else if (SrmTran_CacheEntity.SrmTrans[tranTask.TOPLACE - 1].state)
                    {
                        task.ISERROR = 1;
                        task.ERRORDEVICEID = tranTask.TOPLACE;
                        task.ERRORMSG = 1;
                    }
                }

                edm.SaveChanges();
            }

        }

        /// <summary>
        /// 删除所有关联任务
        /// </summary>
        /// <returns></returns>
        public static bool DeleteAllTask(int mainId, out List<int> tranDoingId, out List<int> rgvDoingId, out List<int> srmDoingId)
        {
            tranDoingId = new List<int>();
            rgvDoingId = new List<int>();
            srmDoingId = new List<int>();

            using (Model edm = new Model())
            {
                TASK_TASK mainTask = edm.TASK_TASK.FirstOrDefault(x => x.ID == mainId);
                if (mainTask != null)
                {
                    List<SrmTask> srmTaskList = mainTask.SrmTask.ToList();

                    List<SrmTask> srmTaskDoingList = srmTaskList.Where(x => x.HASFINISHED == 0 && x.ISRELEASED == 1).ToList();
                    foreach (var i in srmTaskDoingList)
                    {
                        int id = i.USESRMID;
                        //校验、防止误发
                        SRM.SrmService.SrmService srv = new SRM.SrmService.SrmService();
                        int taskid = JsonConvert.DeserializeObject<EntitySrmView>(srv.GetSrmInfo(id)).RtaskNO;
                        if (taskid == mainTask.ID)
                        {
                            srmDoingId.Add(id);
                        }
                    }
                    //edm.SrmTask.RemoveRange(srmTaskList);
                    foreach (var i in srmTaskList)
                    {
                        i.ISRELEASED = 1;
                    }

                    List<RgvTask> rgvTaskList = mainTask.RgvTask.ToList();
                    List<RgvTask> rgvTaskDoingList = rgvTaskList.Where(x => x.HASFINISHED == 0 && x.ISRELEASED == 1).ToList();
                    foreach (var i in rgvTaskDoingList)
                    {
                        int id = i.USERGVID;
                        //校验、防止误发
                        RGV.RgvService.RgvService srv = new RGV.RgvService.RgvService();
                        int taskid = JsonConvert.DeserializeObject<EntityRgvView>(srv.GetRgvInfo(id)).taskId;
                        if (taskid == mainTask.ID)
                        {
                            rgvDoingId.Add(id);
                        }
                    }
                    //DeleteRgvTask(rgvTaskList);
                    foreach (var i in rgvTaskList)
                    {
                        i.ISRELEASED = 1;
                    }
                    //输送线当前任务删除（特殊处理）
                    List<TranTask> tranTaskList = mainTask.TranTask.ToList();
                    //List<TranTask> tranTaskDoingList = tranTaskList.Where(x => x.HASFINISHED == 0 && x.ISRELEASED == 1).ToList();
                    if (mainTask.TASKTYPE == 1)
                    {
                        try
                        {
                            int sourceplace = int.Parse(mainTask.SOURCEPLACE);
                            TranTask tranTaskDoing = tranTaskList.OrderByDescending(x => x.ID).FirstOrDefault(x => x.SOURCEPLACE == sourceplace);
                            SRMTRAN.SrmTranService.SrmTranService srv = new SRMTRAN.SrmTranService.SrmTranService();
                            int taskIds = JsonConvert.DeserializeObject<EntitySrmTranView>(srv.GetSrmConveyorStationInfo(tranTaskDoing.SOURCEPLACE)).taskId;
                            int taskIdt = JsonConvert.DeserializeObject<EntitySrmTranView>(srv.GetSrmConveyorStationInfo(tranTaskDoing.TOPLACE)).taskId;
                            if (taskIds == mainTask.ID)
                            {
                                tranDoingId.Add(tranTaskDoing.SOURCEPLACE);
                            }
                            if (taskIdt == mainTask.ID)
                            {
                                tranDoingId.Add(tranTaskDoing.TOPLACE);
                            }
                        }
                        catch
                        {

                        }
                    }

                    //edm.TranTask.RemoveRange(tranTaskList);
                    foreach (var i in tranTaskList)
                    {
                        i.ISRELEASED = 1;
                    }
                    mainTask.HASFINISHED = 2;
                    mainTask.ISERROR = 1;
                    if (edm.SaveChanges() > 0)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// 因RGV存在前置任务的分步删除
        /// </summary>
        /// <param name="rgvTaskList"></param>
        public static void DeleteRgvTask(List<RgvTask> rgvTaskList)
        {
            //因为前置任务造成删除失败则分步删除
            List<RgvTask> rgvTaskListFirstDelete = rgvTaskList.Where(x => x.PRETASK != null).ToList();
            List<RgvTask> rgvTaskListSecondDelete = rgvTaskList.Where(x => x.PRETASK == null).ToList();

            using (Model edm = new Model())
            {
                foreach (var i in rgvTaskListFirstDelete)
                {
                    RgvTask rgvTask = edm.RgvTask.FirstOrDefault(x => x.ID == i.ID);
                    edm.RgvTask.Remove(rgvTask);
                }
                edm.SaveChanges();
            }

            using (Model edm2 = new Model())
            {
                foreach (var i in rgvTaskListSecondDelete)
                {
                    RgvTask rgvTask = edm2.RgvTask.FirstOrDefault(x => x.ID == i.ID);
                    edm2.RgvTask.Remove(rgvTask);
                }
                edm2.SaveChanges();
            }
        }


        /// 删除所有关联任务
        /// </summary>
        /// <returns></returns>
        public static bool DeleteAllTask(int mainId, out List<int> tranDoingId, out List<int> rgvDoingId, out List<int> srmDoingId, out List<string> outPlace, out int dir)
        {
            tranDoingId = new List<int>();
            rgvDoingId = new List<int>();
            srmDoingId = new List<int>();
            outPlace = new List<string>();
            dir = 0;
            using (Model edm = new Model())
            {
                TASK_TASK mainTask = edm.TASK_TASK.FirstOrDefault(x => x.ID == mainId);
                //if (mainTask != null && ((mainTask.HASFINISHED != 1 && mainTask.TASKTYPE == 1) || mainTask.TASKTYPE == 2))
                if (mainTask != null)
                {
                    //确定东西
                    if (mainTask.RgvTask.FirstOrDefault() != null)
                    {
                        if (mainTask.RgvTask.FirstOrDefault().SOURCEPLACE <= 34)
                        {
                            dir = 0;
                        }
                        else
                        {
                            dir = 1;
                        }
                    }

                    List<SrmTask> srmTaskList = mainTask.SrmTask.ToList();

                    List<SrmTask> srmTaskDoingList = srmTaskList.Where(x => x.HASFINISHED == 0 && x.ISRELEASED == 1).ToList();
                    foreach (var i in srmTaskDoingList)
                    {
                        int id = i.USESRMID;
                        //校验、防止误发
                        SRM.SrmService.SrmService srv = new SRM.SrmService.SrmService();
                        int taskid = JsonConvert.DeserializeObject<EntitySrmView>(srv.GetSrmInfo(id)).RtaskNO;
                        if (taskid == mainTask.ID)
                        {
                            srmDoingId.Add(id);

                        }
                    }
                    //删除库存
                    foreach (var i in srmTaskList)
                    {
                        List<BASE_PLACE_VS_CONTAINER> pvcList = edm.BASE_PLACE_VS_CONTAINER.Where(x => (x.BASE_PLACE.PLACE.Contains(i.SOURCEPLACE) || x.BASE_PLACE.PLACE.Contains(i.TOPLACE)) && x.BASE_PLACE.SRMID == i.USESRMID && x.CONTAINERID == i.TASK_TASK.CONTAINERID).ToList();
                        foreach (var j in pvcList)
                        {
                            outPlace.Add(j.BASE_PLACE.PLACE);
                            j.BASE_PLACE.ISLOCK = 1;//锁定
                            j.BASE_PLACE.ISFULL = 0;
                            j.ENABLE = 0;
                            j.STATUS = "OUT";
                            ////删堵塞库存
                            List<int> tranId = new List<int>()
                                {
                                    9,
                                    8,
                                    7,
                                    6,
                                    4,
                                    3,
                                    2
                                };
                            if ((j.BASE_PLACE.ROW == 1 || j.BASE_PLACE.ROW == 4) && tranId.Contains(j.BASE_PLACE.SRMID ?? 0))
                            {
                                int row = j.BASE_PLACE.ROW == 1 ? 2 : 3;
                                BASE_PLACE placeNext = edm.BASE_PLACE.FirstOrDefault(x => x.COL == j.BASE_PLACE.COL && x.LAYER == j.BASE_PLACE.LAYER && x.SRMID == j.BASE_PLACE.SRMID && x.ROW == row);
                                if (placeNext != null)
                                {
                                    outPlace.Add(placeNext.PLACE);
                                    placeNext.ISLOCK = 1;//锁定
                                    if (placeNext.BASE_PLACE_VS_CONTAINER.Count != 0)//隔壁存在库存
                                    {
                                        BASE_PLACE_VS_CONTAINER pvc = placeNext.BASE_PLACE_VS_CONTAINER.FirstOrDefault(x => x.ENABLE == 1);
                                        pvc.BASE_PLACE.ISFULL = 0;
                                        pvc.ENABLE = 0;
                                        pvc.STATUS = "OUT";
                                        edm.BASE_PLACE_VS_CONTAINER.Remove(pvc);
                                    }
                                }
                            }
                            edm.BASE_PLACE_VS_CONTAINER.Remove(j);
                        }
                    }
                    //edm.SrmTask.RemoveRange(srmTaskList);
                    foreach (var i in srmTaskList)
                    {
                        i.ISRELEASED = 1;
                        i.HASFINISHED = 1;
                    }

                    List<RgvTask> rgvTaskList = mainTask.RgvTask.ToList();
                    List<RgvTask> rgvTaskDoingList = rgvTaskList.Where(x => x.HASFINISHED == 0 && x.ISRELEASED == 1).ToList();
                    foreach (var i in rgvTaskDoingList)
                    {
                        int id = i.USERGVID;
                        //校验、防止误发
                        RGV.RgvService.RgvService srv = new RGV.RgvService.RgvService();
                        int taskid = JsonConvert.DeserializeObject<EntityRgvView>(srv.GetRgvInfo(id)).taskId;
                        if (taskid == mainTask.ID)
                        {
                            rgvDoingId.Add(id);
                        }
                    }
                    //DeleteRgvTask(rgvTaskList);
                    foreach (var i in rgvTaskList)
                    {
                        i.ISRELEASED = 1;
                    }
                    //输送线当前任务删除（特殊处理）
                    List<TranTask> tranTaskList = mainTask.TranTask.ToList();
                    //List<TranTask> tranTaskDoingList = tranTaskList.Where(x => x.HASFINISHED == 0 && x.ISRELEASED == 1).ToList();
                    if (mainTask.TASKTYPE == 1)
                    {
                        try
                        {
                            int sourceplace = int.Parse(mainTask.SOURCEPLACE);
                            TranTask tranTaskDoing = tranTaskList.OrderByDescending(x => x.ID).FirstOrDefault(x => x.SOURCEPLACE == sourceplace);
                            SRMTRAN.SrmTranService.SrmTranService srv = new SRMTRAN.SrmTranService.SrmTranService();
                            int taskIds = JsonConvert.DeserializeObject<EntitySrmTranView>(srv.GetSrmConveyorStationInfo(tranTaskDoing.SOURCEPLACE)).taskId;
                            int taskIdt = JsonConvert.DeserializeObject<EntitySrmTranView>(srv.GetSrmConveyorStationInfo(tranTaskDoing.TOPLACE)).taskId;
                            if (taskIds == mainTask.ID)
                            {
                                tranDoingId.Add(tranTaskDoing.SOURCEPLACE);
                            }
                            if (taskIdt == mainTask.ID)
                            {
                                tranDoingId.Add(tranTaskDoing.TOPLACE);
                            }
                        }
                        catch
                        {

                        }
                    }

                    //edm.TranTask.RemoveRange(tranTaskList);
                    foreach (var i in tranTaskList)
                    {
                        i.ISRELEASED = 1;
                    }
                    mainTask.HASREADED = 1;
                    mainTask.HASFINISHED = 2;
                    mainTask.ISERROR = 1;
                    mainTask.TASKSTATUS = "异常/取消";
                    //清空组盘数据
                    //查看当前任务是否为该器具的最后一条任务
                    TASK_TASK lastTask = edm.TASK_TASK.AsNoTracking().OrderByDescending(u => u.CREATETIME).FirstOrDefault(x => x.CONTAINERID == mainTask.CONTAINERID);
                    if (lastTask.ID == mainId)
                    {
                        List<BASE_CONTAINER_VS_ITEM> containerList = edm.BASE_CONTAINER_VS_ITEM.Where(x => x.CONTAINERID == mainTask.CONTAINERID).ToList();
                        edm.BASE_CONTAINER_VS_ITEM.RemoveRange(containerList);
                        if (edm.SaveChanges() > 0)
                        {
                            //记录删除托盘和物料绑定关系日志 【Editby shaoc,2023-03-07】
                            iWareSda_QQJF.WCSNEW.Helper.LogRemoveBASE_CONTAINER_VS_ITEM(containerList, "Helper.DeleteAllTask", "删除关联任务,根据堆垛机任务号删除任务");
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                    else
                    {
                        if (edm.SaveChanges() > 0)
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                }
                else
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// 删除托盘和物料绑定关系 记录日志
        /// </summary>
        /// <param name="cviList"></param>
        public static void LogRemoveBASE_CONTAINER_VS_ITEM(List<BASE_CONTAINER_VS_ITEM> cviList, string funName, string remark)
        {
            foreach (var item in cviList)
            {
                LogRemoveBASE_CONTAINER_VS_ITEM(item, funName, remark);
            }
        }

        /// <summary>
        /// 删除托盘和物料绑定关系 记录日志
        /// </summary>
        /// <param name="cviList"></param>
        public static void LogRemoveBASE_CONTAINER_VS_ITEM(BASE_CONTAINER_VS_ITEM item, string funName, string remark)
        {
            var logTitle = "方法名:" + funName + ",删除原因:" + remark + ",";
            try
            {
                //记录删除托盘和物料绑定关系日志 【Editby shaoc,2023-03-07】
                Log4NetHelper.WriteInfoLog(LogType.RemoveBASE_CONTAINER_VS_ITEM,
                    logTitle +
                    "删除托盘和物料绑定关系 成功,cvi_id:" + item.ID + ",ITEMID:" + item.ITEMID + ",CONTAINERID:" + item.CONTAINERID
                    //+ ",CONTAINERNAME：" + item.BASE_CONTAINER.CONTAINERNAME
                    //+ ",ITEMNAME：" + item.BASE_ITEM.ITEMNAME
                    );
            }
            catch (Exception ex)
            {
                Log4NetHelper.WriteErrorLog(LogType.RemoveBASE_CONTAINER_VS_ITEM, logTitle + "记录删除托盘和物料关系失败:" + ex.Message + ",cvi_id:" + item.ID, ex);
            }
        }


    }
}