using iWareCommon;
using iWareCommon.Common.Globle;
using iWareCommon.Utils;
using iWareModel;
using iWareSql;
using iWareSql.DataAccess;
using iWareSql.DbOrm;
using iWareSql.Orm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using XiGang.Core.Model;

namespace iWareCC
{
    /// <summary>
    /// 设备线程服务
    /// </summary>
    public class DeviceThreadServiceHandle
    {
        private static string _namespace = "iWareSda.DeviceThreadService";
        public LogType currentLogType = LogType.AGVTheadService;
        /// <summary>
        /// 线程休眠的时间（毫秒）
        /// </summary>
        public int cycleDelay = 500;//100,暂时 改成每次5秒一次循环

        #region 启动服务

        /// <summary>
        /// 启动服务
        /// </summary>
        public virtual void StartService()
        {

        }

        #endregion

        #region 下发任务线程

        /// <summary>
        /// 下发设备任务线程
        /// </summary>
        /// <param name="x"></param>
        public void IssueTaskThread(EDevice x)
        {
            ThreadHelper.StartThread(new Thread(new ParameterizedThreadStart(IssueTask)), (int)x);
        }

        /// <summary>
        /// 下发设备任务
        /// </summary>
        /// <param name="srmName"></param>
        public virtual void IssueTask(object deviceId)
        {

        }
        /// <summary>
        /// 下发设备任务处理
        /// </summary>
        /// <param name="srmName"></param>
        public virtual void IssueTaskHandle(int deviceId, out string errMsg)
        {
            errMsg = "";
        }
        #endregion

        #region 任务完成确认线程

        /// <summary>
        /// 任务完成确认线程
        /// </summary>
        /// <param name="x"></param>
        public void ConfirmFinishTaskThread(EDevice x)
        {
            ThreadHelper.StartThread(new Thread(new ParameterizedThreadStart(ConfirmFinishTask)), (int)x);
        }

        /// <summary>
        /// 任务完成确认
        /// </summary>
        /// <param name="srmName"></param>
        public virtual void ConfirmFinishTask(object deviceId)
        {

        }
        /// <summary>
        /// 任务完成确认处理
        /// </summary>
        /// <param name="srmName"></param>
        public virtual void ConfirmFinishTaskHandle(int deviceId, out string errMsg)
        {
            errMsg = "";
        }
        #endregion

        #region 确认任务完成线程
        #endregion

        #region 验证

        /// <summary>
        /// 验证设备是否可以下发新任务
        /// </summary>
        /// <param name="int_deviceId"></param>
        /// <returns></returns>
        public virtual bool ValidateDeviceIsAllowSendTask(int int_deviceId, out string errMsg)
        {
            errMsg = "";
            EDevice device = (EDevice)Enum.Parse(typeof(EDevice), int_deviceId.ToString());
            //if (Wms_EquipmentSituationHandler.IsEquipmentBreakdown(int_deviceId).result)
            //{//如果设备已经设定为 故障状态，不允许下发任务！！！ [EditBy shaocx,2020-12-07]
            //    errMsg = device.ToString() + "被设定为故障状态,不允许下发新任务";
            //    return false;
            //}

            return true;
        }

        /// <summary>
        /// 验证设备是否可以下发新任务
        /// </summary>
        /// <param name="int_deviceId"></param>
        /// <returns></returns>
        public virtual bool ValidateDeviceIsAllowSendTask(int int_deviceId, ware_task_sub task, out string errMsg)
        {
            errMsg = "";

            return true;
        }

