using ABB.Robotics.Controllers;
using ABB.Robotics.Controllers.Discovery;
using ABB.Robotics.Controllers.IOSystemDomain;
using ABB.Robotics.Controllers.RapidDomain;
using OnlineStore.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;

namespace OnlineStore.DeviceLibrary
{
    public class ABBControl
    {
        public static int  DefaultSpeed = ConfigAppSettings.GetIntValue(Setting_Init.DefaultSpeed);
        public static string DI_Start = "di_start";//启动程序
        public static string DI_Stop = "di_stop";//停止程序
        public static string DO_ES = "do_ES";//急停状态
        public static string DO_IsRun = "do_IsRun";//机器人程序运行状态
        public static string Do_AutoOn = "do_AutoOn";//是否自动状态

        private static NetworkScanner scanner = null;
        // private Controller controller = null;
        //   private static Task[] tasks = null;
        private static NetworkWatcher networkwatcher = null;
        public static Dictionary<string, Controller> controllerMap = new Dictionary<string, Controller>();
        public static Dictionary<string, ControllerInfo> controllerInfoMap = new Dictionary<string, ControllerInfo>();

        public delegate void ControllerAddDelegate(ControllerInfo controller);
        public static event ControllerAddDelegate ControllerAddEvent;



        public static void Load()
        {
            StartServer();
            controllerMap = new Dictionary<string, Controller>();
            controllerInfoMap = new Dictionary<string, ControllerInfo>();
            scanner = new NetworkScanner();
            scanner.Scan();
            ControllerInfoCollection controllers = scanner.Controllers;
            int i = 0;
            foreach (ControllerInfo controllerInfo in controllers)
            {
                AddControllerInfo(controllerInfo);
                i++;
            }

            networkwatcher = new NetworkWatcher(scanner.Controllers);
            networkwatcher.Found += new EventHandler<NetworkWatcherEventArgs>(HandleFoundEvent);
            networkwatcher.EnableRaisingEvents = true;

            if (DefaultSpeed <= 0)
            {
                DefaultSpeed = 600;
                ConfigAppSettings.SaveValue(Setting_Init.DefaultSpeed, 600);
            }
        }
        private static bool AddControllerInfo(ControllerInfo controllerInfo)
        {
            try
            {
                Controller con = ControllerFactory.CreateFrom(controllerInfo);
                con.Logon(UserInfo.DefaultUser);
                ControllerState state = con.State;
                string ip = con.IPAddress.ToString();
                RemoveController(ip);
                controllerMap.Add(ip, con);
                // controller = con;
                controllerInfoMap.Add(ip, controllerInfo);
                LogUtil.info("成功添加机器人【" + ip + "】");
                return true;
            }
            catch (Exception ex)
            {
                LogUtil.error("添加机器人【" + controllerInfo.IPAddress.ToString() + "】失败：" + ex.ToString());
            }
            return false;
        }
        private static void RemoveController(string ip)
        {
            if (controllerInfoMap.ContainsKey(ip))
            {
                controllerInfoMap.Remove(ip);
            }
            if (controllerMap.ContainsKey(ip))
            {
                controllerMap.Remove(ip);
            }
        }

        private static void HandleFoundEvent(object sender, NetworkWatcherEventArgs e)
        {
            ControllerInfo controllerInfo = e.Controller;
            if (controllerInfo != null)
            {
                if (AddControllerInfo(controllerInfo))
                {
                    ControllerAddEvent?.Invoke(controllerInfo);
                }
            }
        }

        public static void StartABBControl(string ip, string signalName = "di_start", bool isReset = true)
        {
            if (isReset)
            {
                StopABBControl(ip);
            }

            SetRobotSignal(ip, signalName);
            Thread.Sleep(100);
            ResetRobotSignal(ip, signalName);
        }

        public static void StopABBControl(string ip, string signalName = "di_stop")
        {
            SetRobotSignal(ip, signalName);
            Thread.Sleep(100);
            ResetRobotSignal(ip, signalName);
        }

        public static void SetRobotSignal(string ip, string name)
        {
            try
            {
                Controller controller = GetControllerByIP(ip);
                if (controller != null)
                {
                    // string name = comboBox1.Text;
                    Signal singalValue = controller.IOSystem.GetSignal(name);
                    if (singalValue == null)
                    {
                        LogUtil.error("ABB[" + ip + "] GetSignal [" + name + "] =null");
                    }
                    else
                    {
                        DigitalSignal digitalSig = (DigitalSignal)singalValue;
                        digitalSig.Set();
                    }
                }

            }
            catch (Exception ex)
            {
                LogUtil.error("ABB[" + ip + "]  SetRobotSignal  [" + name + "] Error:" + ex.ToString());
            }
        }

