using log4net;
using URSoldering.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using URSoldering.LoadCSVLibrary;
using System.Threading.Tasks;

namespace URSoldering.DeviceLibrary
{
    public partial class WeldRobotBean
    {
        public static bool HasSoldering = ConfigAppSettings.GetBoolValue(Setting_Init.HasSoldering);
        public static bool IsFirstStart = false;
        public static string WarnMsg = "";
        public static readonly ILog LOGGER = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        private static System.Timers.Timer mainTimer = new System.Timers.Timer();
        public static URPointValue HomePoint = new URPointValue();
        public static URPointValue Clear1Point = new URPointValue();
        public static URPointValue Clear2Point = new URPointValue();
        public static URPointValue RobotMin = new URPointValue();
        public static URPointValue RobotMax = new URPointValue();

         
        //休眠的秒数，<=0不需要休眠
        public static int SleepSeconds = ConfigAppSettings.GetIntValue(Setting_Init.SleepSeconds);
        public static bool isHighSpeed = ConfigAppSettings.GetIntValue(Setting_Init.Robot_IsHigh) == 1;
        //public static int ClearMSenconds = ConfigAppSettings.GetIntValue(Setting_Init.Clear_Time);
        private static string RobotName = "【焊接】";
        /// <summary>
        /// 机械臂是否在运行中
        /// </summary>
        public static bool ISRun = false;
        /// <summary>
        /// 是否在急停中
        /// </summary>
        public static bool IsInSudden = false;
        /// <summary>
        /// 是否没有气压信号
        /// </summary>
        public static bool IsNoAir = false;

        /// <summary>
        /// 焊接步骤
        /// </summary>
        public static WeldStepBean WeldMoveStep = new WeldStepBean();
        //public static int ClearCount = ConfigAppSettings.GetIntValue(Setting_Init.Weld_Clear_Count);
        public static int WeldCount = 0;
        private static bool isInit = false;
        public static AlarmType alarmType = AlarmType.None;

        //记录是否空闲中，如果空闲并且超过三分钟，就关闭烙铁，下次启动时需要打卡
        private static bool IsFree = false;
        private static DateTime BeginFreeTime = DateTime.Now;
        private static bool SolderSleep = false;

        static WeldRobotBean()
        {
            mainTimer = new System.Timers.Timer();
            mainTimer.Interval = 300;
            mainTimer.AutoReset = true;
            mainTimer.Elapsed += mainTimer_Elapsed;
            mainTimer.Enabled = false;

            Clear1Point = LoadPoint(Setting_Init.Soldering_Clear1Point);
            Clear2Point = LoadPoint(Setting_Init.Soldering_Clear2Point);
            HomePoint = LoadPoint(Setting_Init.Soldering_HomePoint);
            RobotMin = LoadPoint(Setting_Init.Soldering_RobotMin);
            RobotMax = LoadPoint(Setting_Init.Soldering_RobotMax);
        }

        private static URPointValue LoadPoint(string configStr)
        {
            URPointValue p = new URPointValue();
            string configP = ConfigAppSettings.GetValue(configStr);
            if (String.IsNullOrEmpty(configP))
            {
                ConfigAppSettings.SaveValue(configStr, p.ToJosonStr());
            }
            else
            {
                p = URPointValue.ToObject(configP);
            }
            return p;

        }

