using URSoldering.Common;
using URSoldering.LoadCSVLibrary;
using log4net; 
using System.Timers;

namespace URSoldering.DeviceLibrary
{
    public class RobotBean
    {
        /// <summary>
        /// 报警或者警告信息
        /// </summary>
        public string WarnMsg = "";
        public static string RobotName = "";
        public static readonly ILog LOGGER = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
        public RobotStatus Status = RobotStatus.Wait; 
        protected System.Timers.Timer mainTimer = new System.Timers.Timer();
        public static RobotConfig baseConfig = null;
        public bool IsInSuddendown = false;
        /// <summary>
        /// 不扫码工作
        /// </summary>
        public bool NoCodeWork = false;
        public string NoCodeCode = "NoCode";
        /// <summary>
        /// 铆压调试不进行铆压
        /// 焊接调试不检测送丝报警
        /// </summary>
        public bool IsDebug = ConfigAppSettings.GetBoolValue(Setting_Init.ISDebug);
        /// <summary>
        /// 三色灯定时器
        /// </summary>
        protected System.Timers.Timer ledTimer = new System.Timers.Timer();
        public void InitTimer()
        {
            ledTimer = new System.Timers.Timer();
            ledTimer.AutoReset = true;
            ledTimer.Enabled = false;
            ledTimer.Interval = 1000;
            ledTimer.Elapsed += LedTimer_Elapsed;

            mainTimer = new System.Timers.Timer();
            mainTimer.AutoReset = true;
            mainTimer.Enabled = false;
            mainTimer.Interval = 200;
            mainTimer.Elapsed += mainTimer_Elapsed;
        }
        /// <summary>
        /// 三色灯处理，复位完成后，如果忙碌绿灯亮，等待状态绿灯闪烁
        /// </summary> 
        private void LedTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            if (Status.Equals(RobotStatus.Reset))
            {
                if (KNDIOValue(IO_Type.AutoRunSingle).Equals(IO_VALUE.LOW))
                {
                    KNDIOMove(IO_Type.AutoRunSingle, IO_VALUE.HIGH);
                }
                if (KNDIOValue(IO_Type.WaitSingle).Equals(IO_VALUE.HIGH))
                {
                    KNDIOMove(IO_Type.WaitSingle, IO_VALUE.LOW);
                }
                else
                {
                    KNDIOMove(IO_Type.WaitSingle, IO_VALUE.HIGH);
                }

            }
            else if (Status.Equals(RobotStatus.Busy))
            {
                //忙碌或转动，绿灯常亮，黄灯灭，红灯亮时绿灯不亮
                if (KNDIOValue(IO_Type.WaitSingle).Equals(IO_VALUE.HIGH))
                {
                    KNDIOMove(IO_Type.WaitSingle, IO_VALUE.LOW);
                }
                if (KNDIOValue(IO_Type.AutoRunSingle).Equals(IO_VALUE.LOW))
                {
                    KNDIOMove(IO_Type.AutoRunSingle, IO_VALUE.HIGH);
                }
            }
            else if (Status.Equals(RobotStatus.Runing))
            {
                //等待状态，黄灯灭，绿灯闪烁，红灯亮时绿灯不亮
                if (KNDIOValue(IO_Type.WaitSingle).Equals(IO_VALUE.HIGH))
                {
                    KNDIOMove(IO_Type.WaitSingle, IO_VALUE.LOW);
                }
                if (KNDIOValue(IO_Type.AutoRunSingle).Equals(IO_VALUE.HIGH))
                {
                    KNDIOMove(IO_Type.AutoRunSingle, IO_VALUE.LOW);
                }
                else
                {
                    KNDIOMove(IO_Type.AutoRunSingle, IO_VALUE.HIGH);
                }
            }

        }
        protected virtual void mainTimer_Elapsed(object sender, ElapsedEventArgs e)
        {

        } 
        public static ConfigIO getWaitIO(string type)
        {
            if (baseConfig.RobotDIList.ContainsKey(type))
            {
                return baseConfig.RobotDIList[type];
            }
            else if (baseConfig.RobotDIList.ContainsKey(type))
            {
                return baseConfig.RobotDIList[type];
            }
            return null;
        }