        /// <summary>
        /// 验证目标点是否已经有库存！
        /// </summary>
        /// <param name="int_deviceId"></param>
        /// <returns></returns>
        public virtual bool ValidateIsHasStoreForToPlace(int int_deviceId, int placeId, string placeNo, out string errMsg)
        {
            errMsg = "";
            EDevice device = (EDevice)Enum.Parse(typeof(EDevice), int_deviceId.ToString());
            //增加验证-验证目标点是否有库存，如果有库存，则不允许下发新任务 【EditBy shaocx,2022-04-15】
            //using (DbOrm edm = new DbOrm())
            //{
            //    var store = StoreHandler.GetV_AllStoreByPlaceId(edm, placeId);
            //    if (store != null)
            //    {
            //        errMsg = "目标点" + placeNo + "系统显示已经有货,不允许给" + device.ToString() + "下发新任务，货物类型:" + store.MaterialTypeName + ",货物托盘号:" + store.SalverCode;
            //        return false;
            //    }
            //}
            return true;
        }


        /// <summary>
        ///  验证前面存在同一个起点、目标点的任务
        /// </summary>
        /// <param name="int_deviceId"></param>
        /// <param name="part"></param>
        /// <param name="errMsg"></param>
        /// <returns>true：验证通过，false：验证不通过</returns>
        public virtual bool ValidateIsHasNoFinishedSameTask(int int_deviceId, ware_task_sub part, out string errMsg)
        {
            errMsg = "";
            EDevice device = (EDevice)Enum.Parse(typeof(EDevice), int_deviceId.ToString());
            //using (DbModel edm = new DbModel())
            //{
            //    var queryState1 = (int)SubTaskStateEnum.已取消;
            //    var queryState2 = (int)SubTaskStateEnum.已完成;
            //    var partList = edm.Task_Part.Where(x => x.Id != part.Id && x.DeviceId == int_deviceId
            //        //&& x.MainTaskSequence <= part.MainTaskSequence
            //        && x.CreateTime < part.CreateTime
            //        && x.SourcePlace == part.SourcePlace
            //        && x.ToPlace == part.ToPlace
            //        && x.TaskState != queryState1 && x.TaskState != queryState2
            //        ).ToList();
            //    if (partList != null && partList.Count > 0)
            //    {
            //        errMsg = "前面存在同一个起点、目标点的任务,不允许给" + device.ToString() + "下发新任务:" + part.PlcTaskId;
            //        return false;
            //    }
            //}
            return true;
        }

        /// <summary>
        /// 验证设备是否可以接受任务
        /// </summary>
        /// <param name="int_deviceId"></param>
        /// <returns></returns>
        public virtual bool ValidateDeviceIsOK(int int_deviceId, ware_task_sub _task, int taskId, out string errMsg)
        {
            errMsg = "";
            return true;
        }

        /// <summary>
        /// 验证根据设备号是否能找到设备
        /// </summary>
        /// <param name="int_deviceId"></param>
        /// <returns></returns>
        public virtual T ValidateIsExistDevice<T>(int int_deviceId)
        {
            return default(T);
        }


        /// <summary>
        /// 验证设备是否任务完成
        /// </summary>
        /// <param name="int_deviceId"></param>
        /// <returns></returns>
        public virtual bool ValidateDeviceTaskIsFinsished(int int_deviceId, ware_task_sub _task, out string errMsg)
        {
            errMsg = "";
            return false;
        }

        /// <summary>
        /// 验证设备是否任务完成
        /// </summary>
        /// <param name="int_deviceId"></param>
        /// <returns>0表示没有任务完成，其他表示任务完成，并返回任务号</returns>
        public virtual bool ValidateDeviceTaskIsFinsished(int int_deviceId, ware_task_sub _task, int taskId, out string errMsg)
        {
            errMsg = "";
            return false;
        }

        /// <summary>
        /// 验证设备是否任务完成
        /// </summary>
        /// <param name="int_deviceId"></param>
        /// <returns>0表示没有任务完成，其他表示任务完成，并返回任务号</returns>
        public virtual bool ValidateDeviceTaskIsFinsished(int int_deviceId, ware_task_sub _task, int taskId, bool? isAllowSimulateExecute, out string errMsg)
        {
            errMsg = "";
            return false;
        }