        public static SolderingRobotConfig RobotConfig = null;
        public static void InitData(SolderingRobotConfig config)
        {
            RobotConfig = config;
        }
        /// <summary>
        /// 初始化 
        /// </summary>
        public static void Init()
        { 
            StartURRobot();
            SolderingManager.Init(RobotConfig.JBC_Soldering_Port, RobotConfig.JBC_Soldering_Num);
            SendWireManager.Init(RobotConfig.JBC_SendWire_Port);

            isInit = true;
        }
        private static void StartURRobot()
        {
            if (!URRobotControl.IsRun)
            {
                Task.Factory.StartNew(delegate ()
                {
                    bool result = URRobotControl.StartRobot();

                    if (!result)
                    {
                        WarnMsg = "连接UR机器人失败";
                    }
                });
            }
        }
        public static void ResetInit()
        {
            StartURRobot();
            SendWireManager.Init(RobotConfig.JBC_SendWire_Port);
            SolderingManager.Init(RobotConfig.JBC_Soldering_Port, RobotConfig.JBC_Soldering_Num);
        }
        /// <summary>
        /// 开始运行
        /// </summary>
        /// <returns></returns>
        public static string StartRun()
        {
            LogUtil.info(RobotName + "开始启动");
            IsFirstStart = true;
            return GoHome();
        }
        public static string Reset()
        { 
            StopSleep();
            WeldMoveStep.EndMove();
            WarnMsg = "";
            if (!isInit)
            {
                Init();
            }
            else
            {
                ResetInit();
            }
            //Thread.Sleep(1000);
            //if (!URRobotControl.IsRun)
            //{
            //    Thread.Sleep(2000);
            //}
            if (!URRobotControl.PointIsValid(HomePoint))
            {
                LogUtil.info(RobotName + "开始启动失败：原点坐标无效");
                return "原点坐标无效";
            }
            if ((!URRobotControl.PointIsValid(Clear1Point)) || (!URRobotControl.PointIsValid(Clear2Point)))
            {
                LogUtil.info(RobotName + "开始启动失败：清洗点坐标无效");
                return "清洗点坐标无效";
            }

            if (HasSoldering)
            {
                if (!SolderingManager.IsRun)
                {
                    LogUtil.info(RobotName + "开始启动:烙铁没有连接上");
                    return "烙铁没有连接上！";
                }
                if (!SendWireManager.IsRun)
                {
                    LogUtil.info(RobotName + "开始启动:JBC送丝器没有连接上");
                    return "JBC送丝器没有连接上！";
                }
            }
          

            IsInSudden = false;
            IsNoAir = false;
            //开始运行
            alarmType = AlarmType.None;
            //锁定轴
            URRobotControl.LockAxis();

            //烙铁温度=0， 送丝上升，机器复位
            SolderingUp(false);
            SendWireWork(false);

            ISRun = true;
            mainTimer.Enabled = true;
            return "";
        }

        public static void StopWeld()
        {
            LogUtil.info(RobotName + "停止当前焊接");
            WeldMoveStep.EndMove();
        }
        /// <summary>
        /// 停止所有运动
        /// </summary>
        public static void StopMove()
        {
            StopWeld();
            LogUtil.info(RobotName + "停止所有运动");

            //烙铁温度=0，烙铁上升，送丝上升，机器复位
            SolderingUp(false);
            SendWireWork(false);

            SendWireManager.StopSend();
            SolderingManager.Release();
        }
        /// <summary>
        /// 停止运行
        /// </summary>
        public static void StopRun()
        {
            IsFree = false;
            SolderSleep = false;
            StopMove();
            mainTimer.Enabled = false;
            ISRun = false;

            LogUtil.info(LOGGER, RobotName + "停止运行");
        }
        private static bool IsTimerProcess = false;
        static void mainTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (IsTimerProcess)
            {
                return;
            }
            IsTimerProcess = true;
            try
            {
                if (WeldMoveStep.moveType.Equals(MoveType.None))
                {
                    IOTimeOutProcess();

                    //处理休眠
                    if (IsFree)
                    {
                        //如果超过配置的时间，关闭烙铁头
                        TimeSpan span = DateTime.Now - BeginFreeTime;
                        if (SleepSeconds > 0 && span.TotalSeconds > SleepSeconds && (SolderSleep.Equals(false)))
                        {
                            LogUtil.info(RobotName + "，已经空闲【" + (int)span.TotalSeconds + "】秒，开始休眠烙铁");
                            SolderSleep = true;
                            SolderingManager.Release();
                        }
                    }
                    else
                    {
                        IsFree = true;
                        BeginFreeTime = DateTime.Now;
                    }
                }
                else if (WeldMoveStep.moveType.Equals(MoveType.Weld))
                {
                    IsFree = false;
                    if (alarmType.Equals(AlarmType.None) || alarmType.Equals(AlarmType.StepTimeOut))
                    {
                        WeldProcess();
                    }
                }
                else if (WeldMoveStep.moveType.Equals(MoveType.GoHome))
                {
                    GoHomeProcess();
                }
                if (HasSoldering)
                {
                    CheckSolderingAlarm();
                }
                if ((!WeldMoveStep.moveType.Equals(MoveType.Weld)) || WeldMoveStep.ResetCount >= 3)
                {
                    CheckSendWireAlarm();
                }
                if (!WeldMoveStep.moveType.Equals(MoveType.GoHome))
                {
                    CheckRobotAlarm();
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(RobotName + "定时器出错：" + ex.ToString());
            }
            IsTimerProcess = false;
        }
        private static void CheckRobotAlarm()
        {
            if (alarmType.Equals(AlarmType.RobotError))
            {
                return;
            }

            if (URRobotControl.WarnMsg.Equals(""))
            {
                if (URRobotControl.IsRun.Equals(false))
                {
                    WarnMsg = "机械臂连接断开";
                    LogUtil.error("检测到" + WarnMsg);
                    Alarm(AlarmType.RobotError);

                }
            }
            else
            {

                WarnMsg = URRobotControl.WarnMsg;
                LogUtil.error("检测到" + WarnMsg);
                Alarm(AlarmType.RobotError);
            }
        }
        //烙铁停止休眠
        private static void StopSleep()
        {
            IsFree = false;
            if (SolderSleep)
            {
                SolderingManager.Init(RobotConfig.JBC_Soldering_Port, RobotConfig.JBC_Soldering_Num);
                SolderSleep = false;
            }
        }

