using System;
using System.Configuration;
using System.Threading;
using WebSocket4Net;


namespace Container.Common
{
    public class WebSocketForProgram
    {
        private WebSocket websocket = null;
        App app = ((App)System.Windows.Application.Current);
        public delegate void WebSocketReceiveDelegate(string type, string message);
        public static event WebSocketReceiveDelegate WebSocketReceiveEvent;
        private Class_Log log = new Class_Log();
        bool reconnect = false;
        #region WebSocketClient

        public void OpenWebSocket()
        {
            try
            {
                //var ws = ConfigurationManager.AppSettings["websocketProgram"];
                var ws = "ws://" + app.websocketProgramIP + ":" + ConfigurationManager.AppSettings["websocketProgramPort"];
                log.WriteLogFile("ws--" + ws, "GetSyncDev");
                if (websocket != null) {
                    if (websocket.State == WebSocketState.Open)
                    {
                        websocket.Close();
                    }
                    websocket.Dispose();
                    websocket = null;
                }
                websocket = new WebSocket(ws);
                websocket.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(websocket_Error);
                websocket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(websocket_MessageReceived);
                websocket.Opened += new EventHandler(websocket_Opened);
                websocket.Closed += new EventHandler(websocket_Closed);
                websocket.Open();
            }
            catch (Exception ex)
            {
                log.WriteLogFile(ex.ToString());
            }
        }

        public void ReloadWebSocket()
        {
            try
            {
                if (websocket != null)
                {
                    reconnect = false;
                    websocket.Close();
                    websocket.Dispose();
                    websocket = null;
                }
                log.WriteLogFile("打开--", "GetSyncDev");
                OpenWebSocket();
            }
            catch (Exception e)
            {

                log.WriteLogFile(e.ToString(), "WebSocketForProgramError");
            }
        }
        void websocket_Closed(object sender, EventArgs e)
        {
            app.isProgramSync = false;
            //if (!reconnect)
            //{
            //    reconnect = true;
            //    ReConnect();
            //}
        }
        void websocket_Opened(object sender, EventArgs e) {
            reconnect = false;
            log.WriteLogFile("打开","客户端");
            app.isProgramSync = true;
        }

        public void CloseWebSocket()
        {
            
            if (websocket != null)
            {
                reconnect = true;
                websocket.Close();
            }

        }

        void websocket_MessageReceived(object sender, MessageReceivedEventArgs e)
        {
            try
            {
                WebSocketReceiveEvent("play", e.Message);
            }
            catch (Exception ex)
            {
                log.WriteLogFile(ex.ToString(), "WebSocketLog");

            }
        }

        void websocket_Error(object sender, SuperSocket.ClientEngine.ErrorEventArgs e)
        {
            log.WriteLogFile("失败"+e.ToString(), "客户端");
            app.isProgramSync = false;
            //try
            //{
            //    if (websocket != null)
            //        websocket.Close();
            //}
            //catch
            //{
            //}
            //reconnect = true;
            //ReConnect();
        }

        /// <summary>
        /// websocket重连
        /// </summary>
        private void ReConnect()
        {
            try
            {
                Action ac = new Action(() =>
                {
                    while (reconnect)
                    {
                        log.WriteLogFile("重试"+ (websocket==null), "WebSocketForProgramErrorLog");
                        try
                        {
                            if (websocket != null)
                            {
                                log.WriteLogFile("重试State" + websocket.State, "WebSocketForProgramErrorLog");
                                if (websocket.State == WebSocketState.Closed)
                                {
                                    reconnect = false;
                                    websocket.Open();
                                }

                                if (websocket.State == WebSocketState.Open)
                                {
                                    reconnect = false;
                                    break;
                                }
                            }
                            else {
                                log.WriteLogFile("重试OpenWebSocket", "WebSocketForProgramErrorLog");
                                //Thread.Sleep(10000);
                                OpenWebSocket();
                            }
                        }
                        catch (Exception ex)
                        {
                            log.WriteLogFile(ex.ToString(), "WebSocketForProgramErrorLog");
                        }
                        finally
                        {
                            Thread.Sleep(10000);
                        }


                    }
                });
                ac.BeginInvoke((o) =>
                {
                    //reconnect = false;
                }, null);
            }
            catch (Exception ex)
            {
                log.WriteLogFile(ex.ToString(), "WebSocketForProgramErrorLog");
            }
        }

        #endregion
    }
}