using Asa;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.NetworkInformation;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace OnlineStore.DeviceLibrary
{
    public partial class X_RAY_Equip : EquipBase
    {
        public bool OpenXLine = true;

        public ReelInfo In_ReelInfo = new ReelInfo();
        public ReelInfo Work_ReelInfo = new ReelInfo();
        public ReelInfo Out_ReelInfo = new ReelInfo();

        public XRay_Config Config;


        public XRay xRay = null; 
        public XrayImage xrayImage = null;

        public bool xRayCanStart = false;
        public string LastXRayState = "未知";
        public bool InXWork = false;

        public int ThresholdValue = ConfigAppSettings.GetIntValue(Setting_Init.ThresholdValue);
        private int ResultMinCount = -1;

        private string path_XRAY = Application.StartupPath + @"\XRAY\";
        private string path_XRAY_NGBck = Application.StartupPath + @"\XRAY\NGBck";
        private string path1_tif = Application.StartupPath + @"\XRAY\tif"; 
        private string path2_out = Application.StartupPath + @"\XRAY\out\";
        //private string path3_area = Application.StartupPath + @"\XRAY\area.txt";


        public X_RAY_Equip(string cid, XRay_Config config)
        {
            this.DeviceID = config.Id;
            this.Config = config;
            baseConfig = config;
            IsDebug = config.IsDebug.Equals(1);
            Name = (" " + "点料模块 ");

            Init();
            ledProcessTimer.Elapsed += LedProcess;
            IoCheckTimer.Elapsed += IoCheckTimerProcess;
            MoveInfo = new RobotMoveInfo(Name);
            SecMoveInfo = new RobotMoveInfo(Name.Trim() + "-SMove");
            XrayImage.setProcessLevel(4);
            Task.Factory.StartNew(delegate
            {
                XRayLoad();
            });

        }

        /// <summary>
        /// 图像平板报错
        /// </summary>
        public bool carerayImageError = false;
        private bool XRayLoad()
        {
            try
            {
                
                xRay = new XRay("XRay");

                xRay.WarmUp += XRay_WarmUp;
                string lastData = ConfigAppSettings.GetValue(Setting_Init.XRay_Data);
                bool xresult = xRay.Open(Config.XRay_Port, lastData);
                if (!xresult)
                {
                    LastXRayState = "第一次  xRay.Open(" + Config.XRay_Port + "," + lastData + ")=" + xresult + ", 再打开一次";
                    LogUtil.info(Name + "第一次  xRay.Open(" + Config.XRay_Port + "," + lastData + ")=" + xresult + ", 再打开一次 ");
                    xresult = xRay.Open(Config.XRay_Port, lastData);
                }
                LastXRayState = "xRay.Open(" + Config.XRay_Port + "," + lastData + ")=" + xresult;
                LogUtil.info(Name + "xRay.Open(" + Config.XRay_Port + "," + lastData + ")=" + xresult);

                if (!Directory.Exists(path1_tif))
                {
                    Directory.CreateDirectory(path1_tif);
                }
                if (!Directory.Exists(path2_out))
                {
                    Directory.CreateDirectory(path2_out);
                }
                
                ResultMinCount = ConfigAppSettings.GetIntValue(Setting_Init.ResultMinCount);
                if (ResultMinCount == -1)
                {
                    ResultMinCount = 100;
                }
                return true;
            }
            catch (Exception ex)
            {
                LogUtil.error("XRayLoad  出错：" + ex.ToString());
            }
            return true;
        }
        public bool ISXPlateReady = false;
        public bool XPlateUP()
        {
            IOMove(IO_Type.X_Xplate_Power, IO_VALUE.HIGH);
            LogUtil.info(Name + " 开始启动x光平板");
            var p = Process.GetProcessesByName("Server");
            if (p.Length > 0)
            {
                LogUtil.info(Name + " kill server");
                p.ToList().ForEach((a) => { a.Kill(); });
            }
            Thread.Sleep(1 * 1000);

            Ping ping = new Ping();
            var firstping = false;
            var secondping = false;
            var lastping = false;
            int timecount = 0;
            while (true)
            {
                var rr = ping.Send("192.168.68.1", 5);
                if (rr.Status == IPStatus.Success)
                {
                    if (!lastping && !firstping)
                    {
                        LogUtil.info(Name + " x光平板,第一次ping通");
                        firstping = true;
                        Thread.Sleep(1000 * 15);
                    }
                    if (!lastping && firstping && !secondping)
                    {
                        LogUtil.info(Name + " x光平板,第二次ping通");
                        secondping = true;
                        Thread.Sleep(1000 * 10);
                        break;
                    }
                    lastping = true;
                }
                else
                {
                    LogUtil.info(Name + " x光平板,未ping通");
                    lastping = false;
                }
                Thread.Sleep(500);
                timecount++;
                if (timecount > 120 * 100 / 500)
                {
                    LogUtil.info(Name + " x光平板,启动超时");
                    return false;
                }
            }
            if (xrayImage != null)
            {
                try
                {
                    xrayImage.Close();
                }
                catch { }
            }
            xrayImage = new XrayImage("XRay", XrayImage.DeviceType.CARREY);

            bool cResult = xrayImage.Open();
            LogUtil.info(Name + "carerayImage.Open()=" + cResult);
            carerayImageError = !cResult;
            if (carerayImageError)
                XPlateReStart();

            this.MoveStop = false;
            ISXPlateReady = true;

            return true;
        }
        public void XPlateReStart()
        {
            ISXPlateReady = false;
            IOMove(IO_Type.X_Xplate_Power, IO_VALUE.LOW);
            Thread.Sleep(1000*10);
            XPlateUP();
        }
        public void XRayDispose()
        {
            try
            {
                if (xRay!=null && xRay.IsRayOpen)
                {
                    xRay.Stop();
                }
                if (xRay != null)
                    xRay.Close();
                xrayImage.Close();
            }
            catch (Exception ex)
            {
                LogUtil.error("XRayDispose  出错：" + ex.ToString());
            }
        }

        private void XRay_WarmUp(bool state, string text)
        {
            LastXRayState = state + "：" + text;
            LogUtil.info(Name + "XRay_WarmUp [" + state + "] [" + text + "]");
            if (state)
            {
                xRay.SetVC(Config.XRay_Voltage, Config.XRay_Electricity);
                LogUtil.info(Name + "收到state= [" + state + "]，设置电流 [" + Config.XRay_Electricity + "]电压[" + Config.XRay_Voltage + "]");
                xRayCanStart = true;
            }
        }

        #region 启动，复位，停止 
        public override bool StartRun()
        {
            if (CanStartRun().Equals(false))
            {
                return false;
            }

            SetAllTimer(false);
            MoveInfo.EndMove();
            SecMoveInfo.EndMove();
            runStatus = RobotRunStatus.HomeMoving;
            MoveInfo.NewMove(RobotMoveType.RHome);
            LogInfo("开始 原点返回：   ");
            StartReset();
            
            SetAllTimer(true);
            return true;
        }


        public override bool Reset()
        {
            StopMove();
            runStatus = RobotRunStatus.Reset;
            MoveInfo.NewMove(RobotMoveType.Reset);
            LogInfo("开始重置：   ");
            StartReset();
            return true;
        }

        private void StartReset()
        {
            //TimerMaxSeconds = 10;
            SetWarnMsg("");
            carerayImageError = false;
            alarmType = AlarmType.None;
            isInSuddenDown = false;
            isNoAirCheck = false;
            isInPro = false;
            MoveInfo.NextMoveStep(StepEnum.XR01_CloseXLock);
            WorkLog("XRay复位 ：关闭X光互锁信号");
            IOMove(IO_Type.X_Lock_On, IO_VALUE.LOW);

        }

        protected override void ResetProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            if (MoveInfo.IsStep(StepEnum.XR01_CloseXLock))
            {
                MoveInfo.NextMoveStep(StepEnum.XR02_DoorOpen);
                CylinderMove(MoveInfo, IO_Type.X_InDoor_Up, IO_Type.X_InDoor_Down);
                CylinderMove(MoveInfo, IO_Type.X_OutDoor_Up, IO_Type.X_OutDoor_Down);
                if (IOValue(IO_Type.X_ReelCheck).Equals(IO_VALUE.HIGH) && IOValue(IO_Type.Out_TrayCheck).Equals(IO_VALUE.HIGH))
                {
                    WorkLog("XRay复位 ：左侧们打开，右侧门打开，挡停下降");
                    CylinderMove(MoveInfo, IO_Type.X_StopCylinder_Up, IO_Type.X_StopCylinder_Down);
                }
                else
                {
                    WorkLog("XRay复位 ：左侧们打开，右侧门打开，挡停不动作");
                }

            }
            else if (MoveInfo.IsStep(StepEnum.XR02_DoorOpen))
            {
                MoveInfo.NextMoveStep(StepEnum.XR03_LineRun);
                WorkLog(" XRay复位:  皮带转动6秒");

                if (IOValue(IO_Type.X_ReelCheck).Equals(IO_VALUE.LOW))
                {
                    if (IOValue(IO_Type.X_InLine_Check).Equals(IO_VALUE.LOW))
                    {
                        IOMove(IO_Type.X_InLine_Run, IO_VALUE.HIGH);
                    }
                    IOMove(IO_Type.X_MLine_Run, IO_VALUE.HIGH);
                }
                IOMove(IO_Type.X_OLine_Run, IO_VALUE.HIGH);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(6000));
            }
            else if (MoveInfo.IsStep(StepEnum.XR03_LineRun))
            {
                MoveInfo.NextMoveStep(StepEnum.XR04_LineStop);
                WorkLog(" XRay复位: 皮带停止转动");

                IOMove(IO_Type.X_InLine_Run, IO_VALUE.LOW);
                IOMove(IO_Type.X_MLine_Run, IO_VALUE.LOW);
                IOMove(IO_Type.X_OLine_Run, IO_VALUE.LOW);
            }
            else if (MoveInfo.IsStep(StepEnum.XR04_LineStop))
            {
                MoveInfo.NextMoveStep(StepEnum.XR05_DoorClose);
                WorkLog(" XRay复位: 左右门关闭，挡停下降 ");
                CylinderMove(MoveInfo, IO_Type.X_InDoor_Down, IO_Type.X_InDoor_Up);
                CylinderMove(MoveInfo, IO_Type.X_OutDoor_Down, IO_Type.X_OutDoor_Up);
                CylinderMove(MoveInfo, IO_Type.X_StopCylinder_Up, IO_Type.X_StopCylinder_Down);
            }
            else if (MoveInfo.IsStep(StepEnum.XR05_DoorClose))
            {
                TimeSpan span = DateTime.Now - MoveInfo.MoveStartTime;  
                WorkLog(" XRay复位 ：完成，耗时（" + FormUtil.GetSpanStr(span) + "）");
                MoveInfo.EndMove();
                runStatus = RobotRunStatus.Runing;
            }
        }

        internal override void StopMove()
        {
            SecMoveInfo.EndMove();
            MoveInfo.EndMove();
            InXWork = false;
            if (xRay.IsRayOpen)
            {
                xRay.Stop();
            }

            IOMove(IO_Type.X_Lock_On, IO_VALUE.LOW);
            IOMove(IO_Type.X_InLine_Run, IO_VALUE.LOW);
            IOMove(IO_Type.X_MLine_Run, IO_VALUE.LOW);
            IOMove(IO_Type.X_OLine_Run, IO_VALUE.LOW);
        }


        public override void StopRun()
        {
            SetAllTimer(false);
            StopMove();
            runStatus = RobotRunStatus.Wait;
        }
        #endregion

        #region 定时器
        protected override void BaseTimerProcess()
        {
            if (isInSuddenDown || isNoAirCheck)
            {
                return;
            }
            BusyMoveProcess();
            IOTimeOutProcess();

            if (NoAlarm() && MoveInfo.MoveType.Equals(RobotMoveType.None))
            {
                if (IOValue(IO_Type.X_ReelCheck).Equals(IO_VALUE.HIGH) || IOValue(IO_Type.X_InLine_Check).Equals(IO_VALUE.HIGH))
                {
                    StartWorking(new WorkParam());
                }
            }
            LockOnProcess();
        }
        #endregion


        #region 互锁信号处理

        private void LockOnProcess()
        {
            //不在复位，可以验证是否打开互锁信号
            if (IOValue(IO_Type.X_Lock_On).Equals(IO_VALUE.HIGH))
            {
                if (!LockOnCanMove())
                {
                    IOMove(IO_Type.X_Lock_On, IO_VALUE.LOW);
                    if (xRay.IsRayOpen)
                    {
                        LogUtil.error("LockOnProcess 需要关闭 X_Lock_On，发现 xRay.IsRayOpen，调用 xRay.Close");
                        xRay.Close();
                    }
                }
            }
            else
            {
                if ((!MoveInfo.MoveType.Equals(RobotMoveType.Reset)) && (!MoveInfo.MoveType.Equals(RobotMoveType.RHome)))
                {
                    if (MoveInfo.MoveType.Equals(RobotMoveType.Working) && MoveInfo.MoveStep >= StepEnum.XW16_EndCount)
                    {

                    }
                    else
                    {
                        if (LockOnCanMove() && (!isInSuddenDown) && (!isNoAirCheck))
                        {
                            IOMove(IO_Type.X_Lock_On, IO_VALUE.HIGH);
                        }
                    }
                }
            }
        }

        public bool LockOnCanMove()
        {
            if (IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.HIGH)
                && IOValue(IO_Type.X_DoorLimit_Down).Equals(IO_VALUE.HIGH)
                && IOValue(IO_Type.X_DoorLimit_Up).Equals(IO_VALUE.HIGH)
                && IOValue(IO_Type.X_InDoor_Up).Equals(IO_VALUE.HIGH)
                && IOValue(IO_Type.X_OutDoor_Up).Equals(IO_VALUE.HIGH)
                && IOValue(IO_Type.X_InDoor_Down).Equals(IO_VALUE.LOW)
                && IOValue(IO_Type.X_OutDoor_Down).Equals(IO_VALUE.LOW)
                )
            {
                return true;
            }
            return false;
        }
        #endregion

        public override string GetMoveStr()
        {
            string msg = "";
            int tLength = 15;

            msg += "runS：  " + runStatus + "\n";
            msg += "alarm：  " + alarmType + "\n";
            msg += "Move：" + MoveInfo.MoveType + " " + MoveInfo.MoveStep + "\n";
            msg += "X光图片：" + lastFileName + "\n";

            msg += "入口料盘：" + In_ReelInfo.ToStr() + " \r\n";
            msg += "扫描区料盘：" + Work_ReelInfo.ToStr() + " \r\n";
            msg += "出口料盘：" + Out_ReelInfo.ToStr() + " \r\n";

            return msg;
        }

     
    }

   
}