        private static DateTime preCheckSendWireTime = DateTime.Now;
        private static DateTime lastSendWireOkTime = DateTime.Now;
        /// <summary>
        /// 检测送丝错误
        /// </summary>
        private static void CheckSendWireAlarm()
        {
            preCheckSendWireTime = DateTime.Now;
            //如果休眠了不需要处理  
            if (SendWireManager.IsAlarm())
            {
                SendWireManager.Reset();
                if (SendWireManager.IsAlarm())
                {
                    //停止送丝器
                    SendWireManager.StopSend();
                    WarnMsg = "送丝器报警";
                    Alarm(AlarmType.SendWireAlarm);
                    LogUtil.error(RobotName + WarnMsg);
                }
            }
            else
            {
                if (alarmType.Equals(AlarmType.SendWireAlarm) && IsInSudden.Equals(false) && IsNoAir.Equals(false))
                {
                    TimeSpan span = DateTime.Now - lastSendWireOkTime;
                    int needSeconds = ConfigAppSettings.GetIntValue(Setting_Init.SendWireRecoverSeconds);
                    if (span.TotalSeconds > needSeconds)
                    {
                        WarnMsg = "";
                        alarmType = AlarmType.None;
                        WarnMsg = "";
                        LogUtil.info(RobotName + "送丝器已恢复超过【" + needSeconds + "】秒，消除送丝器报警！");
                    }
                }
            }
        }
        /// <summary>
        /// 卡丝恢复功能，只有手动点了才会继续,当前焊点会重新焊接
        /// </summary> 
        public static bool SendWireRecover()
        {
            if (SendWireManager.IsAlarm())
            {
                LogUtil.info(RobotName + "卡丝恢复失败，仍在报警中！");
            }
            else
            {
                if (alarmType.Equals(AlarmType.SendWireAlarm) && IsInSudden.Equals(false) && IsNoAir.Equals(false))
                {
                    if (WeldMoveStep.moveType.Equals(MoveType.Weld))
                    {
                        LogUtil.info(RobotName + "开始卡丝恢复，重新此焊点的焊接 ！");
                        WeldMoveStep.NextMoveStep(MoveStep.Wait);
                    }
                    lastSendWireOkTime = DateTime.Now;
                    LogUtil.info(RobotName + "开始卡丝恢复！");
                    return true;
                }
            }
            return false;
        }
        /// <summary>IsNeedMsg
        /// 送丝报警恢复前是否需要弹出提示信息
        /// </summary>
        /// <returns></returns>
        public static bool IsNeedMsg()
        {
            if (alarmType.Equals(AlarmType.SendWireAlarm) && IsInSudden.Equals(false) && IsNoAir.Equals(false))
            {
                //判断是否在焊接中
                if (WeldMoveStep.moveType.Equals(MoveType.Weld))
                {
                    return true;
                }
            }
            return false;
        }
        private static DateTime preCheckSolderingTime = DateTime.Now;
        private static int preSolderingRet = -1;
        /// <summary>
        /// 检查烙铁报警
        /// </summary> 
        private static void CheckSolderingAlarm()
        {
            //10秒钟检测一次
            TimeSpan span = DateTime.Now - preCheckSolderingTime;

            if (span.TotalSeconds > 10)
            {
                preCheckSolderingTime = DateTime.Now;
                //如果休眠了不需要处理 
                int ErrorCode = SolderingManager.ReadPortError();
                //添加验证，需要连续两次都是同一个值才算有效，跳过不稳定的错误
                if (!ErrorCode.Equals(preSolderingRet))
                {
                    LOGGER.Info(RobotName + "烙铁PortError更改，本次读取的值：" + ErrorCode + ",上次的值：" + preSolderingRet + "");
                    preSolderingRet = ErrorCode;
                }
                if (ErrorCode > 0)
                {
                    string str = SolderingManager.GetErrorStr(ErrorCode);
                    WarnMsg = "烙铁报警：" + str;
                    Alarm(AlarmType.SolderingAlarm);
                    LogUtil.error(RobotName + WarnMsg);
                }
                else
                {
                    if (alarmType.Equals(AlarmType.SolderingAlarm) && IsInSudden.Equals(false) && IsNoAir.Equals(false))
                    {
                        WarnMsg = "";
                        alarmType = AlarmType.None;
                        WarnMsg = "";

                        LogUtil.error(RobotName + "消除烙铁报警！");
                    }
                }
            }
        }

