using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using yunneiWCS.Common;
using yunneiWCS.data;
using yunneiWCS.EnumDefine;
using yunneiWCS.EnumDefine.Device;
using yunneiWCS.ORM;

namespace yunneiWCS.ExtendFunction
{
    /// <summary>
    /// 增补创建的扩展帮助类 【EditBy shaocx,2022-02-05】
    /// </summary>
    public class MyExtendHelper
    {
        /// <summary>
        /// 验证AGV是否执行回原点的任务
        /// </summary>
        /// <param name="isP"></param>
        /// <returns></returns>
        public static bool ValidateAgvNoParting(string isP)
        {
            // return MyExtendHelper.ValidateAgvNoParting(isP);//原来的代码
            return true;//先确认返回，试试效果 【Editby shaocx,2024-10-11】
        }

        /// <summary>
        /// 过滤这些真正的空库位
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="findPosition"></param>
        /// <returns></returns>
        public static List<position> FilterEmptyPosition(dbmodel mod, List<position> findPosition)
        {
            List<position> new_outPosition = new List<position>();
            if (findPosition == null || findPosition.Count == 0)
            {
                return new_outPosition;
            }
            productStock _productStock = null;
            foreach (var item in findPosition)
            {
                _productStock = null;
                _productStock = mod.productStock.Where(x => x.positionId == item.positionId).FirstOrDefault();
                if (_productStock != null)
                {//说明有库存

                }
                else
                {//说明无库存
                    new_outPosition.Add(item);
                }
            }
            return new_outPosition;
        }

