using MaterialTraceability.Common;
using MaterialTraceability.Entity.DAO;
using MaterialTraceability.Entity.DTO;
using MaterialTraceability.Entity.Enum;
using MaterialTraceability.SqlSugar;
using MaterialTraceability.SqlSugar.ServiceImpl;
using MaterialTraceability.WebService;
using MaterialTraceability.WebService.MiReleaseSfcWithActivityServiceService;
using MaterialTraceability.WebService.Param;
using MaterialTraceability.WebService.ProcessLotServiceWSService;
using System;
using System.Collections.Generic;
using System.Linq; 

using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace MaterialTraceability.Business.Impl
{
    /// <summary>
    /// 涂布信号逻辑处理
    /// </summary>
    public class TBSignalReadBusiness : ISignalReadFunction
    {
        // INIFile配置文件
        private INIFile inifile = new INIFile(System.Environment.CurrentDirectory + "/MesConfig/App.InI");
        private INIFile appinifile = new INIFile(System.Environment.CurrentDirectory + "/App.InI");

        /// <summary>
        /// 日志刷新
        /// </summary>
        /// <param name="type">日志内容</param>
        /// <param name="massage"></param>
        public delegate void LogRefresh(LogType logType, string massage);
        public static event LogRefresh LogRefreshEvent;


        /// <summary>
        /// 视图层数据刷新
        /// </summary>
        /// <param name="viewModelDto"></param>
        public delegate void ViewModelRefresh(ViewModelDto viewModelDto);
        public static event ViewModelRefresh ViewModelRefreshEvent;

        /// <summary>
        /// 涂布工单下达获取结果事件
        /// </summary>
        /// <param name="result"></param>
        /// <param name="sfc"></param>
        public delegate void GetSFCByMes(bool result, string sfc);
        public static event GetSFCByMes GetSFCByMesEvent;

        /// <summary>
        /// 涂布结束流程
        /// </summary>
        /// <param name="sfc"></param>
        /// <param name="proDownRecord"></param>
        public delegate void EndProduction(int ea, ProShaftInfo proDownRecord);
        public static event EndProduction EndProductionEvent;

        /// <summary>
        /// 清空流程界面
        /// </summary>
        public delegate void ClearViewRefresh();
        public static event ClearViewRefresh ClearViewRefreshEvent;

        /// <summary>
        /// 异常处理流程刷新
        /// </summary>
        public delegate void TBAlarmRecordRefresh();
        public static event TBAlarmRecordRefresh TBAlarmRecordRefreshEvent;

        /// <summary>
        /// PLC信号事件
        /// </summary>
        /// <param name="status"></param>
        /// <param name="position"></param>
        public delegate void SignalReadInvoke(int status, int position);

        /// <summary>
        /// RFID读写器业务
        /// </summary>
        private EquipBusiness equipBusiness = new EquipBusiness();

        /// <summary>
        /// Mes WebService接口
        /// </summary>
        private IMesWebServices MesWebServices = new MesWebServicesImpl();

        //卷轴信息
        private IBaseServices<ProShaftInfo> shaftInfoServices = new BaseServices<ProShaftInfo>();

        //收卷记录
        private IBaseServices<ProDownRecord> downRecordServices = new BaseServices<ProDownRecord>();

        private IBaseServices<SysClient> sysClientServices = new BaseServices<SysClient>();

        private MesAlarmInfo alarmInfo = new MesAlarmInfo();

        private PlcBusiness plcBusiness = new PlcBusiness();

        private UpLoadBusiness upLoadBusiness = UpLoadBusiness.Instance;

        private AppConfigDto appConfig = AppConfigDto.Instance;
        string ran = "";
        /// <summary>
        /// 放卷位涨紧
        /// </summary>
        /// <param name="position"></param>
        public void UpMaterialBegin(int position)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 放卷位结束
        /// </summary>
        /// <param name="position"></param>
        public void UpMaterialEnd(int position)
        {
            throw new NotImplementedException();
        }
        ///add by yinzf
        /// <summary>
        /// 
        /// </summary>
        /// <param name="position"></param>
        public void UpBegin(int position)
        {

        }
        //end add

        public async Task<bool> GetSameRFIDInfo(int position, string epc)
        {
            bool iFlag = false;
            try
            {

                if (position == 1)
                {
                    position = 2;
                }
                else
                {
                    position = 1;
                }
                Expression<Func<ProShaftInfo, bool>> exp = s1 => true;
                exp = exp.And(x => x.positionId == position.ToString() && x.processId == appConfig.processId);
                List<ProShaftInfo> result = await shaftInfoServices.Query(exp);

                if (result != null || result.Count > 0)
                {
                    
                    ProShaftInfo shaftInfo = result.FirstOrDefault();
                    if (shaftInfo.bindRfid == epc)
                    {
                        return true;
                    }

                }
            }
            catch (Exception ex)
            {

            }
            return iFlag;
        }

        /// <summary>
        /// 收卷位涨紧
        /// </summary>
        /// <param name="position"></param>
        public async void DownMaterialBegin(int position)
        {
            if (appConfig.PLCType.Contains("HNTBPLcAddress"))
            {
                plcBusiness.writePlc(appConfig.TbAddress.气涨泄气,0);
            }
            string logStr = position == 1 ? LanguageHelper.ShowMessage("A轴") : LanguageHelper.ShowMessage("B轴");
            #region 未登录不让涨紧生产，便于记录生产者
            /*if (StringExtension.IsBlank(ConfigHelper.GetConfig("roleId")))
            {
                MessageBox.Show("请先登录再开始生产");
                LogHelper.Info("请先登录再开始生产");
                LogRefreshEvent?.Invoke(LogType.AlarmLog, "请先登录再开始生产");
                return;
            }*/
            #endregion

            //string sfc = "";
            try
            {
                //获取当前涨紧卷轴 A轴：1，B轴：2
                LogRefreshEvent?.Invoke(LogType.PlcLog, logStr + LanguageHelper.ShowMessage("收卷涨紧触发成功"));
                LogHelper.Info(logStr + "收卷涨紧触发成功");
                LogRefreshEvent?.Invoke(LogType.RfidLog, logStr+ LanguageHelper.ShowMessage("开始读取卷筒RFID物料信息"));
                LogHelper.Info(String.Format("开始读取{0}卷筒RFID物料信息", logStr));
                //读取卷筒RFID物料信息
                ProEquip proEquip = equipBusiness.Equiplist.Where(x => x.positionId == position).FirstOrDefault();
                if(proEquip == null)
                {
                    LogRefreshEvent?.Invoke(LogType.RfidLog,  logStr + LanguageHelper.ShowMessage("获取RFID设备信息异常"));
                    return;
                }
                string epc = equipBusiness.ReadEPCByAntana(proEquip.equipId);
                //string epc = System.Guid.NewGuid().ToString("N").Substring(0,14);
                epc = epc.Replace("\0", "").Trim();
                if (epc == "" || epc == null)
                {
                    //Random random = new Random();
                    if (!string.IsNullOrEmpty(appinifile.IniReadValue("SystemConfig", "RFIDnum")))
                    {
                        ran = appinifile.IniReadValue("SystemConfig", "RFIDnum");
                        ran = ran.PadLeft(6, '0');
                        epc = "CATT1RDA" + ran; 
                    }
                }

                //20231028新增读取到上一次相同标签报警泄气
                bool iFlag = await GetSameRFIDInfo(position, epc);
                if (iFlag)
                {
                    //读取失败，控制PLC气胀轴
                    plcBusiness.writePlc(appConfig.TbAddress.气涨泄气, 1);
                    //写入报警
                    plcBusiness.writePlc(appConfig.TbAddress.RFID异常, 1);
                    //写入转塔是否可以旋转
                    plcBusiness.writePlc(appConfig.TbAddress.是否转塔, 0);
                    string str = position == 1 ? LanguageHelper.ShowMessage("B轴") : LanguageHelper.ShowMessage("A轴");
                    //if (position == 1)
                    //{
                    //    str = "B轴";
                    //}
                    //else
                    //{
                    //    str = "A轴";
                    //}
                    LogHelper.Info("RFID条码信息与" + str + "读取相同，请更换卷筒或标签");

                    LogRefreshEvent?.Invoke(LogType.RfidLog, logStr + LanguageHelper.ShowMessage("RFID条码信息读取相同与") + str + LanguageHelper.ShowMessage("请更换卷筒或标签"));
                    LogRefreshEvent?.Invoke(LogType.AlarmLog, logStr + LanguageHelper.ShowMessage("RFID条码信息读取相同与") + str + LanguageHelper.ShowMessage("请更换卷筒或标签"));
                    ViewModelRefreshEvent?.Invoke(new ViewModelDto()
                    {
                        rfidInfo = new RfidInfoDto()
                        {
                            rfid = "",
                            sfc = "",
                            ea = "",
                            position = position,
                        },
                        plcStatus = true,
                    });
                    return;
                }
                if (StringExtension.IsBlank(epc) || (!epc.Contains("JSLY") && !epc.Contains("CATT") && !epc.Contains("YBC")))
                {

                    //读取失败，控制PLC气胀轴
                    plcBusiness.writePlc(appConfig.TbAddress.气涨泄气, 1);
                    //写入报警
                    plcBusiness.writePlc(appConfig.TbAddress.RFID异常, 1);
                    //写入转塔是否可以旋转
                    plcBusiness.writePlc(appConfig.TbAddress.是否转塔, 0);
                    LogHelper.Info("RFID条码信息读取失败，下发气胀轴泄气");

                    LogRefreshEvent?.Invoke(LogType.RfidLog, logStr + LanguageHelper.ShowMessage("RFID条码信息读取失败"));
                    LogRefreshEvent?.Invoke(LogType.AlarmLog, logStr + LanguageHelper.ShowMessage("RFID条码信息读取失败"));
                    
                    return;
                }
                LogHelper.Info("收卷位设备：" + proEquip.equipIp + "涨紧信号读取成功：" + epc);

                LogRefreshEvent?.Invoke(LogType.RfidLog, logStr + LanguageHelper.ShowMessage("RFID条码信息读取成功：") + epc);
                
                lock(string.Empty)
                {
                    LogHelper.Info("判断RFID标签是否重复");
                    
                    if (BusinessHelper.DownRfidIsRecur(epc,position).Result)
                    {

                        ////读取失败，控制PLC气胀轴
                        //plcBusiness.writePlc(appConfig.TbAddress.气涨泄气, 1);
                        ////写入报警
                        //plcBusiness.writePlc(appConfig.TbAddress.RFID异常, 1);
                        ////写入转塔是否可以旋转
                        //plcBusiness.writePlc(appConfig.TbAddress.是否转塔, 0);


                        LogHelper.Info(logStr + "RFID读取到的条码：" + epc + "与前一读取相同不做MES处理");

                        LogRefreshEvent?.Invoke(LogType.RfidLog, logStr + epc + LanguageHelper.ShowMessage("RFID读取到的条码与前一读取相同不做MES处理"));
                        LogRefreshEvent?.Invoke(LogType.AlarmLog, logStr + epc + LanguageHelper.ShowMessage("RFID读取到的条码与前一读取相同不做MES处理"));
                        plcBusiness.writePlc(appConfig.TbAddress.气涨泄气, 0);
                        plcBusiness.writePlc(appConfig.TbAddress.RFID异常, 0);
                        plcBusiness.writePlc(appConfig.TbAddress.是否转塔, 1);
                        return;
                    }
                    //SaveReadRecord(proEquip, epc);
                    MesBegin(position, epc, true);
                }            
            }
            catch (Exception ex)
            {
                LogHelper.Error("涂布工序收卷位涨紧逻辑处理异常",ex);
            }
        }

        /// <summary>
        /// 收卷位结束
        /// </summary>
        /// <param name="position"></param>
        public async void DownMaterialEnd(int position)
        {
            string logStr = position == 1 ? LanguageHelper.ShowMessage("A轴") : LanguageHelper.ShowMessage("B轴");
            try
            {
                LogRefreshEvent?.Invoke(LogType.PlcLog, logStr + LanguageHelper.ShowMessage("收卷结束信号触发成功"));
                LogHelper.Info(logStr + "收卷结束信号触发成功");
                
                //获取收卷轴绑定的RFID条码信息,取最新数据
                Expression<Func<ProShaftInfo, bool>> exp = s1 => true;
                exp = exp.And(x => x.positionId == position.ToString() && x.processId == appConfig.processId);
                Expression<Func<ProShaftInfo, object>> order = (x) => x.bindTime;
                ProShaftInfo shaftInfo = await shaftInfoServices.QueryFirst(exp, order, false);

                if (StringExtension.IsBlank(shaftInfo.bindRfid))
                {
                    LogRefreshEvent?.Invoke(LogType.RfidLog, logStr + LanguageHelper.ShowMessage("收卷完工获取绑定信息为空不进入结束流程") );
                    LogRefreshEvent?.Invoke(LogType.AlarmLog, logStr + LanguageHelper.ShowMessage("收卷完工获取绑定信息为空不进入结束流程"));
                    LogHelper.Info(String.Format("{0}收卷完工获取绑定信息为空不进入结束流程", logStr));
                    return;
                }

                LogHelper.Info(String.Format("{0}当前绑定的物料信息为：{1}", logStr, JsonChange.ModeToJson(shaftInfo)));

                //下发禁止下料信号
                plcBusiness.writePlc(appConfig.TbAddress.控制下料, 0);
                LogRefreshEvent?.Invoke(LogType.PlcLog, logStr + LanguageHelper.ShowMessage("收卷结束，下发禁止下料信号"));
                //plcBusiness.writePlc(appConfig.TbAddress.控制下料, 1);

                int eaValue = PlcBusiness.readPlc(appConfig.TbAddress.收卷轴米数);
                LogRefreshEvent.Invoke(LogType.PlcLog, LanguageHelper.ShowMessage("读取涂布机收卷米数：") + eaValue);
                LogHelper.Info("读取涂布机收卷米数：" + eaValue);
                string membraneLength = GetSysConfigList("SysConfig").Where(x => x.paramKey == "membraneLength").FirstOrDefault().paramValue;
                string volumesNumber = GetSysConfigList("SysConfig").Where(x => x.paramKey == "volumesNumber").FirstOrDefault().paramValue;

                LogHelper.Info("获取设备膜长："+ membraneLength+"；系数："+ volumesNumber);
                eaValue = Convert.ToInt32(Convert.ToDouble(eaValue) / Convert.ToDouble(membraneLength) * Convert.ToDouble(volumesNumber));
                LogRefreshEvent.Invoke(LogType.PlcLog, LanguageHelper.ShowMessage( "读取涂布机收卷EA值：") + eaValue);
                LogHelper.Info("读取涂布机收卷EA值：" + eaValue);
                LogHelper.Info("日志排查进入收卷完工操作前，打印绑定信息shaftInfo:" + JsonChange.ModeToJson(shaftInfo));
                //收卷完工操作
                EndProductionEvent?.Invoke(eaValue, shaftInfo);



                //刷新异常处理流程
                TBAlarmRecordRefreshEvent?.Invoke();
            }
            catch (Exception ex)
            {
                LogHelper.Error("涂布工序收卷位结束逻辑处理异常", ex);
            }
        }

        /// <summary>
        /// 解绑RFID与SFC(涂布暂时不需要解绑)
        /// </summary>
        /// <param name="rfidStr"></param>
        private void UnBindRfidAndSfc(int position,string rfidStr)
        {
            //获取当前RFID是否绑定
            string sfcStr = "";
            DateTime beginTime = new DateTime();
            ProcessLotServiceWSServiceParam processLotServiceWSServiceParam = new ProcessLotServiceWSServiceParam()
            {
                //url = "http://lymesa.catlbattery.com:8103/manufacturing-papiservices/ProcessLotServiceWSService?wsdl",
                //site = "2100",
                url = inifile.IniReadValue("ProcessLotServiceWSServiceParam", "url"),
                site = inifile.IniReadValue("ProcessLotServiceWSServiceParam", "site"),
                processlotref = String.Format("ProcessLotBO:2400,{0}", rfidStr),
                loginUser = inifile.IniReadValue("ProcessLotServiceWSServiceParam", "loginUser"),
                password = inifile.IniReadValue("ProcessLotServiceWSServiceParam", "password"),
            };

            try
            {
                LogRefreshEvent?.Invoke(LogType.MesLog, LanguageHelper.ShowMessage("调用MES接口获取RFID绑定的SFC"));
                LogHelper.Info("MES获取膜卷号接口请求参数：" + JsonChange.ModeToJson(processLotServiceWSServiceParam));

                if (appConfig.isMesFlag == 1)
                {
                    readProcessLotResponse readProcessLotResponse = MesWebServices.readProcessLot(processLotServiceWSServiceParam);
                    LogHelper.Info("MES获取膜卷号接口返回参数：" + JsonChange.ModeToJson(readProcessLotResponse));
                    if (readProcessLotResponse.Response.processLotMemberList != null)
                    {
                        sfcStr = readProcessLotResponse.Response.processLotMemberList[0].memberContext.Substring(11);
                        LogHelper.Info("RFID条码：" + rfidStr + "绑定的SFC条码为：" + sfcStr);
                        LogRefreshEvent?.Invoke(LogType.MesLog, rfidStr + LanguageHelper.ShowMessage( "RFID条码绑定的SFC条码为：") + sfcStr);
                    }
                }
                else
                {
                    //sfcStr = System.Guid.NewGuid().ToString("N").Substring(0, 14);
                    Random random = new Random();
                    sfcStr = "LYL3PC0223082400" + random.Next(10, 99);
                }
            }
            catch (Exception ex)
            {
                LogHelper.Info("MES获取膜卷号接口调用异常：" + ex.Message);
                LogRefreshEvent?.Invoke(LogType.AlarmLog, LanguageHelper.ShowMessage("MES获取膜卷号接口调用异常：")+ ex.Message);
                WebServiceLog.saveReadProcessLot(processLotServiceWSServiceParam, null, beginTime, ex.Message);
                return;
            }

            if (!StringExtension.IsBlank(sfcStr))
            {
                ProcessLotServiceWSServiceParam lotServiceWSServiceParam = new ProcessLotServiceWSServiceParam()
                {
                    url = inifile.IniReadValue("ProcessLotServiceWSServiceParam", "url"),
                    site = inifile.IniReadValue("ProcessLotServiceWSServiceParam", "site"),
                    processlotref = "ProcessLotBO:2400," + rfidStr,
                    memberlist = new string[] { "SFCBO:2400," + sfcStr },
                    loginUser = inifile.IniReadValue("ProcessLotServiceWSServiceParam", "loginUser"),
                    password = inifile.IniReadValue("ProcessLotServiceWSServiceParam", "password"),

                };
                LogHelper.Info("MES解绑接口请求参数：" + JsonChange.ModeToJson(lotServiceWSServiceParam));
                beginTime = DateTime.Now;
                try
                {
                    if (appConfig.isMesFlag == 1)
                    {
                        removeMemberResponse removeMember = MesWebServices.iRemoveMember(lotServiceWSServiceParam);
                        LogHelper.Info("MES解绑接口返回参数：" + JsonChange.ModeToJson(removeMember));
                    }
                }
                catch (Exception ex)
                {
                    WebServiceLog.saveRemoveMember(processLotServiceWSServiceParam, null, beginTime, ex.Message);
                    LogRefreshEvent?.Invoke(LogType.MesLog, LanguageHelper.ShowMessage("MES解绑接口调用异常：") + ex.Message);
                    LogRefreshEvent?.Invoke(LogType.AlarmLog, rfidStr+ LanguageHelper.ShowMessage("RFID条码解绑失败") + ex.Message);

                    return;
                }
            }
            else
            {
                LogHelper.Info("RFID条码：" + rfidStr + "未绑定SFC信息");
                LogRefreshEvent?.Invoke(LogType.RfidLog, rfidStr+ LanguageHelper.ShowMessage("RFID条码未绑定SFC信息"));
            }
        }

        /// <summary>
        /// 卷筒涨紧MES处理信号
        /// </summary>
        /// <param name="postion"></param>
        /// <param name="epc"></param>
        /// <param name="auto">是否是自动读取，如果不是自动读取需要把PLC信号清掉</param>
        public async void MesBegin(int position, string epc, bool auto)
        {
            string logStr = position == 1 ? LanguageHelper.ShowMessage("A轴") : LanguageHelper.ShowMessage("B轴");
            string sfc = "";    
            if (!auto)
            {
                //清除泄气信号
                plcBusiness.writePlc(appConfig.TbAddress.气涨泄气, 0);
                //清除报警
                plcBusiness.writePlc(appConfig.TbAddress.RFID异常, 0);
            }
            try
            {

                #region Add By wenjy 2022-09-20 获取工单信息，判断是否需要更换工单
                if (appConfig.isMesFlag == 1)
                {
                    if (!ShopOrderAlarm(position))
                    {
                        //MES接口返回异常，控制PLC气胀轴写1泄气
                        plcBusiness.writePlc(appConfig.TbAddress.气涨泄气, 1);
                        //写入报警
                        plcBusiness.writePlc(appConfig.TbAddress.MES异常, 1);
                        return;
                    }
                }
                  
                #endregion

                //调用MES接口获取SFC
                #region Update By wenjy 2022-09-20 涂布工单下达逻辑修改
                sfc = GetSFC(position);
                if (StringExtension.IsBlank(sfc))
                {
                    return;
                }
                #endregion

                LogHelper.Info("涂布工单下达接口调用成功，SFC膜卷号为：" + sfc);
                LogRefreshEvent?.Invoke(LogType.MesLog, LanguageHelper.ShowMessage( "MES涂布工单下达接口调用成功,膜卷号：") + sfc);
                GetSFCByMesEvent?.Invoke(true, sfc);

                WriteSfcAndEpc(position, sfc, epc);
                if (!string.IsNullOrEmpty(appinifile.IniReadValue("SystemConfig", "RFIDnum")))
                {
                    appinifile.IniWriteValue("SystemConfig", "RFIDnum", int.Parse(appinifile.IniReadValue("SystemConfig", "RFIDnum") + 1).ToString());
                }

                ViewModelRefreshEvent?.Invoke(new ViewModelDto()
                {
                    rfidInfo = new RfidInfoDto()
                    {
                        rfid = epc,
                        position = position,
                        sfc = sfc,
                        ea = "",
                    },
                    plcStatus = true,
                });
                LogHelper.Info("本地保存RFID及膜卷号信息生成收卷记录");

                //实时绑定卷轴与RFID信息
                LogHelper.Info(String.Format("绑定{0}卷轴与RFID:{1}获取卷轴信息", logStr, epc));
                Expression<Func<ProShaftInfo, bool>> exp = s1 => true;
                exp = exp.And(x => x.positionId == position.ToString() && x.processId == appConfig.processId);
                Expression<Func<ProShaftInfo, object>> order = (x) => x.bindTime;
                ProShaftInfo shaftInfo = await shaftInfoServices.QueryFirst(exp, order, true);

                if (shaftInfo == null)
                {
                    LogRefreshEvent?.Invoke(LogType.RfidLog, LanguageHelper.ShowMessage("绑定卷轴与RFID条码获取卷轴信息为空"));
                    LogRefreshEvent?.Invoke(LogType.AlarmLog, LanguageHelper.ShowMessage("绑定卷轴与RFID条码获取卷轴信息为空"));
                    LogHelper.Info("绑定卷轴与RFID获取卷轴信息为空");
                    return;
                }
                LogHelper.Info("获取卷轴信息为：" + JsonChange.ModeToJson(shaftInfo));
                shaftInfo.bindRfid = epc;
                shaftInfo.bindSfc = sfc;
                shaftInfo.bindTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                await shaftInfoServices.Update(shaftInfo);

                LogHelper.Info("本地绑定RFID：" + epc + ",SFC：" + sfc);
                //PLC允许转塔 D9602写1
                plcBusiness.writePlc(appConfig.TbAddress.是否转塔, 1);
                plcBusiness.writePlc(appConfig.TbAddress.MES异常, 0);
                plcBusiness.writePlc(appConfig.TbAddress.RFID异常, 0);

                //添加下料记录
                ProDownRecord downRecord = new ProDownRecord()
                {
                    Id = System.Guid.NewGuid().ToString("N"),
                    MachineId = appConfig.machineId,
                    PositionId = position,
                    Rfid = epc,
                    Sfc = sfc,
                    IsProduction = 0,
                    beginTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                    RecordTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
                };
                await downRecordServices.Add(downRecord);
               
                
                //upLoadBusiness.SaveDownRecord(downRecord);
            }
            catch (Exception e)
            {
                LogHelper.Info(e.ToString());
            }

        }

        private void WriteSfcAndEpc(int position,string sfcStr,string rfidStr)
        {
            if (position == 1)
            {
                LogHelper.Info("将SFC与RFID写入PLC地址");
                PlcBusiness.writeStrPlc(appConfig.TbAddress.A轴膜卷号, sfcStr);
                PlcBusiness.writeStrPlc(appConfig.TbAddress.A轴标签号, rfidStr);
                //LogRefreshEvent?.Invoke(LogType.PlcLog, "将SFC与RFID写入PLC地址");
            }
            else
            {
                LogHelper.Info("将SFC与RFID写入PLC地址");
                PlcBusiness.writeStrPlc(appConfig.TbAddress.B轴膜卷号, sfcStr);
                PlcBusiness.writeStrPlc(appConfig.TbAddress.B轴标签号, rfidStr);
                //LogRefreshEvent?.Invoke(LogType.PlcLog, "将SFC与RFID写入PLC地址");
            }

        }

        /// <summary>
        /// 涂布工单下达
        /// </summary>
        /// <returns></returns>
        private string GetSFC(int position)
        {
            string sfc = "";
            LogHelper.Info("调用MES涂布工单下达接口");
            LogRefreshEvent?.Invoke(LogType.MesLog, LanguageHelper.ShowMessage( "调用MES涂布工单下达接口"));
            //调MES涂布工单下达接口获取SFC
            MiReleaseSfcWithActivityServiceServiceParam miReleaseSfcWithActivityServiceServiceParam = new MiReleaseSfcWithActivityServiceServiceParam()
            {
                url = inifile.IniReadValue("MiReleaseSfcWithActivityServiceServiceParam","url"),
                site = inifile.IniReadValue("MiReleaseSfcWithActivityServiceServiceParam", "site"),
                user = inifile.IniReadValue("MiReleaseSfcWithActivityServiceServiceParam", "user"),
                operation = appConfig.operationByA,
                operationRevision = inifile.IniReadValue("MiReleaseSfcWithActivityServiceServiceParam", "operationRevision"),
                activityId = inifile.IniReadValue("MiReleaseSfcWithActivityServiceServiceParam", "activity"),
                Resource = appConfig.resource,
                sfcQty = 1,
                modeProcessSfc = modeProcessSFC.MODE_START_SFC, //MODE_START_SFC
                isCarrierType = false,
                loginUser = inifile.IniReadValue("MiReleaseSfcWithActivityServiceServiceParam", "loginUser"),
                password = inifile.IniReadValue("MiReleaseSfcWithActivityServiceServiceParam", "password"),
            };
            DateTime beginTime = DateTime.Now;
            try
            {
                LogHelper.Info("涂布工单下达接口请求参数：" + JsonChange.ModeToJson(miReleaseSfcWithActivityServiceServiceParam));

                if (appConfig.isMesFlag == 1)
                {
                    miReleaseSfcWithActivityResponse releaseSfcWithActivityResponse = MesWebServices.iMiReleaseSfcWithActivityServiceService(miReleaseSfcWithActivityServiceServiceParam);
                    LogHelper.Info("涂布工单下达接口返回参数：" + JsonChange.ModeToJson(releaseSfcWithActivityResponse));
                    if (releaseSfcWithActivityResponse.@return.code > 0)
                    {
                        LogRefreshEvent?.Invoke(LogType.MesLog, LanguageHelper.ShowMessage( "涂布工单获取调用MES接口失败：") + releaseSfcWithActivityResponse.@return.code + releaseSfcWithActivityResponse.@return.message);
                        LogRefreshEvent?.Invoke(LogType.AlarmLog, LanguageHelper.ShowMessage("涂布工单获取调用MES接口失败：") + releaseSfcWithActivityResponse.@return.code+releaseSfcWithActivityResponse.@return.message);
                        GetSFCByMesEvent?.Invoke(false, "");
                        //亚康MES报警未泄气，暂时用RFID异常代替MES报警泄气，待厂家改造
                        if (appConfig.PLCType.Contains("YKTBPLcAddress"))
                        {
                            plcBusiness.writePlc(appConfig.TbAddress.RFID异常, 1);
                        }
                        //MES接口返回异常，控制PLC气胀轴写1泄气
                        plcBusiness.writePlc(appConfig.TbAddress.气涨泄气, 1);
                        //写入报警
                        plcBusiness.writePlc(appConfig.TbAddress.MES异常, 1);
                        //写入转塔是否可以旋转
                        plcBusiness.writePlc(appConfig.TbAddress.是否转塔, 0);
                        LogHelper.Info("涂布工单下达接口获取失败：" + releaseSfcWithActivityResponse.@return.message + "，下发气胀轴泄气，下发MES接口返回异常报警");

                        return "";
                    }
                    sfc = releaseSfcWithActivityResponse.@return.sfcArray[0].sfc;
                }
                else
                {
                    //sfc = System.Guid.NewGuid().ToString("N").Substring(0, 14);
                    Random random = new Random();
                    sfc = "LYL3PC0223082400" + random.Next(10, 99);
                }
                return sfc;
            }
            catch (Exception ex)
            {
                WebServiceLog.saveMiReleaseSfcWithActivityServiceService(miReleaseSfcWithActivityServiceServiceParam, null, beginTime, ex.Message);

                LogRefreshEvent?.Invoke(LogType.AlarmLog,LanguageHelper.ShowMessage( "涂布工单下达MES接口调用异常：") + ex.Message);
                LogRefreshEvent?.Invoke(LogType.MesLog, LanguageHelper.ShowMessage( "涂布工单下达MES接口调用异常:") + ex.Message);
                GetSFCByMesEvent?.Invoke(false, "");
                //亚康MES报警未泄气，暂时用RFID异常代替MES报警泄气，待厂家改造
                if (appConfig.PLCType.Contains("YKTBPLcAddress"))
                {
                    //plcBusiness.writePlc(appConfig.TbAddress.RFID异常, 1);
                }
                //读取失败，控制PLC气胀轴
                plcBusiness.writePlc(appConfig.TbAddress.气涨泄气, 1);
                //写入报警
                plcBusiness.writePlc(appConfig.TbAddress.MES异常, 1);
                //写入转塔是否可以旋转
                plcBusiness.writePlc(appConfig.TbAddress.是否转塔, 0);
                return "";
            }
        }

        /// <summary>
        /// 工单预警
        /// </summary>
        /// <returns></returns>
        private bool ShopOrderAlarm(int position)
        {
            try
            {
                //获取工单预警设置
                var shopOrderConfig = GetSysConfigList("ShopOrderAlarm");
                if (shopOrderConfig.Count == 0)
                {
                    LogRefreshEvent?.Invoke(LogType.AlarmLog, LanguageHelper.ShowMessage( "获取工单预警设置信息为空"));
                    LogHelper.Info("获取工单预警设置信息为空");
                    return false;
                }
                string shopOrderStr = shopOrderConfig.Where(x => x.paramKey == "ShopOrder").FirstOrDefault().paramValue;
                string orderAlarmAmount = shopOrderConfig.Where(x => x.paramKey == "OrderAlarmAmount").FirstOrDefault().paramValue;
                FindShopRequestParam findShopRequestParam = new FindShopRequestParam()
                {
                    url = inifile.IniReadValue("FindShopRequestParam","url"),
                    site = inifile.IniReadValue("FindShopRequestParam", "site"),
                    shopOrder = String.Format("ShopOrderBO:2400,{0}", shopOrderStr),
                    loginUser = inifile.IniReadValue("FindShopRequestParam", "loginUser"),
                    password = inifile.IniReadValue("FindShopRequestParam", "password"),
                };
                LogHelper.Info("调用MES获取工单产量信息接口请求参数："+ JsonChange.ModeToJson(findShopRequestParam));

                var info = MesWebServices.findShopOrder(findShopRequestParam);
                LogHelper.Info("调用MES获取工单产量信息接口返回参数："+JsonChange.ModeToJson(info)); 
                var quantityOrderd = info.Response.quantityOrdered; //工单总数量
                var quantityReleased = info.Response.quantityReleased;  //已下达数量

                if (Convert.ToDecimal(orderAlarmAmount) < quantityOrderd - quantityReleased)
                {
                    return true;
                }
                LogRefreshEvent?.Invoke(LogType.AlarmLog, LanguageHelper.ShowMessage( "工单超产，及时更换工单"));
                return false;
            }catch(Exception ex)
            {
                LogHelper.Error("工单预警判断异常:" + ex.ToString());
                LogRefreshEvent?.Invoke(LogType.AlarmLog, LanguageHelper.ShowMessage("工单预警判断异常：") +ex.Message);
                return false;
            }
        }

        /// <summary>
        /// 强制下料
        /// </summary>
        /// <param name="position"></param>
        public async void ForceDown(int position)
        {
            try
            {
                
                string logStr = position == 1 ? LanguageHelper.ShowMessage("A轴") : LanguageHelper.ShowMessage( "B轴");

                LogHelper.Info(logStr + "强制下料信号触发，下发下料信号");

                LogRefreshEvent?.Invoke(LogType.PlcLog, logStr + LanguageHelper.ShowMessage("强制下料信号触发成功"));

                LogRefreshEvent?.Invoke(LogType.PlcLog, logStr + LanguageHelper.ShowMessage("下发下料信号"));
                plcBusiness.writePlc(appConfig.TbAddress.控制下料, 0);

                string bindSfc = "";

                var shatInfo = await GetShaftInfoByPosition(position);

                if(shatInfo == null)
                {
                    LogHelper.Info("强制下料获取绑定信息为空");
                    return;
                }

                bindSfc = shatInfo.bindSfc;

                LogRefreshEvent?.Invoke(LogType.PlcLog, logStr + LanguageHelper.ShowMessage("获取绑定的SFC信息：") + bindSfc);

                //通过SFC获取下料信息
                Expression<Func<ProDownRecord, bool>> exp = s1 => true;
                exp = exp.And(x => x.Sfc == bindSfc && x.PositionId == position);
                Expression<Func<ProDownRecord, object>> order = s1 => s1.RecordTime;
                ProDownRecord downRecord = await downRecordServices.QueryFirst(exp, order, false);

                if (downRecord == null)
                {
                    TBAlarmRecordRefreshEvent?.Invoke();
                    LogRefreshEvent?.Invoke(LogType.RfidLog, logStr + LanguageHelper.ShowMessage("通过SFC获取下料信息为空") + bindSfc);
                    return;
                }

                downRecord.IsProduction = 3;
                downRecord.endTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

                if (downRecord.eaValue < 15)
                {
                    int eaValue = PlcBusiness.readPlc(appConfig.TbAddress.收卷轴米数);
                    LogRefreshEvent.Invoke(LogType.PlcLog, LanguageHelper.ShowMessage("读取涂布机收卷米数：") + eaValue);
                    LogHelper.Info("读取设备收卷米数：" + eaValue);
                    string membraneLength = GetSysConfigList("SysConfig").Where(x => x.paramKey == "membraneLength").FirstOrDefault().paramValue;
                    string volumesNumber = GetSysConfigList("SysConfig").Where(x => x.paramKey == "volumesNumber").FirstOrDefault().paramValue;

                    LogHelper.Info("获取设备膜长：" + membraneLength + "；系数：" + volumesNumber);
                    eaValue = Convert.ToInt32(Convert.ToDouble(eaValue) / Convert.ToDouble(membraneLength) * Convert.ToDouble(volumesNumber));
                    LogRefreshEvent.Invoke(LogType.PlcLog, LanguageHelper.ShowMessage("读取涂布机收卷EA：") + eaValue);
                    LogHelper.Info("设备收卷EA值：" + eaValue);

                    downRecord.eaValue = eaValue;
                }

                bool updateResult = await downRecordServices.Update(downRecord);

                if (!updateResult)
                {
                    TBAlarmRecordRefreshEvent?.Invoke();
                    LogRefreshEvent?.Invoke(LogType.RfidLog, LanguageHelper.ShowMessage("强制下料状态更新失败"));
                    return;
                }
                //LogRefreshEvent?.Invoke(LogType.RfidLog, LanguageHelper.ShowMessage("强制下料状态更新成功"));

                LogRefreshEvent?.Invoke(LogType.PlcLog, logStr + LanguageHelper.ShowMessage("强制下料完成"));

                ClearViewRefreshEvent?.Invoke();
                //刷新异常处理流程状态
                TBAlarmRecordRefreshEvent?.Invoke();
            }
            catch(Exception ex)
            {
                LogRefreshEvent?.Invoke(LogType.RfidLog, "强制下料信号处理异常" + ex.Message);
                LogHelper.Error("强制下料信号处理异常", ex);
            }
        }

        public async Task<ProShaftInfo> GetShaftInfoByPosition(int position)
        {
            try
            {
                string str = appConfig.processId;
                Expression<Func<ProShaftInfo, bool>> exp = s1 => true;
                exp = exp.And(x => x.positionId == position.ToString() && x.processId == str);
                List<ProShaftInfo> result = await shaftInfoServices.Query(exp);

                if (result != null || result.Count > 0)
                {
                    ProShaftInfo shaftInfo = result.FirstOrDefault();
                    return shaftInfo;
                }
                return null;
            }
            catch (Exception ex)
            {
                LogRefreshEvent?.Invoke(LogType.RfidLog, LanguageHelper.ShowMessage( "获取卷轴信息为空"));
                LogHelper.Info("获取卷轴信息异常：" + ex.Message);
                return null;
            }
        }

        /// <summary>
        /// 收卷位开始信号
        /// </summary>
        /// <param name="position"></param>
        public void DownBegin(int position)
        {
            string logStr = position == 1 ? LanguageHelper.ShowMessage("A轴") : LanguageHelper.ShowMessage("B轴");
            try
            {

                LogHelper.Info(logStr + "收卷开始信号触发成功，解绑RFID绑定的SFC条码");
                LogRefreshEvent?.Invoke(LogType.PlcLog, logStr + LanguageHelper.ShowMessage( "收卷开始信号触发成功"));
                LogRefreshEvent?.Invoke(LogType.RfidLog, logStr + LanguageHelper.ShowMessage("解绑RFID绑定的SFC条码"));
                //获取RFID条码信息
                ProShaftInfo shaftInfo = this.GetShaftInfoByPosition(position).Result;
                this.UnBindRfidAndSfc(position, shaftInfo.bindRfid);
            }
            catch (Exception ex)
            {
                LogHelper.Info(logStr + "收卷开始信号逻辑处理异常：" + ex.Message);
                //upLoadBusiness.SaveLogRecord(position, logStr + "收卷开始信号逻辑处理异常：" + ex.Message);
            }
        }

        /// <summary>
        /// 获取配置列表
        /// </summary>
        /// <returns></returns>
        private List<SysClient> GetSysConfigList(string paramType)
        {
            try
            {
                Expression<Func<SysClient, bool>> exp = s1 => true;

                if (StringExtension.IsNotBlank(paramType))
                {
                    exp = exp.And(x => x.paramType == paramType);
                }

                exp = exp.And(x => x.processId == appConfig.processId);

                List<SysClient> info = sysClientServices.Query(exp).Result;

                return info;
            }catch(Exception ex)
            {
                LogHelper.Error("获取配置列表异常", ex);
                return null;
            }
        }

        /// <summary>
        /// 设备启动
        /// </summary>
        public void MachineStartUp()
        {
            throw new NotImplementedException();
        }

        private void SaveReadRecord(ProEquip equip, string rfidStr)
        {
            ProReadRecord readRecord = new ProReadRecord()
            {
                MachineID = equip.machineId,
                EquipID = equip.equipId,
                PositionID = equip.positionId,
                Ant = StringChange.ParseToInt(equip.equipAnt),
                ReadEPC = rfidStr,
                Result = StringExtension.IsBlank(rfidStr) ? "0" : "1",
                ReadTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
            };
            upLoadBusiness.SaveReadRecord(readRecord);
        }
    }
}