        public static void ResetRobotSignal(string ip, string name)
        {
            try
            {
                Controller controller = GetControllerByIP(ip);
                if (controller != null)
                {
                    //string name = comboBox1.Text;
                    Signal singalValue = controller.IOSystem.GetSignal(name);
                    if (singalValue == null)
                    {
                        LogUtil.error("ABB[" + ip + "] GetSignal [" + name + "]= null");
                    }
                    else
                    {
                        DigitalSignal digitalSig = (DigitalSignal)singalValue;
                        digitalSig.Reset();
                    }
                }

            }
            catch (Exception ex)
            {
                LogUtil.error("ABB[" + ip + "]  ResetRobotSignal  [" + name + "] Error:" + ex.ToString());
            }
        }
        public static int GetSingalState(string ip, string name = "do_ES")
        {
            try
            {
                Controller controller = GetControllerByIP(ip);
                if (controller != null)
                {
                    //string name = comboBox1.Text;
                    Signal singalValue = controller.IOSystem.GetSignal(name);
                    if (singalValue == null)
                    {
                        LogUtil.error("ABB[" + ip + "] GetSingal  [" + name + "]= null");
                    }
                    else
                    {
                        DigitalSignal digitalSig = (DigitalSignal)singalValue;
                        return (int)digitalSig.Value;
                    }
                }

            }
            catch (Exception ex)
            {
                LogUtil.error("ABB[" + ip + "]  GetSingalState  [" + name + "] Error:" + ex.ToString());
            }
            return 0;
        }
        public static ControllerState GetRobotState(string ip)
        {
            try
            {
                Controller controller = GetControllerByIP(ip);
                if (controller != null)
                {
                    ControllerState state = controller.State;
                    // return state.ToString();
                    return state;
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("ABB[" + ip + "] GetRobotState" + "error:" + ex.ToString());
            }
            return ControllerState.Unknown;
        }

        public static Controller GetControllerByIP(string ip)
        {
            if (controllerMap.ContainsKey(ip))
            {
                return controllerMap[ip];
            }
            LogUtil.error("ABB [" + ip + "] GetControllerByIP= null");
            return null;
        }


        public static void Dispose()
        {
            StopServer();
            foreach (Controller con in controllerMap.Values)
            {
                con.Logoff();
                con.Dispose();
            }
            controllerMap.Clear();
        }


        #region TCPServer
        private static TcpServer tcpserver = null;
        public static bool IsStart = false;

        private static int ABBServerPort = ConfigAppSettings.GetIntValue(Setting_Init.ABBServerPort);
        public static string ErrorInfo = "";

        public static string Cmd_movep = "movep";
        public static string Cmd_moveget = "moveget";
        public static string Cmd_moveput = "moveput";
        public static string Cmd_validateP = "validateP";

        public static Dictionary<string, Client> ClientMap = new Dictionary<string, Client>();

        //最后一次软件控制移动到的位置
        public static string LastSendPoint = "";

        //public delegate void OpEnd(string ip, string result);
        //private static event OpEnd OnCmdEnd;

        private static object LockObj = new object();

        public static Dictionary<string, string> AbbCurrCmd = new Dictionary<string, string>();

        private static void StartServer()
        {
            try
            {
                if (ABBServerPort <= 0)
                {
                    ABBServerPort = 21;
                }
                if (!IsStart)
                {
                    ClientMap = new Dictionary<string, Client>();
                    if (tcpserver == null)
                    {
                        tcpserver = new TcpServer();
                    }
                    IsStart = true;
                    tcpserver.Start(ABBServerPort);
                    tcpserver.AcceptClientEvent += Tcpserver_AcceptClientEvent;
                    LogUtil.info("ABBTcpServer在端口[" + ABBServerPort + "]监听！");
                    tcpserver.ReviceMsgEvent += tcp_ReviceMsgEvent;
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("ABBTcpServer启动[" + ABBServerPort + "]监听错误：" + ex.ToString());
            }
        }

        private static void Tcpserver_AcceptClientEvent(Client client)
        {
            SaveRobotClient(client);
        }
        private static object MapLock = "";
        private static void SaveRobotClient(Client client)
        {
            lock (MapLock)
            {
                IPEndPoint clientipe = (IPEndPoint)client.ClientSocket.RemoteEndPoint;
                string ip = clientipe.Address.ToString();
                if (ClientMap.ContainsKey(ip))
                {
                    ClientMap.Remove(ip);
                }
                ClientMap.Add(ip, client);
            }
        }
        private static void StopServer()
        {
            try
            {
                if (IsStart)
                {
                    IsStart = false;
                    tcpserver.ReviceMsgEvent -= tcp_ReviceMsgEvent;
                    tcpserver.Stop();
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("关闭 监听出错：" + ex.ToString());
            }
        }
        private static void tcp_ReviceMsgEvent(Client client, string msg)
        {
            try
            {
                if (System.String.IsNullOrEmpty(msg))
                {
                    return;
                }
                ProcessMsg(client, msg);

            }
            catch (Exception ex)
            {
                LogUtil.error("处理ABB消息【" + msg + "】出错：" + ex.ToString());
            }
        }

        public static string FINISHED = "FINISHED";
        private static bool ProcessMsg(Client client, string msg)
        {
            IPEndPoint clientipe = (IPEndPoint)client.ClientSocket.RemoteEndPoint;
            string add = clientipe.Address.ToString();
            //  string[] msgArray = msg.Split(cmd_spilt);
            msg = msg.Replace("\r", "");
            LogUtil.info("Revice[" + add + "]:[" + msg + "]");
            //msg = msg.Replace(";", "");
            string OkStr = "OK";

            string preCmd = GetAbbCmd(add);
            if (preCmd.Contains(FINISHED))
            {
                preCmd = preCmd.Replace(FINISHED, "");
            }
            if (msg.Contains("ERROR"))
            {
                ErrorInfo = msg;
            }
            else if ((!preCmd.Equals("")) && msg.Contains(preCmd))
            { 
                if (msg.Contains(OkStr))
                {
                    UpdateAbbCmd(add, "");
                    //OnCmdEnd?.Invoke(add, msg);
                }
                else if (msg.Contains(FINISHED))
                {
                    //TODO 
                    UpdateAbbCmd(add, msg);
                }
            }
            //else if (msg.Contains(Cmd_movep) && msg.Contains(OkStr))
            //{
            //    OnCmdEnd?.Invoke(add, msg);
            //}
            //else if (msg.Contains(Cmd_moveget) && msg.Contains(OkStr))
            //{
            //    OnCmdEnd?.Invoke(add, msg);
            //    UpdateAbbCmd(add, "");
            //}
            else if (msg.Contains(OkStr))
            {
                LogUtil.info("Revice[" + add + "]:[" + msg + "]  未找到相关处理，preCmd="+preCmd);
                //OnCmdEnd?.Invoke(add, msg);
            }
            return false;
        }


        public static bool SendCmd(string robotIp, string moveCmd, string pName, string moveType = "L", int Speed = 10)
        {

            //取料get，根据尺寸7,11,13，15，分别为：p1,p2,p3,p4
            //放料：大料架：cp，小料架：dp

            string str = moveCmd + "," + pName + "," + moveType + "," + Speed + "";
            UpdateAbbCmd(robotIp, str);

            if (moveCmd.Equals(Cmd_moveget) || moveCmd.Equals(Cmd_movep) || moveCmd.Equals(Cmd_moveput) || moveCmd.Equals(Cmd_validateP))
            { }
            else
            {
                LogUtil.error ("Send [" + robotIp + "] : [" + str + "] 失败，命令无效");
                return false;
            }
            Client client = null;
            lock (LockObj)
            {
                if (ClientMap.ContainsKey(robotIp))
                {
                    client = ClientMap[robotIp];
                }
            }
            if (client != null && client.ClientSocket.Connected)
            {
                LastSendPoint = pName;
                LogUtil.info("Send [" + robotIp + "] : [" + str + "]");
                SaveLastCmd(robotIp, str);
                byte[] sendBuffer = new byte[1024];
                sendBuffer = Encoding.UTF8.GetBytes(str);
                client.ClientSocket.Send(sendBuffer);
                return true;
            }
            else
            {
                LogUtil.error("Send [" + robotIp + "] : [" + str + "] 失败，客户端未连接");
            }
            return false;
        } 
        private static void UpdateAbbCmd(string robotIp, string moveCmd)
        { 
            if (AbbCurrCmd.ContainsKey(robotIp))
            {
                AbbCurrCmd.Remove(robotIp);
            }
            if (System.String.IsNullOrEmpty(moveCmd).Equals(false))
            {
                AbbCurrCmd[robotIp] = moveCmd;
            }
        }
        public static string GetAbbCmd(string robotIp)
        {
            if (AbbCurrCmd.ContainsKey(robotIp))
            {
                return AbbCurrCmd[robotIp];
            }
            return "";
        }

        public static bool IsConnected(string ip)
        {
            if (ClientMap.ContainsKey(ip) && ABBControl.GetRobotState(ip).Equals(ControllerState.MotorsOn))
            {
                if (ABBControl.GetSingalState(ip, ABBControl.Do_AutoOn).Equals(1))
                    return true;
            }
            return false;
        }


        #region 连续动作
        public  static  bool IsAutoMove = false;
        public static string  LastAutoP = "";
        public static void StartConMove(string ip, List<string> movePList, string mType = "L", string getp = "p1", int speed = 0)
        {
            if (speed <= 0)
            {
                speed = DefaultSpeed;
            }
            if (IsAutoMove)
            {
                return;
            }

            System.Threading.Tasks.Task.Factory.StartNew(delegate
            {
                IsAutoMove = true;
                try
                {

                    foreach (string currP in movePList)
                    {
                        LastAutoP = " " + getp + " -> " + currP + "  取料 ";
                        string result = "";
                        int timeOutMs = 600000;
                        DateTime startTime = DateTime.Now;
                        ABBControl.SendCmd(ip, ABBControl.Cmd_moveget, getp, "L", speed);
                        while (true)
                        {
                            Thread.Sleep(100);
                            TimeSpan span = DateTime.Now - startTime;

                            if (!IsAutoMove)
                            {
                                result = "手动停止";
                                break;
                            }
                            else if (span.TotalMilliseconds > timeOutMs)
                            {
                                result = getLastCmd(ip) + "超时";
                                break;
                            }
                            //判断Buzy及位置是否结束
                            else if (ABBControl.GetAbbCmd(ip).Equals(""))
                            {
                                result = "";
                                break;
                            }
                        }

                        if (result.Equals(""))
                        {
                            LogUtil.info("ABB " + ip + "连续运动[" + LastAutoP + "]结束：" + result);
                        }
                        else
                        {
                            LogUtil.error("ABB " + ip + "连续运动[" + LastAutoP + "]结束：" + result + "，结束连续运动");
                            break;
                        }

                        result = "";
                        startTime = DateTime.Now;
                        LastAutoP = " " + getp + " -> " + currP + "  放料 ";
                        ABBControl.SendCmd(ip, ABBControl.Cmd_moveput, currP, "L", speed);
                        while (true)
                        {
                            Thread.Sleep(50);
                            TimeSpan span = DateTime.Now - startTime;
                            if (!IsAutoMove)
                            {
                                result = "手动停止";
                                break;
                            }
                            else if (span.TotalMilliseconds > timeOutMs)
                            {
                                result = getLastCmd(ip) + "超时";
                                break;
                            }
                            //判断Buzy及位置是否结束
                            else if (ABBControl.GetAbbCmd(ip).Equals(""))
                            {
                                result = "";
                                break;
                            }
                        }
                        if (result.Equals(""))
                        {
                            LogUtil.info("ABB " + ip + "连续运动[" + LastAutoP + "]结束：" + result);
                        }
                        else
                        {
                            LogUtil.error("ABB " + ip + "连续运动[" + LastAutoP + "]结束：" + result + "，结束连续运动");
                            break;
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.error("ABB " + ip + "连续运动错误：" + ex.ToString());
                }
                finally { IsAutoMove = false; }

            });

        }
        public static void StopConMove()
        {
            IsAutoMove = false;
        }
        private static Dictionary<string, string> lastCmdMap = new Dictionary<string, string>();
        public static string getLastCmd(string ip)
        {
            if (lastCmdMap.ContainsKey(ip))
            {
                return lastCmdMap[ip];
            }
            return "";
        }
        private  static void SaveLastCmd(string ip, string cmd)
        {
            try
            {
                if (lastCmdMap.ContainsKey(ip))
                {
                    lastCmdMap[ip] = "[" + DateTime.Now.ToLongTimeString() + "]" + cmd;
                }
                else
                {
                    lastCmdMap.Add(ip, "[" + DateTime.Now.ToLongTimeString() + "]" + cmd);
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("SaveLastCmd[" + ip + "][" + cmd + "]error :" + ex.ToString());
            }
        } 

        #endregion
    }
    #endregion
}