#region MIT License
/**
 * WebSocket.cs
 *
 * A C# implementation of the WebSocket interface.
 * This code derived from WebSocket.java (http://github.com/adamac/Java-WebSocket-client).
 *
 * The MIT License
 *
 * Copyright (c) 2009 Adam MacBeth
 * Copyright (c) 2010-2012 sta.blockhead
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using WebSocketSharp.Frame;
using WebSocketSharp.Net;
using WebSocketSharp.Net.Sockets;

namespace WebSocketSharp
{

    /// <summary>
    /// Implements the WebSocket interface.
    /// </summary>
    /// <remarks>
    /// The WebSocket class provides methods and properties for two-way communication using the WebSocket protocol (RFC 6455).
    /// </remarks>
    public class WebSocket : IDisposable
    {
        #region Private Const Fields

        private const int _fragmentLen = 1016; // Max value is int.MaxValue - 14.
        private const string _guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
        private const string _version = "13";

        #endregion

        #region Private Fields

        private string _base64key;
        private HttpListenerContext _httpContext;
        private WebSocketContext _context;
        private System.Net.IPEndPoint _endPoint;
        private string _extensions;
        private AutoResetEvent _exitMessageLoop;
        private Object _forClose;
        private Object _forSend;
        private bool _isClient;
        private bool _isSecure;
        private string _protocol;
        private string _protocols;
        private NameValueCollection _queryString;
        private volatile WsState _readyState;
        private AutoResetEvent _receivePong;
        private TcpClient _tcpClient;
        private Uri _uri;
        private SynchronizedCollection<WsFrame> _unTransmittedBuffer;
        private WsStream _wsStream;
        private string _origin;

        #endregion

        #region Private Constructor

        private WebSocket()
        {
            _extensions = String.Empty;
            _forClose = new Object();
            _forSend = new Object();
            _protocol = String.Empty;
            _readyState = WsState.CONNECTING;
            _unTransmittedBuffer = new SynchronizedCollection<WsFrame>();
        }

        #endregion

        #region Internal Constructor

        internal WebSocket(HttpListenerWebSocketContext context)
            : this()
        {
            _uri = Ext.ToUri(context.Path);
            _context = context;
            _httpContext = context.BaseContext;
            _wsStream = context.Stream;
            _endPoint = context.ServerEndPoint;
            _isClient = false;
            _isSecure = context.IsSecureConnection;
        }

        internal WebSocket(TcpListenerWebSocketContext context)
            : this()
        {
            _uri = Ext.ToUri(context.Path);
            _context = context;
            _tcpClient = context.Client;
            _wsStream = context.Stream;
            _endPoint = context.ServerEndPoint;
            _isClient = false;
            _isSecure = context.IsSecureConnection;
        }

        #endregion

        #region Public Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="WebSocketSharp.WebSocket"/> class with the specified WebSocket URL and subprotocols.
        /// </summary>
        /// <param name="url">
        /// A <see cref="string"/> that contains the WebSocket URL.
        /// </param>
        /// <param name="protocols">
        /// An array of <see cref="string"/> that contains the WebSocket subprotocols if any.
        /// </param>
        /// <exception cref="ArgumentNullException">
        /// <paramref name="url"/> is <see langword="null"/>.
        /// </exception>
        /// <exception cref="ArgumentException">
        /// <paramref name="url"/> is not valid WebSocket URL.
        /// </exception>
        public WebSocket(string url, params string[] protocols)
            : this()
        {
            if (url == null)
                throw new ArgumentNullException("url");

            Uri uri;
            string msg;
            if (!tryCreateUri(url, out uri, out msg))
                throw new ArgumentException(msg, "url");

            _uri = uri;
            _protocols = Ext.ToString(protocols, ", ");
            _base64key = createBase64Key();
            _isClient = true;
            _isSecure = uri.Scheme == "wss" ? true : false;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="WebSocketSharp.WebSocket"/> class with the specified WebSocket URL, OnOpen, OnMessage, OnError, OnClose event handlers and subprotocols.
        /// </summary>
        /// <param name="url">
        /// A <see cref="string"/> that contains the WebSocket URL.
        /// </param>
        /// <param name="onOpen">
        /// An OnOpen event handler.
        /// </param>
        /// <param name="onMessage">
        /// An OnMessage event handler.
        /// </param>
        /// <param name="onError">
        /// An OnError event handler.
        /// </param>
        /// <param name="onClose">
        /// An OnClose event handler.
        /// </param>
        /// <param name="protocols">
        /// An array of <see cref="string"/> that contains the WebSocket subprotocols if any.
        /// </param>
        /// <exception cref="ArgumentNullException">
        /// <paramref name="url"/> is <see langword="null"/>.
        /// </exception>
        /// <exception cref="ArgumentException">
        /// <paramref name="url"/> is not valid WebSocket URL.
        /// </exception>
        public WebSocket(
          string url,
          EventHandler onOpen,
          EventHandler<MessageEventArgs> onMessage,
          EventHandler<ErrorEventArgs> onError,
          EventHandler<CloseEventArgs> onClose,
          params string[] protocols)
            : this(url, protocols)
        {
            OnOpen = onOpen;
            OnMessage = onMessage;
            OnError = onError;
            OnClose = onClose;

            Connect();
        }

        #endregion

        #region Internal Property

        internal NameValueCollection QueryString
        {
            get
            {
                return _queryString;
            }
        }

        #endregion

        #region Public Properties

        /// <summary>
        /// Gets the amount of untransmitted data.
        /// </summary>
        /// <value>
        /// The number of bytes of untransmitted data.
        /// </value>
        public ulong BufferedAmount
        {
            get
            {
                lock (_unTransmittedBuffer.SyncRoot)
                {
                    ulong bufferedAmount = 0;
                    foreach (WsFrame frame in _unTransmittedBuffer)
                        bufferedAmount += frame.PayloadLength;

                    return bufferedAmount;
                }
            }
        }

        /// <summary>
        /// Gets the extensions selected by the server.
        /// </summary>
        /// <value>
        /// A <see cref="string"/> that contains the extensions if any. By default, <c>String.Empty</c>. (Currently this will only ever be the <c>String.Empty</c>.)
        /// </value>
        public string Extensions
        {
            get
            {
                return _extensions;
            }
        }

        /// <summary>
        /// Gets a value indicating whether a connection is alive.
        /// </summary>
        /// <value>
        /// <c>true</c> if the connection is alive; otherwise, <c>false</c>.
        /// </value>
        public bool IsAlive
        {
            get
            {
                if (_readyState != WsState.OPEN)
                    return false;

                return Ping();
            }
        }

        /// <summary>
        /// Gets a value indicating whether a connection is secure.
        /// </summary>
        /// <value>
        /// <c>true</c> if the connection is secure; otherwise, <c>false</c>.
        /// </value>
        public bool IsSecure
        {
            get
            {
                return _isSecure;
            }
        }

        /// <summary>
        /// Gets the subprotocol selected by the server.
        /// </summary>
        /// <value>
        /// A <see cref="string"/> that contains the subprotocol if any. By default, <c>String.Empty</c>.
        /// </value>
        public string Protocol
        {
            get
            {
                return _protocol;
            }
        }

        /// <summary>
        /// Gets the state of the connection.
        /// </summary>
        /// <value>
        /// A <see cref="WebSocketSharp.WsState"/>. By default, <c>WsState.CONNECTING</c>.
        /// </value>
        public WsState ReadyState
        {
            get
            {
                return _readyState;
            }
        }

        /// <summary>
        /// Gets the untransmitted WebSocket frames.
        /// </summary>
        /// <value>
        /// A <c>IList&lt;WsFrame&gt;</c> that contains the untransmitted WebSocket frames.
        /// </value>
        public IList<WsFrame> UnTransmittedBuffer
        {
            get
            {
                return _unTransmittedBuffer;
            }
        }

        /// <summary>
        /// Gets or sets the WebSocket URL.
        /// </summary>
        /// <value>
        /// A <see cref="Uri"/> that contains the WebSocket URL.
        /// </value>
        public Uri Url
        {
            get { return _uri; }
            set
            {
                if (_readyState == WsState.CONNECTING && !_isClient)
                    _uri = value;
            }
        }

        /// <summary>
        /// Gets or sets the WebSocket Origin.
        /// </summary>
        public string Origin
        {
            get { return this._origin; }
            set { this._origin = value; }
        }

        /// <summary>
        /// Gets or sets the extra WebSocket handshake headers.
        /// </summary>
        public IDictionary<string, string> ExtraHeaders { get; set; }

        #endregion

        #region Events

        /// <summary>
        /// Occurs when the WebSocket connection has been established.
        /// </summary>
        public event EventHandler OnOpen;

        /// <summary>
        /// Occurs when the WebSocket receives a data frame.
        /// </summary>
        public event EventHandler<MessageEventArgs> OnMessage;

        /// <summary>
        /// Occurs when the WebSocket gets an error.
        /// </summary>
        public event EventHandler<ErrorEventArgs> OnError;

        /// <summary>
        /// Occurs when the WebSocket receives a Close frame or the Close method is called.
        /// </summary>
        public event EventHandler<CloseEventArgs> OnClose;

        #endregion

        #region Private Methods

        // As Server
        private void acceptHandshake()
        {
            var req = receiveOpeningHandshake();

            string msg;
            if (!isValidRequest(req, out msg))
            {
                onError(msg);
                close(CloseStatusCode.HANDSHAKE_FAILURE, msg);
                return;
            }

            sendResponseHandshake();
            onOpen();
        }

        private bool canSendAsCloseFrame(PayloadData data)
        {
            if (data.Length >= 2)
            {
                var code = Ext.To<ushort>(Ext.SubArray(data.ToBytes(), 0, 2), ByteOrder.BIG);
                if (code == (ushort)CloseStatusCode.NO_STATUS_CODE ||
                    code == (ushort)CloseStatusCode.ABNORMAL ||
                    code == (ushort)CloseStatusCode.HANDSHAKE_FAILURE)
                    return false;
            }

            return true;
        }

        private void close(HttpStatusCode code)
        {
            if (_readyState != WsState.CONNECTING || _isClient)
                return;

            sendResponseHandshake(code);
            closeConnection();
        }

        private void close(PayloadData data)
        {
#if DEBUG
            Console.WriteLine("WS: Info@close: Current thread IsBackground ?: {0}", Thread.CurrentThread.IsBackground);
#endif
            lock (_forClose)
            {
                // Whether the closing handshake has been started already ?
                if (_readyState == WsState.CLOSING ||
                    _readyState == WsState.CLOSED)
                    return;

                // Whether the closing handshake as server is started before the connection has been established ?
                if (_readyState == WsState.CONNECTING && !_isClient)
                {
                    sendResponseHandshake(HttpStatusCode.BadRequest);
                    onClose(new CloseEventArgs(data));

                    return;
                }

                _readyState = WsState.CLOSING;
            }

            // Whether a close status code that must not be set for send is used ?
            if (!canSendAsCloseFrame(data))
            {
                onClose(new CloseEventArgs(data));
                return;
            }

            closeHandshake(data);
#if DEBUG
            Console.WriteLine("WS: Info@close: Exits close method.");
#endif
        }

        private void close(CloseStatusCode code, string reason)
        {
            close((ushort)code, reason);
        }

        private void close(ushort code, string reason)
        {
            var data = new List<byte>(Ext.ToBytes(code, ByteOrder.BIG));
            if (!Ext.IsNullOrEmpty(reason))
            {
                var buffer = Encoding.UTF8.GetBytes(reason);
                data.AddRange(buffer);
            }

            var payloadData = new PayloadData(data.ToArray());
            if (payloadData.Length > 125)
            {
                var msg = "A Close frame must have a payload length of 125 bytes or less.";
                onError(msg);
                return;
            }

            close(payloadData);
        }

        private bool closeConnection()
        {
            _readyState = WsState.CLOSED;

            try
            {
                if (_httpContext != null)
                {
                    _httpContext.Response.Close();
                    _wsStream = null;
                    _httpContext = null;
                }

                if (_wsStream != null)
                {
                    _wsStream.Dispose();
                    _wsStream = null;
                }

                if (_tcpClient != null)
                {
                    _tcpClient.Close();
                    _tcpClient = null;
                }

                return true;
            }
            catch (Exception ex)
            {
                onError(ex.Message);
                return false;
            }
        }

        private void closeHandshake(PayloadData data)
        {
            var args = new CloseEventArgs(data);
            var frame = createFrame(Fin.FINAL, Opcode.CLOSE, data);
            send(frame);
            onClose(args);
        }

        // As Client
        private string createBase64Key()
        {
            var src = new byte[16];
            var rand = new Random();
            rand.NextBytes(src);

            return Convert.ToBase64String(src);
        }

        // As Client
        private void createClientStream()
        {
            var host = _uri.DnsSafeHost;
            var port = _uri.Port > 0
                     ? _uri.Port
                     : _isSecure ? 443 : 80;

            _tcpClient = new TcpClient(host, port);
            _wsStream = WsStream.CreateClientStream(_tcpClient, host, _isSecure);
        }

        private WsFrame createFrame(Fin fin, Opcode opcode, PayloadData payloadData)
        {
            return _isClient
                   ? new WsFrame(fin, opcode, payloadData)
                   : new WsFrame(fin, opcode, Mask.UNMASK, payloadData);
        }

        // As Client
        private RequestHandshake createOpeningHandshake()
        {
            var path = _uri.PathAndQuery;
            var host = _uri.DnsSafeHost;
            var port = ((System.Net.IPEndPoint)_tcpClient.Client.RemoteEndPoint).Port;
            if (port != 80)
                host += ":" + port;

            var req = new RequestHandshake(path);
            req.AddHeader("Host", host);
            req.AddHeader("Sec-WebSocket-Key", _base64key);
            if (!Ext.IsNullOrEmpty(_protocols))
                req.AddHeader("Sec-WebSocket-Protocol", _protocols);
            req.AddHeader("Sec-WebSocket-Version", _version);
            if (!string.IsNullOrEmpty(this._origin))
                req.AddHeader("Origin", this._origin);
            //extra headers
            if (this.ExtraHeaders != null)
                foreach (var i in this.ExtraHeaders)
                    req.AddHeader(i.Key, i.Value);

            return req;
        }

        // As Server
        private ResponseHandshake createResponseHandshake()
        {
            var res = new ResponseHandshake();
            res.AddHeader("Sec-WebSocket-Accept", createResponseKey());

            return res;
        }

        // As Server
        private ResponseHandshake createResponseHandshake(HttpStatusCode code)
        {
            var res = ResponseHandshake.CreateCloseResponse(code);
            res.AddHeader("Sec-WebSocket-Version", _version);

            return res;
        }

        private string createResponseKey()
        {
            SHA1 sha1 = new SHA1CryptoServiceProvider();
            var sb = new StringBuilder(_base64key);
            sb.Append(_guid);
            var src = sha1.ComputeHash(Encoding.UTF8.GetBytes(sb.ToString()));

            return Convert.ToBase64String(src);
        }

        // As Client
        private void doHandshake()
        {
            var res = sendOpeningHandshake();

            string msg;
            if (!isValidResponse(res, out msg))
            {
                onError(msg);
                close(CloseStatusCode.HANDSHAKE_FAILURE, msg);
                return;
            }

            onOpen();
        }

        private bool isValidCloseStatusCode(ushort code, out string message)
        {
            if (code < 1000)
            {
                message = "Close status codes in the range 0-999 are not used: " + code;
                return false;
            }

            if (code > 4999)
            {
                message = "Out of reserved close status code range: " + code;
                return false;
            }

            message = String.Empty;
            return true;
        }

        private bool isValidFrame(WsFrame frame)
        {
            if (frame == null)
            {
                var msg = "The WebSocket frame can not be read from the network stream.";
                close(CloseStatusCode.ABNORMAL, msg);

                return false;
            }

            return true;
        }

        // As Server
        private bool isValidRequest(RequestHandshake request, out string message)
        {
            if (!request.IsWebSocketRequest)
            {
                message = "Invalid WebSocket request.";
                return false;
            }

            if (_uri.IsAbsoluteUri && !isValidRequestHost(request.Headers["Host"], out message))
                return false;

            if (!request.HeaderExists("Sec-WebSocket-Version", _version))
            {
                message = "Unsupported Sec-WebSocket-Version.";
                return false;
            }

            _base64key = request.Headers["Sec-WebSocket-Key"];

            if (request.HeaderExists("Sec-WebSocket-Protocol"))
                _protocols = request.Headers["Sec-WebSocket-Protocol"];

            if (request.HeaderExists("Sec-WebSocket-Extensions"))
                _extensions = request.Headers["Sec-WebSocket-Extensions"];

            _queryString = request.QueryString;

            message = String.Empty;
            return true;
        }

        // As Server
        private bool isValidRequestHost(string value, out string message)
        {
            var host = _uri.DnsSafeHost;
            var type = Uri.CheckHostName(host);
            var address = _endPoint.Address;
            var port = _endPoint.Port;

            var expectedHost1 = host;
            var expectedHost2 = type == UriHostNameType.Dns
                              ? address.ToString()
                              : System.Net.Dns.GetHostEntry(address).HostName;

            if (port != 80)
            {
                expectedHost1 += ":" + port;
                expectedHost2 += ":" + port;
            }

            if (Ext.NotEqual(expectedHost1, value, false) &&
               Ext.NotEqual(expectedHost2, value, false))
            {
                message = "Invalid Host.";
                return false;
            }

            message = String.Empty;
            return true;
        }

        // As Client
        private bool isValidResponse(ResponseHandshake response, out string message)
        {
            if (!response.IsWebSocketResponse)
            {
                message = "Invalid WebSocket response.";
                return false;
            }

            if (!response.HeaderExists("Sec-WebSocket-Accept", createResponseKey()))
            {
                message = "Invalid Sec-WebSocket-Accept.";
                return false;
            }

            if (response.HeaderExists("Sec-WebSocket-Version") &&
                !response.HeaderExists("Sec-WebSocket-Version", _version))
            {
                message = "Unsupported Sec-WebSocket-Version.";
                return false;
            }

            if (response.HeaderExists("Sec-WebSocket-Protocol"))
                _protocol = response.Headers["Sec-WebSocket-Protocol"];

            if (response.HeaderExists("Sec-WebSocket-Extensions"))
                _extensions = response.Headers["Sec-WebSocket-Extensions"];

            message = String.Empty;
            return true;
        }

        private void onClose(CloseEventArgs eventArgs)
        {
            if (!Thread.CurrentThread.IsBackground)
                if (_exitMessageLoop != null)
                    _exitMessageLoop.WaitOne(5 * 1000, false);

            if (closeConnection())
                eventArgs.WasClean = true;

            Ext.Emit(OnClose, this, eventArgs);
        }

        private void onError(string message)
        {
#if DEBUG
            var callerFrame = new StackFrame(1);
            var caller = callerFrame.GetMethod();
            Console.WriteLine("WS: Error@{0}: {1}", caller.Name, message);
#endif
            Ext.Emit(OnError, this, new ErrorEventArgs(message));
        }

        private void onMessage(MessageEventArgs eventArgs)
        {
            if (eventArgs != null)
                Ext.Emit(OnMessage, this, eventArgs);
        }

        private void onOpen()
        {
            _readyState = WsState.OPEN;
            startMessageLoop();
            Ext.Emit(OnOpen, this, EventArgs.Empty);
        }

        private bool ping(string message, int millisecondsTimeout)
        {
            var buffer = Encoding.UTF8.GetBytes(message);
            if (buffer.Length > 125)
            {
                var msg = "A Ping frame must have a payload length of 125 bytes or less.";
                onError(msg);
                return false;
            }

            if (!send(Fin.FINAL, Opcode.PING, buffer))
                return false;

            return _receivePong.WaitOne(millisecondsTimeout, false);
        }

        private void pong(PayloadData data)
        {
            var frame = createFrame(Fin.FINAL, Opcode.PONG, data);
            send(frame);
        }

        private void pong(string data)
        {
            var payloadData = new PayloadData(data);
            pong(payloadData);
        }

        private WsFrame readFrame()
        {
            var frame = _wsStream.ReadFrame();
            return isValidFrame(frame) ? frame : null;
        }

        private string[] readHandshake()
        {
            return _wsStream.ReadHandshake();
        }

        private MessageEventArgs receive(WsFrame frame)
        {
            if (!isValidFrame(frame))
                return null;

            if ((frame.Fin == Fin.FINAL && frame.Opcode == Opcode.CONT) ||
                (frame.Fin == Fin.MORE && frame.Opcode == Opcode.CONT))
                return null;

            if (frame.Fin == Fin.MORE)
            {// MORE
                var merged = receiveFragmented(frame);
                return merged != null
                       ? new MessageEventArgs(frame.Opcode, new PayloadData(merged))
                       : null;
            }

            if (frame.Opcode == Opcode.CLOSE)
            {// FINAL & CLOSE
#if DEBUG
                Console.WriteLine("WS: Info@receive: Starts closing handshake.");
#endif
                close(frame.PayloadData);
                return null;
            }

            if (frame.Opcode == Opcode.PING)
            {// FINAL & PING
#if DEBUG
                Console.WriteLine("WS: Info@receive: Returns Pong.");
#endif
                pong(frame.PayloadData);
                return null;
            }

            if (frame.Opcode == Opcode.PONG)
            {// FINAL & PONG
#if DEBUG
                Console.WriteLine("WS: Info@receive: Receives Pong.");
#endif
                _receivePong.Set();
                return null;
            }

            // FINAL & (TEXT | BINARY)
            return new MessageEventArgs(frame.Opcode, frame.PayloadData);
        }

        private byte[] receiveFragmented(WsFrame firstFrame)
        {
            var buffer = new List<byte>(firstFrame.PayloadData.ToBytes());

            while (true)
            {
                var frame = readFrame();
                if (frame == null)
                    return null;

                if (frame.Fin == Fin.MORE)
                {
                    if (frame.Opcode == Opcode.CONT)
                    {// MORE & CONT
                        buffer.AddRange(frame.PayloadData.ToBytes());
                        continue;
                    }

#if DEBUG
                    Console.WriteLine("WS: Info@receiveFragmented: Starts closing handshake.");
#endif
                    close(CloseStatusCode.INCORRECT_DATA, String.Empty);
                    return null;
                }

                if (frame.Opcode == Opcode.CONT)
                {// FINAL & CONT
                    buffer.AddRange(frame.PayloadData.ToBytes());
                    break;
                }

                if (frame.Opcode == Opcode.CLOSE)
                {// FINAL & CLOSE
#if DEBUG
                    Console.WriteLine("WS: Info@receiveFragmented: Starts closing handshake.");
#endif
                    close(frame.PayloadData);
                    return null;
                }

                if (frame.Opcode == Opcode.PING)
                {// FINAL & PING
#if DEBUG
                    Console.WriteLine("WS: Info@receiveFragmented: Returns Pong.");
#endif
                    pong(frame.PayloadData);
                    continue;
                }

                if (frame.Opcode == Opcode.PONG)
                {// FINAL & PONG
#if DEBUG
                    Console.WriteLine("WS: Info@receiveFragmented: Receives Pong.");
#endif
                    _receivePong.Set();
                    continue;
                }

                // FINAL & (TEXT | BINARY)
#if DEBUG
                Console.WriteLine("WS: Info@receiveFragmented: Starts closing handshake.");
#endif
                close(CloseStatusCode.INCORRECT_DATA, String.Empty);
                return null;
            }

            return buffer.ToArray();
        }

        // As Server
        private RequestHandshake receiveOpeningHandshake()
        {
            var req = RequestHandshake.Parse(_context);
#if DEBUG
            Console.WriteLine("WS: Info@receiveOpeningHandshake: Opening handshake from client:\n");
            Console.WriteLine(req.ToString());
#endif
            return req;
        }

        // As Client
        private ResponseHandshake receiveResponseHandshake()
        {
            var res = ResponseHandshake.Parse(readHandshake());
#if DEBUG
            Console.WriteLine("WS: Info@receiveResponseHandshake: Response handshake from server:\n");
            Console.WriteLine(res.ToString());
#endif
            return res;
        }

        private bool send(WsFrame frame)
        {
            if (_readyState == WsState.CONNECTING ||
                _readyState == WsState.CLOSED)
            {
                var msg = "The WebSocket connection isn't established or has been closed.";
                onError(msg);
                return false;
            }

            try
            {
                if (_unTransmittedBuffer.Count == 0)
                {
                    if (_wsStream != null)
                    {
                        _wsStream.WriteFrame(frame);
                        return true;
                    }
                }

                if (_unTransmittedBuffer.Count > 0)
                {
                    _unTransmittedBuffer.Add(frame);
                    var msg = "Current data can not be sent because there is untransmitted data.";
                    onError(msg);
                }

                return false;
            }
            catch (Exception ex)
            {
                _unTransmittedBuffer.Add(frame);
                onError(ex.Message);
                return false;
            }
        }

        private void send(Opcode opcode, byte[] data)
        {
            using (MemoryStream ms = new MemoryStream(data))
            {
                send(opcode, ms);
            }
        }

        private void send(Opcode opcode, Stream stream)
        {
            lock (_forSend)
            {
                try
                {
                    if (_readyState != WsState.OPEN)
                    {
                        var msg = "The WebSocket connection isn't established or has been closed.";
                        onError(msg);
                        return;
                    }

                    var length = stream.Length;
                    if (length <= _fragmentLen)
                        send(Fin.FINAL, opcode, Ext.ReadBytes(stream, (int)length));
                    else
                        sendFragmented(opcode, stream);
                }
                catch (Exception ex)
                {
                    onError(ex.Message);
                }
            }
        }

        private bool send(Fin fin, Opcode opcode, byte[] data)
        {
            var frame = createFrame(fin, opcode, new PayloadData(data));
            return send(frame);
        }

        private void sendAsync(Opcode opcode, byte[] data, Action completed)
        {
            sendAsync(opcode, new MemoryStream(data), completed);
        }

        private void sendAsync(Opcode opcode, Stream stream, Action completed)
        {
            Action<Opcode, Stream> action = send;

            AsyncCallback callback = (ar) =>
            {
                try
                {
                    action.EndInvoke(ar);
                    if (completed != null)
                        completed();
                }
                catch (Exception ex)
                {
                    onError(ex.Message);
                }
                finally
                {
                    stream.Close();
                }
            };

            action.BeginInvoke(opcode, stream, callback, null);
        }

        private long sendFragmented(Opcode opcode, Stream stream)
        {
            var length = stream.Length;
            var quo = length / _fragmentLen;
            var rem = length % _fragmentLen;
            var count = rem == 0 ? quo - 2 : quo - 1;

            // First
            var buffer = new byte[_fragmentLen];
            long readLen = stream.Read(buffer, 0, _fragmentLen);
            send(Fin.MORE, opcode, buffer);

            // Mid
            Ext.Times(count, () =>
            {
                readLen += stream.Read(buffer, 0, _fragmentLen);
                send(Fin.MORE, Opcode.CONT, buffer);
            });

            // Final
            if (rem != 0)
                buffer = new byte[rem];
            readLen += stream.Read(buffer, 0, buffer.Length);
            send(Fin.FINAL, Opcode.CONT, buffer);

            return readLen;
        }

        // As Client
        private ResponseHandshake sendOpeningHandshake()
        {
            var req = createOpeningHandshake();
            sendOpeningHandshake(req);

            return receiveResponseHandshake();
        }

        // As Client
        private void sendOpeningHandshake(RequestHandshake request)
        {
#if DEBUG
            Console.WriteLine("WS: Info@sendOpeningHandshake: Opening handshake from client:\n");
            Console.WriteLine(request.ToString());
#endif
            writeHandshake(request);
        }

        // As Server
        private void sendResponseHandshake()
        {
            var res = createResponseHandshake();
            sendResponseHandshake(res);
        }

        // As Server
        private void sendResponseHandshake(HttpStatusCode code)
        {
            var res = createResponseHandshake(code);
            sendResponseHandshake(res);
        }

        // As Server
        private void sendResponseHandshake(ResponseHandshake response)
        {
#if DEBUG
            Console.WriteLine("WS: Info@sendResponseHandshake: Response handshake from server:\n");
            Console.WriteLine(response.ToString());
#endif
            writeHandshake(response);
        }

        private void startMessageLoop()
        {
            _exitMessageLoop = new AutoResetEvent(false);
            _receivePong = new AutoResetEvent(false);

            Action<WsFrame> completed = null;
            completed = (frame) =>
            {
                try
                {
                    onMessage(receive(frame));
                    if (_readyState == WsState.OPEN)
                        _wsStream.ReadFrameAsync(completed);
                    else
                        _exitMessageLoop.Set();
                }
                catch (WsReceivedTooBigMessageException ex)
                {
                    close(CloseStatusCode.TOO_BIG, ex.Message);
                }
                catch (Exception ex)
                {
                    //HACK:close with 1006 when onMessage exception?
                    close(CloseStatusCode.ABNORMAL
                        , string.Format("An exception has occured: {0}", ex.Message));
                }
            };

            _wsStream.ReadFrameAsync(completed);
        }

        private bool tryCreateUri(string uriString, out Uri result, out string message)
        {
            return Ext.TryCreateWebSocketUri(uriString, out result, out message);
        }

        private void writeHandshake(Handshake handshake)
        {
            _wsStream.WriteHandshake(handshake);
        }

        #endregion

        #region Internal Method

        // As Server
        internal void Close(HttpStatusCode code)
        {
            close(code);
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// Closes the connection and releases all associated resources after sends a Close control frame.
        /// </summary>
        public void Close()
        {
            var data = new PayloadData(new byte[] { });
            close(data);
        }

        /// <summary>
        /// Closes the connection and releases all associated resources after sends a Close control frame.
        /// </summary>
        /// <param name="code">
        /// A <see cref="WebSocketSharp.Frame.CloseStatusCode"/> that contains a status code indicating a reason for closure.
        /// </param>
        public void Close(CloseStatusCode code)
        {
            Close(code, String.Empty);
        }

        /// <summary>
        /// Closes the connection and releases all associated resources after sends a Close control frame.
        /// </summary>
        /// <param name="code">
        /// A <see cref="ushort"/> that contains a status code indicating a reason for closure.
        /// </param>
        public void Close(ushort code)
        {
            Close(code, String.Empty);
        }

        /// <summary>
        /// Closes the connection and releases all associated resources after sends a Close control frame.
        /// </summary>
        /// <param name="code">
        /// A <see cref="WebSocketSharp.Frame.CloseStatusCode"/> that contains a status code indicating a reason for closure.
        /// </param>
        /// <param name="reason">
        /// A <see cref="string"/> that contains a reason for closure.
        /// </param>
        public void Close(CloseStatusCode code, string reason)
        {
            Close((ushort)code, reason);
        }

        /// <summary>
        /// Closes the connection and releases all associated resources after sends a Close control frame.
        /// </summary>
        /// <param name="code">
        /// A <see cref="ushort"/> that contains a status code indicating a reason for closure.
        /// </param>
        /// <param name="reason">
        /// A <see cref="string"/> that contains a reason for closure.
        /// </param>
        public void Close(ushort code, string reason)
        {
            string msg;
            if (!isValidCloseStatusCode(code, out msg))
            {
                onError(msg);
                return;
            }

            close(code, reason);
        }

        /// <summary>
        /// Establishes a connection.
        /// </summary>
        public void Connect()
        {
            if (_readyState == WsState.OPEN)
            {
                Console.WriteLine("WS: Info@Connect: The WebSocket connection has been established already.");
                return;
            }

            try
            {
                // As client
                if (_isClient)
                {
                    createClientStream();
                    doHandshake();
                    return;
                }

                // As server
                acceptHandshake();
            }
            catch (Exception ex)
            {
                onError(ex.Message);
                close(CloseStatusCode.HANDSHAKE_FAILURE, "An exception has occured.");
            }
        }

        /// <summary>
        /// Closes the connection and releases all associated resources after sends a Close control frame.
        /// </summary>
        /// <remarks>
        /// Call <see cref="Dispose"/> when you are finished using the <see cref="WebSocketSharp.WebSocket"/>. The
        /// <see cref="Dispose"/> method leaves the <see cref="WebSocketSharp.WebSocket"/> in an unusable state. After
        /// calling <see cref="Dispose"/>, you must release all references to the <see cref="WebSocketSharp.WebSocket"/> so
        /// the garbage collector can reclaim the memory that the <see cref="WebSocketSharp.WebSocket"/> was occupying.
        /// </remarks>
        public void Dispose()
        {
            Close(CloseStatusCode.AWAY);
        }

        /// <summary>
        /// Sends a Ping frame using the connection.
        /// </summary>
        /// <returns>
        /// <c>true</c> if the WebSocket receives a Pong frame in a time; otherwise, <c>false</c>.
        /// </returns>
        public bool Ping()
        {
            return Ping(String.Empty);
        }

        /// <summary>
        /// Sends a Ping frame with a message using the connection.
        /// </summary>
        /// <param name="message">
        /// A <see cref="string"/> that contains the message to be sent.
        /// </param>
        /// <returns>
        /// <c>true</c> if the WebSocket receives a Pong frame in a time; otherwise, <c>false</c>.
        /// </returns>
        public bool Ping(string message)
        {
            if (message == null)
                message = String.Empty;

            return _isClient
                   ? ping(message, 5 * 1000)
                   : ping(message, 1 * 1000);
        }

        /// <summary>
        /// Sends a text data using the connection.
        /// </summary>
        /// <param name="data">
        /// A <see cref="string"/> that contains the text data to be sent.
        /// </param>
        public void Send(string data)
        {
            if (data == null)
            {
                onError("'data' must not be null.");
                return;
            }

            var buffer = Encoding.UTF8.GetBytes(data);
            send(Opcode.TEXT, buffer);
        }

        /// <summary>
        /// Sends a binary data using the connection.
        /// </summary>
        /// <param name="data">
        /// An array of <see cref="byte"/> that contains the binary data to be sent.
        /// </param>
        public void Send(byte[] data)
        {
            if (data == null)
            {
                onError("'data' must not be null.");
                return;
            }

            send(Opcode.BINARY, data);
        }

        /// <summary>
        /// Sends a binary data using the connection.
        /// </summary>
        /// <param name="file">
        /// A <see cref="FileInfo"/> that contains the binary data to be sent.
        /// </param>
        public void Send(FileInfo file)
        {
            if (file == null)
            {
                onError("'file' must not be null.");
                return;
            }

            using (FileStream fs = file.OpenRead())
            {
                send(Opcode.BINARY, fs);
            }
        }

        /// <summary>
        /// Sends a text data asynchronously using the connection.
        /// </summary>
        /// <param name="data">
        /// A <see cref="string"/> that contains the text data to be sent.
        /// </param>
        /// <param name="completed">
        /// An <see cref="Action"/> delegate that contains the method(s) that is called when an asynchronous operation completes.
        /// </param>
        public void SendAsync(string data, Action completed)
        {
            if (data == null)
            {
                onError("'data' must not be null.");
                return;
            }

            var buffer = Encoding.UTF8.GetBytes(data);
            sendAsync(Opcode.TEXT, buffer, completed);
        }

        /// <summary>
        /// Sends a binary data asynchronously using the connection.
        /// </summary>
        /// <param name="data">
        /// An array of <see cref="byte"/> that contains the binary data to be sent.
        /// </param>
        /// <param name="completed">
        /// An <see cref="Action"/> delegate that contains the method(s) that is called when an asynchronous operation completes.
        /// </param>
        public void SendAsync(byte[] data, Action completed)
        {
            if (data == null)
            {
                onError("'data' must not be null.");
                return;
            }

            sendAsync(Opcode.BINARY, data, completed);
        }

        /// <summary>
        /// Sends a binary data asynchronously using the connection.
        /// </summary>
        /// <param name="file">
        /// A <see cref="FileInfo"/> that contains the binary data to be sent.
        /// </param>
        /// <param name="completed">
        /// An <see cref="Action"/> delegate that contains the method(s) that is called when an asynchronous operation completes.
        /// </param>
        public void SendAsync(FileInfo file, Action completed)
        {
            if (file == null)
            {
                onError("'file' must not be null.");
                return;
            }

            sendAsync(Opcode.BINARY, file.OpenRead(), completed);
        }

        #endregion
    }
}