        /// <summary>
        ///  验证起点和终点是否正确
        /// </summary>
        /// <param name="dbOrm"></param>
        /// <param name="sourcePlace">起始点的主键ID</param>
        /// <param name="toPlace">目标点的主键ID</param>
        /// <returns></returns>
        public bool ValdiatePalceIsRight(DbOrm dbOrm, string sourcePlace, string toPlace, ref RealPlaceEntity realPlaceEntity)
        {
            #region 新增异常信息表  【EditBy shaocx,2020-01-20】
            IDictionary<string, object> logDict = new Dictionary<string, object>();
            logDict.Add("sourcePlace", sourcePlace);
            logDict.Add("toPlace", toPlace);
            iWareSql.DbOrm.Base_SysExceptionInfo exception = SysExceptionInfoHandler.GetExceptionInfo<IDictionary<string, object>>(currentLogType, _namespace, "ValdiatePalceIsRight", logDict);
            #endregion
            try
            {
                if (FormCC.IsSimulationPLC)
                    return true;
                var db_fromPlace = dbOrm.ware_site.FirstOrDefault(x => x.Code == sourcePlace);
                var db_toPlace = dbOrm.ware_site.FirstOrDefault(x => x.Code == toPlace);
                if (db_fromPlace == null)
                {
                    exception.exceptionMsg = "起点'" + sourcePlace + "'没有找到";
                    SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
                    return false;
                }
                if (db_toPlace == null)
                {
                    exception.exceptionMsg = "终点'" + toPlace + "'没有找到";
                    SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
                    return false;
                }
                realPlaceEntity = new RealPlaceEntity();
                realPlaceEntity.real_sourcePlace = db_fromPlace;
                realPlaceEntity.real_toPlace = db_toPlace;
                return true;
            }
            catch (Exception ex)
            {
                SysExceptionInfoHandler.GetExceptionInfoForError("验证起点和终点是否正确出现异常:" + ex.Message, ex, ref exception);
                SysExceptionInfoHandler.InsertExceptionInfo(exception);
                throw;
            }

        }



        /// <summary>
        /// 验证数据库中是否有任务要处理
        /// </summary>
        /// <param name="int_deviceId">设备号</param>
        /// <returns></returns>
        public virtual T ValidateIsExistTaskToDispose<T>(DbOrm dbModel, int int_deviceId, out string errMsg, TaskExcuteTypeEnum _TaskExcuteTypeEnum)
        {
            errMsg = "";
            return default(T);
        }

        /// <summary>
        /// 验证数据库中是否有任务要处理
        /// </summary>
        /// <typeparam name="Task_Part"></typeparam>
        /// <param name="dbOrm"></param>
        /// <param name="int_deviceId">Rgv设备号</param>
        /// <param name="errMsg"></param>
        /// <param name="_TaskExcuteTypeEnum"></param>
        /// <returns></returns>
        public ware_task_sub ValidateIsExistTaskToDispose(DbOrm dbOrm, int int_deviceId, out string errMsg, SubTaskStateEnum _SubTaskStateEnum)
        {
            errMsg = "";
            ware_task_sub currTask = null;
            switch (_SubTaskStateEnum)
            {
                //查找需要下发的子任务
                case SubTaskStateEnum.已下发:
                     List<ware_task_sub> currTasks = dbOrm.ware_task_sub.Where(x => x.DeviceId == int_deviceId && x.TaskState == (int)SubTaskStateEnum.未开始).ToList().OrderBy(x => x.CreatedTime).ToList();//按照主任务优先级的升序排序
                    //看同一个设备，是否还有其他正在执行的任务！修改为看同一个站台是否有任务
                    var partTasks = dbOrm.ware_task_sub.Where(x => x.DeviceId == int_deviceId && x.TaskState == (int)SubTaskStateEnum.已下发).
                        OrderBy(x => x.CreatedTime).ToList();//按照主任务的顺序升序
                    foreach (var item in currTasks)
                    {
                        //检查任务优先级，是否可以下发
                        var isExist = dbOrm.ware_task_sub.AsNoTracking().Any(x => x.TaskId == item.TaskId && x.TaskSequence < item.TaskSequence && x.TaskState == (int)SubTaskStateEnum.未开始);
                        if (isExist)
                        {
                            continue;
                        }
                        var partTask = partTasks.Find(u => u.SourcePlace == item.ToPlace || u.SourcePlace == item.SourcePlace || u.ToPlace == item.ToPlace || u.ToPlace == item.SourcePlace);
                        if (partTask != null)
                        {
                            errMsg = string.Format("站台{0}的正在执行任务,任务ID:" + partTask.Id + ",主任务:" + partTask.TaskId + ",PLC任务号:" + partTask.TaskNo, partTask.SourcePlace);
                            //return default(ware_task_sub);
                            continue;
                        }
                        currTask = item;
                        break;
                    }
                    break;
                //查找需要完成的子任务
                case SubTaskStateEnum.已完成:
                    currTask = dbOrm.ware_task_sub.Where(x => x.DeviceId == int_deviceId && x.TaskState == (int)SubTaskStateEnum.已下发).ToList().OrderBy(x => x.CreatedTime).FirstOrDefault();//按照主任务优先级的升序排序
                    break;
            }
            return currTask;
        }