        /// <summary>
        /// io检测异常,如果所有的步骤已经完成，表示信号超时异常已经结束
        /// </summary>
        private static DateTime preIoTimerOutTime = DateTime.Now;
        private static void IOTimeOutProcess()
        {
            try
            {
                TimeSpan span = DateTime.Now - preIoTimerOutTime;
                if (span.TotalSeconds > 1)
                {
                    preIoTimerOutTime = DateTime.Now;
                    if (IsInSudden || IsNoAir)
                    {
                        return;
                    }
                    if (alarmType.Equals(AlarmType.IoSingleTimeOut) || alarmType.Equals(AlarmType.StepTimeOut))
                    {
                        if (WeldMoveStep.IsInWait == false)
                        {
                            LogUtil.info(RobotName + "之前有IO超时异常，清理信号超时异常！");
                            WarnMsg = "";
                            alarmType = AlarmType.None;
                            //RobotBean.KNDIOMove(IO_Type.Device_NG, IO_VALUE.HIGH);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(LOGGER, "IOTimeOutProcess出错：" + ex.ToString());
            }
        }
        public static void Alarm(AlarmType alarm)
        {
            LogUtil.error(LOGGER, RobotName + "收到报警：" + alarm);
            alarmType = alarm;

            //RobotBean.KNDIOMove(IO_Type.Device_NG, IO_VALUE.LOW);
            if (alarmType.Equals(AlarmType.IoSingleTimeOut))
            {
            }
            else if (alarmType.Equals(AlarmType.SuddenStop) || alarmType.Equals(AlarmType.NoAirCheck) || alarm.Equals(AlarmType.RobotError))
            {
                if (alarmType.Equals(AlarmType.SuddenStop))
                {
                    IsInSudden = true;
                }
                else if (alarmType.Equals(AlarmType.NoAirCheck))
                {
                    IsNoAir = true;
                }
                //急停之后需要机械臂重连
                URRobotControl.StopRobot();
                //停止所有运行
                StopMove();
            }
        }

        public static string GoHome()
        {
            string msg = Reset();
            if (!msg.Equals(""))
            {
                WarnMsg = msg;
                return msg;
            }
            WeldMoveStep.NewWeld(MoveType.GoHome);
            WeldMoveStep.NextMoveStep(MoveStep.Home_Reset);
            SolderingUp(true);
            SendWireWork(true);
            WeldMoveStep.WaitList.Add(WaitResultInfo.WaitRobotRun());
            return "";
        }
        public static void GoHomeProcess()
        {
            if (WeldMoveStep.IsInWait)
            {
                CheckWait();
            }
            if (WeldMoveStep.IsInWait)
            {
                return;
            }

            if (WeldMoveStep.moveStep.Equals(MoveStep.Home_Reset))
            {
                WeldMoveStep.NextMoveStep(MoveStep.Home_1_RobotMove);

                if (IsFirstStart)
                {
                    if (BoardManager.CurrBoard != null && BoardManager.CurrBoard.pointList.Count > 0)
                    {
                        int time = (int)(BoardManager.CurrBoard.pointList[0].preheatTime * 1000);
                        int temp = BoardManager.CurrBoard.pointList[0].preheatTemperature;
                        int maxTemp = BoardManager.CurrBoard.pointList[0].preheatTemperatureMax;
                        int minTemp = BoardManager.CurrBoard.pointList[0].preheatTemperatureMin;
                        SolderingManager.setTemp(temp.ToString());
                        WeldLog("设置烙铁温度" + temp + "");
                        WeldMoveStep.WaitList.Add(WaitResultInfo.WaitTemperature(temp, maxTemp, minTemp));
                    }
                }
                MoveToOrg();
            }
            else if (WeldMoveStep.moveStep.Equals(MoveStep.Home_1_RobotMove))
            {
                if (IsFirstStart)
                {
                    IsFirstStart = false;
                    WeldMoveStep.NextMoveStep(MoveStep.Home_3_StartClear);
                    SendWireUpToClear1();
                }
                else
                {
                    WeldLog("回原点结束，机械臂回到待机点 ");
                    WarnMsg = "";
                    WeldMoveStep.EndMove();
                }
            }
            else if (WeldMoveStep.moveStep.Equals(MoveStep.Home_3_StartClear))
            {
                WeldMoveStep.NextMoveStep(MoveStep.Home_4_ToClear2);
                MoveToClear2(RobotConfig.ClearMSenconds);
            }

            else if (WeldMoveStep.moveStep.Equals(MoveStep.Home_4_ToClear2))
            {
                WeldMoveStep.NextMoveStep(MoveStep.Home_5_ToOrg);
                MoveToOrg();
            }
            else if (WeldMoveStep.moveStep.Equals(MoveStep.Home_5_ToOrg))
            {
                WeldLog("回原点结束，清洗完成  ,送丝上升到位  ");
                WarnMsg = "";
                WeldMoveStep.EndMove();
            }
        }
        private static void MoveToPoint(WeldPointInfo p, bool IsHigh)
        {
            SendWireWork(true);
            SolderingDown(true);
            URPointValue point = p.GetURPoint();
            WeldLog("移动到焊点【" + WeldMoveStep.CurrPoint.pointName + "】:" + point.ToShowStr());
            URRobotControl.MoveTo(point, isHighSpeed);
            WeldMoveStep.WaitList.Add(WaitResultInfo.WaitRobotPoint(point));
        }
        private static void MoveToOrg()
        {
            SolderingUp(true);
            SendWireWork(true);
            WeldLog("送丝上升，机械臂走到待机点   ");
            URRobotControl.MoveTo(HomePoint, isHighSpeed);
            WeldMoveStep.WaitList.Add(WaitResultInfo.WaitRobotPoint(HomePoint));

        }
        private static void SendWireUpToClear1()
        {
            SolderingUp(true);
            SendWireClear(true);
            Thread.Sleep(100);
            WeldCount = 0;
            WeldLog("送丝上升，打开清洗装置，机械臂走到清洗点1  ");
            URRobotControl.MoveTo(Clear1Point, isHighSpeed);
            WeldMoveStep.WaitList.Add(WaitResultInfo.WaitRobotPoint(Clear1Point));
        }
        private static void MoveToClear2(int mSenconds)
        {
            WeldMoveStep.WaitList.Add(WaitResultInfo.WaitTime(mSenconds));
            WeldLog("机械臂走到清洗点2 ,打开清洗装置，清洗时间:" + mSenconds + "   ");
            URRobotControl.MoveTo(Clear2Point, isHighSpeed);
            WeldMoveStep.WaitList.Add(WaitResultInfo.WaitRobotPoint(Clear2Point));
        }
        //更新原点
        public static void UpdateOrgPoint(URPointValue point)
        {
            WeldRobotBean.HomePoint = point;
            string str = point.ToJosonStr();
            ConfigAppSettings.SaveValue(Setting_Init.Soldering_HomePoint, str);
        }
        public static void UpdateClear1Point(URPointValue point)
        {
            WeldRobotBean.Clear1Point = point;
            string str = point.ToJosonStr();
            ConfigAppSettings.SaveValue(Setting_Init.Soldering_Clear1Point, str);
        }
        public static void UpdateClear2Point(URPointValue point)
        {
            WeldRobotBean.Clear2Point = point;
            string str = point.ToJosonStr();
            ConfigAppSettings.SaveValue(Setting_Init.Soldering_Clear2Point, str);
        }
        /// <summary>
        /// 验证机器人是否超出活动范围
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        public static string CheckEpsonPoint(URPointValue point)
        { 
            return "";
        }
    }
}