using Google.Protobuf.WellKnownTypes;
using JiangsuEarthquake.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using static JiangsuEarthquake.Common.SocketHelper;

namespace JiangsuEarthquake.Models
{
    public class ServerModel : NotifyBase
    {
        private SocketInfo SI { get; set; } = new SocketInfo();

        private LowerComputerModel lowerComputerModel { get; set; } = new LowerComputerModel();

        //public Server server { get; set; } = new Server();
        public SocketHelper.TcpServer server { get; set; } = new SocketHelper.TcpServer();

        private bool isOpened = false;

        /// <summary>
        /// 服务器是否开启
        /// </summary>
        public bool IsOpened
        {
            get { return isOpened; }
            set { isOpened = value; this.DoNotify(); }
        }

        //private bool isConnected = false;

        ///// <summary>
        ///// 客户端是否连接
        ///// </summary>
        //public bool IsConnected
        //{
        //    get { return isConnected; }
        //    set { isConnected = value; this.DoNotify(); }
        //}

        /// <summary>
        /// 启动服务器
        /// </summary>
        /// <param name="socketInfo"></param>
        /// <returns></returns>
        public bool DoStart(SocketInfo socketInfo)
        {
            SI.IP = socketInfo.IP;
            SI.Port = socketInfo.Port;

            try
            {
                server.InitSocket(socketInfo.IP, socketInfo.Port);  //初始化设备的IP和端口号
                IsOpened = server.Start();

                if (IsOpened)
                {
                    //SocketHelper.pushSockets = new SocketHelper.PushSockets(ReceiveMess);
                    server.pushSockets = ReceiveMess;

                    Console.WriteLine("Server：服务器开启成功，开始接收数据");
                }

                return IsOpened;
            }
            catch(Exception ex)
            {
                IsOpened = false;
                Console.WriteLine("Server DoStart Error：" + ex.Message);

                return IsOpened;
            }
        }

        /// <summary>
        /// 停止服务器
        /// </summary>
        public bool DoStop()
        {
            server.Stop();
            IsOpened = false;
            Console.WriteLine("Server：服务器已关闭");

            return IsOpened;
        }

        /// <summary>
        /// 委托刷新客户数据
        /// </summary>
        private void ReceiveMess(SocketHelper.Sockets sks)
        {
            if (sks.ex != null)
            {
                //在此处理异常信息
                if (sks.ClientDispose)
                {
                    //客户端非主动断开连接下线.  非正常下线  
                    if (sks.Ip != null)
                    {
                        server.ClientList.Remove(sks);
                        server.IsConnected = false;
                        //IsConnected = false;

                        Console.WriteLine("Server ReceiveMess Error：客户端非主动断开连接下线");
                    }
                }
            }
            else
            {
                if (sks.Offset == 0)
                {
                    //正常是不会发送0包的,只有客户端主动断开连接时发送空包.
                    //客户端下线.
                    if (sks.Ip != null && server.ClientList.Contains(sks))
                    {
                        server.ClientList.Remove(sks);
                        server.IsConnected = false;

                        Console.WriteLine("Server ReceiveMess Error：客户端主动断开连接下线");
                    }

                    //IsConnected = false;
                }
                else if (sks.NewClientFlag)
                {
                    server.ClientList.Add(sks);
                    server.IsConnected = true;

                    Console.WriteLine("Server：监测到新客户端" + SI.IP + "/" + SI.Port);
                    //IsConnected = true;
                }
                else
                {
                    //IsConnected = true;

                    //接收客户端消息
                    byte[] buffer = new byte[sks.Offset];
                    Array.Copy(sks.RecBuffer, buffer, sks.Offset);
                    try
                    {
                        int stationName = 0;
                        if (SI.Port == int.Parse(Tools.GetAppSetting("XWJ_Service_Port1")) && SI.IP == Tools.GetAppSetting("XWJ_Service_IP1"))
                        {
                            stationName = 1;
                        }
                        else if (SI.Port == int.Parse(Tools.GetAppSetting("XWJ_Service_Port2")) && SI.IP == Tools.GetAppSetting("XWJ_Service_IP2"))
                        {
                            stationName = 2;
                        }

                        lowerComputerModel.ParsingData(new List<byte>(buffer), stationName);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Server ReceiveMess Error：" + ex.ToString());
                        return;
                    }
                }
            }
        }


        /// <summary>
        /// 发送消息给客户端
        /// </summary>
        public void SendToClient(IPEndPoint ip, byte[] SendData)
        {
            Task.Factory.StartNew(new Action(() =>
            {
                Thread.Sleep(1000);
                server.SendToClient(ip, SendData);
            }));
        }


        /// <summary>
        /// 推送消息
        /// </summary>
        public bool SendMessage(byte[] SendData)
        {
            bool result = false;
            try
            {
                //Task.Factory.StartNew(new Action(() =>
                //{
                server.SendToAll(SendData);
                result = true;
                //}));
            }
            catch(Exception ex)
            {
                Console.WriteLine("Server SendMessage Error：" + ex.ToString());

                result = false;
            }
            return result;
        }
    }
}