        /// <summary>
        /// 是否允许给堆垛机发送新任务
        /// </summary>
        /// <param name="srm"></param>
        /// <returns></returns>
        public static bool IsAllowSendNewTaskToSrm(int sleepTime = 2000)
        {
            Thread.Sleep(sleepTime);//等待一秒钟 【EditBy shaocx,2022-03-26】
            if (Form1.srm.mode == "自动" && Form1.srm.Alarm_info == "无故障" && Form1.srm.state == "待机" && Form1.srm.srmTaskExcuteName == "复位")
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 获取输送线站点
        /// </summary>
        /// <param name="conv1"></param>
        /// <param name="conv2"></param>
        /// <param name="conv3"></param>
        /// <param name="conv4"></param>
        /// <param name="item"></param>
        /// <param name="queryTaskAreaEnum"></param>
        /// <returns></returns>
        public static string GetConvPlace(convEntity conv1, convEntity conv2, convEntity conv3, convEntity conv4, task item, TaskAreaEnum queryTaskAreaEnum)
        {
            string convPlace = "";
            if (!IsAllowSimulatorHandle(item))
            {
                switch (queryTaskAreaEnum)
                {
                    case TaskAreaEnum.缸体侧:
                        if (conv1.taskId.ToString() == item.PlcTaskNo)
                        {
                            convPlace = "2-39-1";
                        }
                        if (conv2.taskId.ToString() == item.PlcTaskNo)
                        {
                            convPlace = "1-39-1";
                        }
                        break;
                    case TaskAreaEnum.缸盖侧:
                        if (conv3.taskId.ToString() == item.PlcTaskNo)
                        {
                            convPlace = "1-0-1";
                        }
                        if (conv4.taskId.ToString() == item.PlcTaskNo)
                        {
                            convPlace = "2-0-1";
                        }
                        break;
                }
            }
            else
            {//虚拟模式或强制完成

                switch (queryTaskAreaEnum)
                {
                    case TaskAreaEnum.缸体侧:
                        convPlace = "2-39-1";//写死
                        break;
                    case TaskAreaEnum.缸盖侧:
                        convPlace = "1-0-1";//写死
                        break;
                }
            }
            return convPlace;
        }

        /// <summary>
        /// 判断任务是否允许模拟完成(虚拟模拟或者是强制完成模式)
        /// </summary>
        /// <param name="_task"></param>
        /// <returns></returns>
        public static bool IsAllowSimulatorHandle(task _task)
        {
            if (Form1.isvirtual)
            {
                return true;
            }
            if (_task != null && _task.isForceComplete == 1)
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 根据站点位置获取输送线的设备枚举
        /// </summary>
        /// <param name="placeName"></param>
        /// <returns></returns>
        public static TransEnum GetTransByPlace(string placeName)
        {
            /*
             * 缸体下线、上线  、缸体余料回库 的立体入库口和出库口  1-39-1（对应输送线短的L2）、2-39-1(对应输送线长的L1)
缸盖下线、上线、缸盖余料回库的立库入库口和出库口  1-0-1(对应输送线短的L3)、2-0-1（对应输送线长的L4）
             */
            switch (placeName)
            {
                case "2-39-1":
                    return TransEnum.输送线L1;
                case "1-39-1":
                    return TransEnum.输送线L2;
                case "2-0-1":
                    return TransEnum.输送线L4;
                case "1-0-1":
                    return TransEnum.输送线L3;
            }
            throw new Exception("根据站点位置" + placeName + "获取输送线的设备枚举失败");
        }

        /// <summary>
        /// 通过站点ID获取库存
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="positionId"></param>
        /// <returns></returns>
        public static productStock GetProductStockById(dbmodel mod, long positionId)
        {
            productStock stock = mod.productStock.FirstOrDefault(x => x.positionId == positionId);
            return stock;
        }

        /// <summary>
        /// 处理入库单，获取任务类型 【EditBy shaocx,2022-02-06】
        /// </summary>
        /// <param name="inTask"></param>
        /// <returns></returns>
        public static taskType GetTaskTypeForInStockOrder(inStockOrder inTask)
        {
            //增加 toStieCode的判断 【EditBy shaocx,2022-02-06】
            taskType tasktype = 0;
            if (string.IsNullOrEmpty(inTask.toStieCode))
            {
                //根据起点判断任务类型
                if (SysGloble.TransStations.Contains(inTask.siteCode))
                {
                    tasktype = taskType.手动入库;
                }
                else
                {
                    //tasktype = inTask.siteCode.Substring(0, 2) == "GT" ? 1 : 2;
                    tasktype = inTask.siteCode.Substring(0, 2) == "GT" ? taskType.缸体下线 : taskType.缸盖下线;
                }
            }
            else
            {//表示不入立体库，直接去天永机器人那里
                tasktype = inTask.siteCode.Substring(0, 2) == "GT" ? taskType.缸体下线直接去上线点 : taskType.缸盖下线直接去上线点;
            }
            return tasktype;
        }

        /// <summary>
        /// 处理入库单，获取任务区域 【EditBy shaocx,2022-02-06】
        /// </summary>
        /// <param name="inTask"></param>
        /// <returns></returns>
        public static int GetTaskAreaForInStockOrder(inStockOrder inTask)
        {
            return inTask.orderType == 1 ? (int)TaskAreaEnum.缸体侧 : (int)TaskAreaEnum.缸盖侧;
        }


        /// <summary>
        /// 根据出库口的位置，获取任务区域 【EditBy shaocx,2022-02-06】
        /// </summary>
        /// <param name="inTask"></param>
        /// <returns></returns>
        public static int GetTaskAreaByOutStorePostion(string postionName)
        {
            TaskAreaEnum _TaskAreaEnum = default(TaskAreaEnum);
            switch (postionName)
            {
                case "1-39-1":
                case "2-39-1":
                    _TaskAreaEnum = TaskAreaEnum.缸体侧;
                    break;
                case "1-0-1":
                case "2-0-1":
                    _TaskAreaEnum = TaskAreaEnum.缸盖侧;
                    break;
            }
            return (int)_TaskAreaEnum;
        }

        /// <summary>
        /// 站点是否被任务占用
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="station"></param>
        /// <returns></returns>
        public static FunctionReturnEntity<string> IsStationHasDoingTask(dbmodel mod, string station)
        {
            //判断站点是否有任务被占用
            var queryStatus1 = (int)taskStatus.完成;
            var queryStatus2 = (int)taskStatus.作废;
            int taskCount = mod.task.Where(x => (x.sourcePlace == station || x.toPlace == station) && x.taskStatus != queryStatus1 && x.taskStatus != queryStatus2).Count();
            if (taskCount > 0)
            {
                return FunctionReturnEntity<string>.Fail("站点" + station + "有任务被占用");
            }
            return FunctionReturnEntity<string>.Success("站点" + station + "没有任务被占用");
        }

        /// <summary>
        /// 输送线站点是否被任务占用
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="station"></param>
        /// <returns></returns>
        public static FunctionReturnEntity<string> IsStationHasDoingTaskForMiddlePlace(dbmodel mod, string _middlePlace)
        {
            //判断站点是否有任务被占用
            var queryStatus1 = (int)taskStatus.完成;
            var queryStatus2 = (int)taskStatus.作废;
            int taskCount = mod.task.Where(x => (x.middlePlace == _middlePlace) && x.taskStatus != queryStatus1 && x.taskStatus != queryStatus2).Count();
            if (taskCount > 0)
            {
                return FunctionReturnEntity<string>.Fail("站点" + _middlePlace + "有任务被占用");
            }
            return FunctionReturnEntity<string>.Success("站点" + _middlePlace + "没有任务被占用");
        }

        /// <summary>
        /// 站点是否可以被创建新任务
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="station"></param>
        /// <returns></returns>
        public static FunctionReturnEntity<string> IsStationAllowCreateNewTask(dbmodel mod, string station)
        {
            var position = mod.position.Where(x => (x.positionName == station)).FirstOrDefault();
            if (position == null)
            {
                return FunctionReturnEntity<string>.Fail("站点" + station + "不存在");
            }
            if (position.isLock == true)
            {
                return FunctionReturnEntity<string>.Fail("站点" + station + "被锁定");
            }
            if (position.enable == false)
            {
                return FunctionReturnEntity<string>.Fail("站点" + station + "被禁用");
            }
            return FunctionReturnEntity<string>.Success("站点" + station + "可以被使用");
        }

        /// <summary>
        /// 验证AGV是否空闲，可发送任务给他
        /// </summary>
        /// <param name="_taskArea"></param>
        /// <param name="agvs"></param>
        /// <param name="agvSendStatus"></param>
        /// <returns></returns>
        public static bool ValidateAgvIsFree(task item, TaskAreaEnum _taskArea, List<AgvStatus> agvs,
        string[] agvSendStatus
        )
        {
            if (MyExtendHelper.IsAllowSimulatorHandle(item)) return true;
            bool isReadAgv = false;
            switch (_taskArea)
            {
                case TaskAreaEnum.缸体侧:
                    if (!MyExtendHelper.IsAllowSimulatorHandle(item))
                    {
                        if (agvs.Count == 4)
                        {
                            #region 判断AGV是否空闲
                            string isP = agvs[2].orderId == null ? "" : agvs[2].orderId.Substring(agvs[2].orderId.Length - 1, 1);
                            if (agvs[2].operatingMode == 2 && agvs[2].battery > 0.4 && MyExtendHelper.ValidateAgvNoParting(isP))
                            {
                                isReadAgv = true;
                            }

                            isP = agvs[3].orderId == null ? "" : agvs[3].orderId.Substring(agvs[3].orderId.Length - 1, 1);
                            if (agvs[3].operatingMode == 2 && agvs[3].battery > 0.4 && MyExtendHelper.ValidateAgvNoParting(isP))
                            {
                                isReadAgv = true;
                            }
                            #endregion
                        }
                    }
                    break;
                case TaskAreaEnum.缸盖侧:
                    if (!MyExtendHelper.IsAllowSimulatorHandle(item))
                    {
                        if (agvs.Count == 4)
                        {
                            #region 判断AGV是否空闲
                            string isP = agvs[0].orderId == null ? "" : agvs[0].orderId.Substring(agvs[0].orderId.Length - 1, 1);
                            if (agvs[0].operatingMode == 2 && agvs[0].battery > 0.4 && MyExtendHelper.ValidateAgvNoParting(isP))
                            {
                                isReadAgv = true;
                            }

                            isP = agvs[1].orderId == null ? "" : agvs[1].orderId.Substring(agvs[1].orderId.Length - 1, 1);
                            if (agvs[1].operatingMode == 2 && agvs[1].battery > 0.4 && MyExtendHelper.ValidateAgvNoParting(isP))
                            {
                                isReadAgv = true;
                            }
                            #endregion
                        }

                    }
                    break;
            }
            return isReadAgv;
        }

    }
}