using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;

namespace Core.StlMes.Client.LgResMgt.Mcms
{
    public class SocketServer : iCommunication
    {
        private readonly Dictionary<string, Socket> Clients = new Dictionary<string, Socket>();


        //用于监听的SOCKET
        private Socket _socketWatch;
        public string WeightValue { get; set; }//重量信息

        public string Ip { get; set; }


        public string Port { get; set; }

        public string LocalPort { get; set; }
        public bool Show { get; set; }

        public void Start()
        {
            //当点击开始监听的时候 在服务器端创建一个负责监听IP地址和端口号的Socket
            _socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //获取ip地址
            var ip = IPAddress.Parse(Ip);
            //创建端口号
            var point = new IPEndPoint(ip, Convert.ToInt32(Port));
            //绑定IP地址和端口号
            _socketWatch.Bind(point);
            //开始监听:设置最大可以同时连接多少个请求
            _socketWatch.Listen(10);

            OnReceiveData("", string.Format("开启监听 ip:{0} 端口:{1} 监听客户端上限:{2}", Ip, Port, "10"), DataType.StartListen);

            new Task(() => StartListen(_socketWatch)).Start();

            Status = true;
        }

        public void Stop()
        {
            Status = false;

            if (_socketWatch != null)
                _socketWatch.Close();

            OnReceiveData("", string.Format("断开监听 ip:{0} 端口:{1} ", Ip, Port), DataType.StopListen);

            if (Clients != null)
            {
                foreach (var keyValuePair in Clients)
                    try
                    {
                        keyValuePair.Value.Disconnect(false);
                        keyValuePair.Value.Shutdown(SocketShutdown.Both);
                        Thread.Sleep(10);
                        keyValuePair.Value.Close();
                        OnReceiveData(keyValuePair.Key, string.Format("断开远程客户端连接 ip:{0}", keyValuePair.Key),
                            DataType.ClientDisconnect);
                    }
                    catch (Exception)
                    {
                    }
                Clients.Clear();
            }
        }

        public event ReceiveDataHandler ReceiveData;

        public void ChangeProtocol(IProtocol iProtocol)
        {
        }

        public bool Status { get; set; }


        protected virtual void OnReceiveData(object data, string message, DataType dataType, byte[] bData = null)
        {
            var handler = ReceiveData;
            if (handler != null)
                new Task(() => { handler(this, data, message, dataType, bData); }).Start();
            // handler(this, data, DeviceName + "    " + message); 
        }

        public void SendMsgToClient(byte[] data)
        {
            if ((Clients == null) || !Clients.Any())
            {
                OnReceiveData("", "无远程客户端", DataType.EvenMessage);
                return;
            }


            foreach (var keyValuePair in Clients.ToArray())
            {
                if (keyValuePair.Value.Poll(1000, SelectMode.SelectRead))
                {
                    keyValuePair.Value.Close(); //关闭socket
                    Clients.Remove(keyValuePair.Key);
                    OnReceiveData(keyValuePair.Key, "远程客户端已经断开连接, IP:" + keyValuePair.Key, DataType.ClientDisconnect);
                    continue;
                }

                /*  if (!keyValuePair.Value.Connected)
                {
                    Clients.Remove(keyValuePair.Key);
                    OnReceiveData(keyValuePair.Key, "远程客户端已经断开连接, IP:" + keyValuePair.Key, DataType.ClientDisconnect);
                    continue;
                }
*/


                try
                {
                    keyValuePair.Value.Send(data);
                }
                catch (Exception ex)
                {
                    OnReceiveData("", "发生远程客户端[ip:" + keyValuePair.Key + "]失败:" + ex.Message, DataType.Error);
                }
            }
        }
        
        private void StartListen(object obj)
        {
            var socketWatch = obj as Socket;
            while (Status)
                try
                {
                    //等待客户端的连接，并且创建一个用于通信的Socket
                    var socketSend = socketWatch.Accept();


                    var buffer = new byte[2048];
                    socketSend.ReceiveTimeout = 5000;
                    var count = socketSend.Receive(buffer);
                    if ((count <= 0) || !((buffer[0] == 0xE6) && (buffer[1] == 0x00) && (buffer[2] == 0xE7)))
                    {
                        socketSend.Shutdown(SocketShutdown.Both);
                        socketSend.Close();
                    }
                    else
                    {
                        socketSend.Send(new byte[] {0xE6, 0X00, 0XE7});


                        //获取远程主机的ip地址和端口号
                        var strIp = socketSend.RemoteEndPoint.ToString();


                        if (Clients.ContainsKey(strIp)) Clients.Remove(strIp);


                        Clients.Add(strIp, socketSend);

                        OnReceiveData(strIp, string.Format("远程客户端连接成功, IP:{0}", strIp), DataType.ClientConnect);
                    }
                }
                catch (Exception)
                {
                }
        }

        /// <summary>
        ///     //获取本机IP地址
        /// </summary>
        /// <returns></returns>
        public string GetIpAdress()
        {
            try
            {
                var HostName = Dns.GetHostName(); //得到主机名
                var IpEntry = Dns.GetHostEntry(HostName);
                for (var i = 0; i < IpEntry.AddressList.Length; i++)
                    if (IpEntry.AddressList[i].AddressFamily == AddressFamily.InterNetwork)
                        return IpEntry.AddressList[i].ToString();
                return "";
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }
    }
}