        #region KNDIO
        public static void ConnectionIO()
        {
            foreach (string deviceName in baseConfig.DIODeviceNameList)
            {
                if (!KNDManager.IsConnection(deviceName))
                {
                    KNDManager.ConnectionIP(deviceName);
                    System.Threading.Thread.Sleep(100);
                }
            }
            FixtureClamp();
        }
        public static void FixtureClamp()
        {
            //连接上IO模块后，夹具夹紧
            KNDIOMove(IO_Type.Fixture_Clamp, IO_VALUE.HIGH);
            KNDIOMove(IO_Type.Fixture_Relax, IO_VALUE.LOW); 
        }
        public static bool IsFixtureClamp()
        {
            if (ConfigAppSettings.GetBoolValue(Setting_Init.ISDebug))
            {
                return true;
            }
            if (KNDIOValue(IO_Type.Fixture_Clamp).Equals(IO_VALUE.HIGH) && KNDIOValue(IO_Type.Fixture_Relax).Equals(IO_VALUE.LOW))
            {
                return true;
            }
            else
            {
                LogUtil.error("夹具夹紧信号不到位");
                return false;
            }
        }
        public static bool ShuddenOK()
        {
            if (ConfigAppSettings.GetBoolValue(Setting_Init.ISDebug))
            {
                return true;
            }
            if (!baseConfig.RobotDIList.ContainsKey(IO_Type.SuddenStop_Single))
            {
                return false;
            }
            ConfigIO configIo = baseConfig.RobotDIList[IO_Type.SuddenStop_Single];

            if (KNDManager.IsConnection(configIo.DeviceName))
            {
                IO_VALUE value = KNDIOValue(IO_Type.SuddenStop_Single);
                if (value.Equals(IO_VALUE.HIGH))
                {
                    return true;
                }
            }
            return false;
        }

        public static void KNDIOMove(string ioType, IO_VALUE ioValue)
        {
            if (baseConfig.RobotDOList.ContainsKey(ioType))
            {
                ConfigIO configIo = baseConfig.RobotDOList[ioType];
                KNDManager.WriteSingleDO(configIo.DeviceName, configIo.SlaveID, configIo.GetIOAddr(), ioValue);
                System.Threading.Thread.Sleep(60);
            }
            else
            {
                LogUtil.error(LOGGER, "没有DO=" + ioType);
            }
        }

        public static void KNDIOMove(string ioType, IO_VALUE ioValue,int millSenconds)
        {
            if (baseConfig.RobotDOList.ContainsKey(ioType))
            {
                ConfigIO configIo = baseConfig.RobotDOList[ioType];
                KNDManager.WriteSingleDO(configIo.DeviceName, configIo.SlaveID, configIo.GetIOAddr(), ioValue, millSenconds);
              
            }
            else
            {
                LogUtil.error(LOGGER, "没有DO=" + ioType);
            }
        }


        /// <summary>
        /// 阻塞等待IO信号，等到返回true,未等到返回false
        /// </summary>
        /// <param name="name">IO名称，抛出异常时的消息名</param>
        /// <param name="ioType">IO</param>
        /// <param name="ioValue">IO值</param>
        /// <param name="timeOut">超时时间（毫秒）</param>
        public static bool WaitIo(string ioType, IO_VALUE value, int timeOut)
        {
            return WaitUtil.Wait(timeOut,delegate() {
                 return value.Equals(RobotBean.KNDIOValue(ioType));
            });
        }

        /// <summary>
        /// 阻塞等待IO信号，等到返回,超时抛出TimeoutException
        /// </summary>
        /// <param name="name">IO名称，抛出异常时的消息名</param>
        /// <param name="ioType">IO</param>
        /// <param name="ioValue">IO值</param>
        /// <param name="timeOut">超时时间（毫秒）</param>
        public static void WaitIo(string name, string ioType, IO_VALUE value, int timeOut)
        {
            WaitUtil.Wait(name, timeOut, delegate () {
                return value.Equals(RobotBean.KNDIOValue(ioType));
            });
        }

        public static IO_VALUE KNDIOValue(string ioType)
        {
            IO_VALUE ioValue = IO_VALUE.LOW;
            if (baseConfig.RobotDIList.ContainsKey(ioType))
            {
                ConfigIO configIo = baseConfig.RobotDIList[ioType];
                ioValue = KNDManager.GetDIValue(configIo.DeviceName, configIo.SlaveID, configIo.GetIOAddr());
                //UpdateDoValue(ioType, ioValue);
            }
            else if (baseConfig.RobotDOList.ContainsKey(ioType))
            {
                ConfigIO configIo = baseConfig.RobotDOList[ioType];
                ioValue = KNDManager.GetDOValue(configIo.DeviceName, configIo.SlaveID, configIo.GetIOAddr());
            }
            else
            {
                LogUtil.error(LOGGER, "没有DO=" + ioType);
            }
            return ioValue;
        }
 
        public void CloseLed( )
        {
            KNDIOMove(IO_Type.AutoRunSingle, IO_VALUE.LOW);
            KNDIOMove(IO_Type.AlarmSingle, IO_VALUE.LOW);
            KNDIOMove(IO_Type.WaitSingle, IO_VALUE.LOW); 
        }
        #endregion

    }

    /// <summary>
    /// 机器人当前的状态
    /// </summary>
    public enum RobotStatus
    {
        /// <summary>
        /// 等待状态
        /// </summary>
        Wait=0,
        /// <summary>
        /// 机器复位中
        /// </summary>
        Reset=1,
        /// <summary>
        /// 正常运行中
        /// </summary>
        Runing=2,
        /// <summary>
        /// 忙碌中，如正在焊接或正在检测
        /// </summary>
        Busy=3,
        /// <summary>
        /// 流水线转动中
        /// </summary>
        LineMove=4
    }
}