        /// <summary>
        /// 当设备任务完成后，验证站点是否有其他任务被占用
        /// </summary>
        /// <param name="dbModel"></param>
        /// <param name="placeId"></param>
        /// <param name="excludeTaskId">本次任务排除</param>
        /// <returns></returns>
        public bool ValdiatePalceIsUsedByTask(DbOrm dbModel, int placeId, string excludeTaskId)
        {
            try
            {
                var queryState1 = (int)SubTaskStateEnum.已取消;
                var queryState2 = (int)SubTaskStateEnum.已完成;
                //int srmCount = dbModel.ware_task_sub.Count(x => x.TaskState != queryState1 && x.TaskState != queryState2 && (x.SourcePlace == placeId || x.ToPlace == placeId) && x.Id != excludeTaskId);
                //if (srmCount > 0)
                //{
                //    return false;
                //}
                //int rgvCount = dbModel.ware_task_sub.Count(x => x.TaskState != queryState1 && x.TaskState != queryState2 && (x.SourcePlace == placeId || x.ToPlace == placeId) && x.Id != excludeTaskId);
                //if (rgvCount > 0)
                //{
                //    return false;
                //}

                return true;
            }
            catch (Exception ex)
            {
                throw;
            }
        }

        #endregion

        #region 获取指定任务阶段的某个设备的所有任务列表

        /// <summary>
        /// 获取指定任务阶段的某个设备的所有任务列表
        /// </summary>
        /// <param name="dbModel"></param>
        /// <param name="int_deviceId"></param>
        /// <param name="_TaskExcuteTypeEnum"></param>
        /// <returns></returns>
        public List<ware_task_sub> GetPartListByDevice(DbOrm dbModel, int int_deviceId, TaskExcuteTypeEnum _TaskExcuteTypeEnum)
        {
            switch (_TaskExcuteTypeEnum)
            {
                case TaskExcuteTypeEnum.执行任务:
                    return dbModel.ware_task_sub.Where(x => x.DeviceId == int_deviceId && x.TaskState == (int)SubTaskStateEnum.未开始).ToList().OrderBy(x => x.CreatedTime).ToList();//按照主任务的顺序升序
                case TaskExcuteTypeEnum.结束任务:
                    return dbModel.ware_task_sub.Where(x => x.DeviceId == int_deviceId && x.TaskState == (int)SubTaskStateEnum.已下发).ToList().OrderBy(x => x.CreatedTime).ToList();//按照主任务的顺序升序
                default:
                    return null;
            }
        }

        #endregion

    }
}