// .. MIT License:
//
//  Copyright (c) 2010-2012, Joe Walnes
//
//  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.
//
/*
 * ***************************************************
 * |docname| - a Websocket with an automatic reconnect
 * ***************************************************
 * From https://github.com/joewalnes/reconnecting-websocket/.
 *
 * This behaves like a WebSocket in every way, except if it fails to connect,
 * or it gets disconnected, it will repeatedly poll until it successfully connects
 * again.
 *
 * It is API compatible, so when you have::
 *
 *   ws = new WebSocket('ws://....');
 *
 * you can replace with:
 *
 *   ws = new ReconnectingWebSocket('ws://....');
 *
 * The event stream will typically look like::
 *
 *  onconnecting
 *  onopen
 *  onmessage
 *  onmessage
 *  onclose // lost connection
 *  onconnecting
 *  onopen  // sometime later...
 *  onmessage
 *  onmessage
 *  etc...
 *
 * It is API compatible with the standard WebSocket API, apart from the following members:
 *
 * - ``bufferedAmount``
 * - ``extensions``
 * - ``binaryType``
 *
 * Latest version: https://github.com/joewalnes/reconnecting-websocket/
 *
 * :author: Joe Walnes
 *
 * Syntax
 * ======
 * ``var socket = new ReconnectingWebSocket(url, protocols, options);``
 *
 * Parameters
 * ==========
 * :url: The url you are connecting to.
 * :protocols: Optional string or array of protocols.
 * :options: See below
 *
 * Options
 * =======
 * Options can either be passed upon instantiation or set after instantiation:
 *
 * :code:`var socket = new ReconnectingWebSocket(url, null, { debug: true, reconnectInterval: 4000 });`
 *
 * or::
 *
 *  var socket = new ReconnectingWebSocket(url);
 *  socket.debug = true;
 *  socket.reconnectInterval = 4000;
 *
 * :debug:
 *  Whether this instance should log debug messages. Accepts true or false. Default: false.
 *
 * :automaticOpen:
 *  Whether or not the websocket should attempt to connect immediately upon instantiation. The socket can be manually opened or closed at any time using ``ws.open()`` and ``ws.close()``.
 *
 * :reconnectInterval:
 *  The number of milliseconds to delay before attempting to reconnect. Accepts integer. Default: 1000.
 *
 * :maxReconnectInterval:
 *  The maximum number of milliseconds to delay a reconnection attempt. Accepts integer. Default: 30000.
 *
 * :reconnectDecay:
 *  The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. Accepts integer or float. Default: 1.5.
 *
 * :timeoutInterval:
 *  The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. Accepts integer. Default: 2000.
 */
(function (global, factory) {
  if (typeof define === "function" && define.amd) {
    define([], factory);
  } else if (typeof module !== "undefined" && module.exports) {
    module.exports = factory();
  } else {
    global.ReconnectingWebSocket = factory();
  }
})(this, function () {
  if (!("WebSocket" in window)) {
    return;
  }

  function ReconnectingWebSocket(url, protocols, options) {
    // Default settings
    var settings = {
      /** Whether this instance should log debug messages. */
      debug: false,

      /** Whether or not the websocket should attempt to connect immediately upon instantiation. */
      automaticOpen: true,

      /** The number of milliseconds to delay before attempting to reconnect. */
      reconnectInterval: 1000,
      /** The maximum number of milliseconds to delay a reconnection attempt. */
      maxReconnectInterval: 30000,
      /** The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. */
      reconnectDecay: 1.5,

      /** The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. */
      timeoutInterval: 2000,

      /** The maximum number of reconnection attempts to make. Unlimited if null. */
      maxReconnectAttempts: null,

      /** The binary type, possible values 'blob' or 'arraybuffer', default 'blob'. */
      binaryType: "blob",
    };
    if (!options) {
      options = {};
    }

    // Overwrite and define settings with options if they exist.
    for (var key in settings) {
      if (typeof options[key] !== "undefined") {
        this[key] = options[key];
      } else {
        this[key] = settings[key];
      }
    }

    // These should be treated as read-only properties

    /** The URL as resolved by the constructor. This is always an absolute URL. Read only. */
    this.url = url;

    /** The number of attempted reconnects since starting, or the last successful connection. Read only. */
    this.reconnectAttempts = 0;

    /**
     * The current state of the connection.
     * Can be one of: WebSocket.CONNECTING, WebSocket.OPEN, WebSocket.CLOSING, WebSocket.CLOSED
     * Read only.
     */
    this.readyState = WebSocket.CONNECTING;

    /**
     * A string indicating the name of the sub-protocol the server selected; this will be one of
     * the strings specified in the protocols parameter when creating the WebSocket object.
     * Read only.
     */
    this.protocol = null;

    // Private state variables

    var self = this;
    var ws;
    var forcedClose = false;
    var timedOut = false;
    var eventTarget = document.createElement("div");

    // Wire up "on*" properties as event handlers

    eventTarget.addEventListener("open", function (event) {
      self.onopen(event);
    });
    eventTarget.addEventListener("close", function (event) {
      self.onclose(event);
    });
    eventTarget.addEventListener("connecting", function (event) {
      self.onconnecting(event);
    });
    eventTarget.addEventListener("message", function (event) {
      self.onmessage(event);
    });
    eventTarget.addEventListener("error", function (event) {
      self.onerror(event);
    });

    // Expose the API required by EventTarget

    this.addEventListener = eventTarget.addEventListener.bind(eventTarget);
    this.removeEventListener =
      eventTarget.removeEventListener.bind(eventTarget);
    this.dispatchEvent = eventTarget.dispatchEvent.bind(eventTarget);

    /**
     * This function generates an event that is compatible with standard
     * compliant browsers and IE9 - IE11
     *
     * This will prevent the error:
     * Object doesn't support this action
     *
     * http://stackoverflow.com/questions/19345392/why-arent-my-parameters-getting-passed-through-to-a-dispatched-event/19345563#19345563
     * @param s String The name that the event should use
     * @param args Object an optional object that the event will use
     */
    function generateEvent(s, args) {
      var evt = document.createEvent("CustomEvent");
      evt.initCustomEvent(s, false, false, args);
      return evt;
    }

    this.open = function (reconnectAttempt) {
      ws = new WebSocket(self.url, protocols || []);
      ws.binaryType = this.binaryType;

      if (reconnectAttempt) {
        if (
          this.maxReconnectAttempts &&
          this.reconnectAttempts > this.maxReconnectAttempts
        ) {
          return;
        }
      } else {
        eventTarget.dispatchEvent(generateEvent("connecting"));
        this.reconnectAttempts = 0;
      }

      if (self.debug || ReconnectingWebSocket.debugAll) {
        console.debug("ReconnectingWebSocket", "attempt-connect", self.url);
      }

      var localWs = ws;
      var timeout = setTimeout(function () {
        if (self.debug || ReconnectingWebSocket.debugAll) {
          console.debug(
            "ReconnectingWebSocket",
            "connection-timeout",
            self.url
          );
        }
        timedOut = true;
        localWs.close();
        timedOut = false;
      }, self.timeoutInterval);

      ws.onopen = function (event) {
        clearTimeout(timeout);
        if (self.debug || ReconnectingWebSocket.debugAll) {
          console.debug("ReconnectingWebSocket", "onopen", self.url);
        }
        self.protocol = ws.protocol;
        self.readyState = WebSocket.OPEN;
        self.reconnectAttempts = 0;
        var e = generateEvent("open");
        e.isReconnect = reconnectAttempt;
        reconnectAttempt = false;
        eventTarget.dispatchEvent(e);
      };

      ws.onclose = function (event) {
        clearTimeout(timeout);
        ws = null;
        if (forcedClose) {
          self.readyState = WebSocket.CLOSED;
          eventTarget.dispatchEvent(generateEvent("close"));
        } else {
          self.readyState = WebSocket.CONNECTING;
          var e = generateEvent("connecting");
          e.code = event.code;
          e.reason = event.reason;
          e.wasClean = event.wasClean;
          eventTarget.dispatchEvent(e);
          if (!reconnectAttempt && !timedOut) {
            if (self.debug || ReconnectingWebSocket.debugAll) {
              console.debug("ReconnectingWebSocket", "onclose", self.url);
            }
            eventTarget.dispatchEvent(generateEvent("close"));
          }

          var timeout =
            self.reconnectInterval *
            Math.pow(self.reconnectDecay, self.reconnectAttempts);
          setTimeout(
            function () {
              self.reconnectAttempts++;
              self.open(true);
            },
            timeout > self.maxReconnectInterval
              ? self.maxReconnectInterval
              : timeout
          );
        }
      };
      ws.onmessage = function (event) {
        if (self.debug || ReconnectingWebSocket.debugAll) {
          console.debug(
            "ReconnectingWebSocket",
            "onmessage",
            self.url,
            event.data
          );
        }
        var e = generateEvent("message");
        e.data = event.data;
        eventTarget.dispatchEvent(e);
      };
      ws.onerror = function (event) {
        if (self.debug || ReconnectingWebSocket.debugAll) {
          console.debug("ReconnectingWebSocket", "onerror", self.url, event);
        }
        eventTarget.dispatchEvent(generateEvent("error"));
      };
    };

    // Whether or not to create a websocket upon instantiation
    if (this.automaticOpen == true) {
      this.open(false);
    }

    /**
     * Transmits data to the server over the WebSocket connection.
     *
     * @param data a text string, ArrayBuffer or Blob to send to the server.
     */
    this.send = function (data) {
      if (ws) {
        if (self.debug || ReconnectingWebSocket.debugAll) {
          console.debug("ReconnectingWebSocket", "send", self.url, data);
        }
        return ws.send(data);
      } else {
        throw "INVALID_STATE_ERR : Pausing to reconnect websocket";
      }
    };

    /**
     * Closes the WebSocket connection or connection attempt, if any.
     * If the connection is already CLOSED, this method does nothing.
     */
    this.close = function (code, reason) {
      // Default CLOSE_NORMAL code
      if (typeof code == "undefined") {
        code = 1000;
      }
      forcedClose = true;
      if (ws) {
        ws.close(code, reason);
      }
    };

    /**
     * Additional public API method to refresh the connection if still open (close, re-open).
     * For example, if the app suspects bad data / missed heart beats, it can try to refresh.
     */
    this.refresh = function () {
      if (ws) {
        ws.close();
      }
    };
  }

  /**
   * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
   * this indicates that the connection is ready to send and receive data.
   */
  ReconnectingWebSocket.prototype.onopen = function (event) {};
  /** An event listener to be called when the WebSocket connection's readyState changes to CLOSED. */
  ReconnectingWebSocket.prototype.onclose = function (event) {};
  /** An event listener to be called when a connection begins being attempted. */
  ReconnectingWebSocket.prototype.onconnecting = function (event) {};
  /** An event listener to be called when a message is received from the server. */
  ReconnectingWebSocket.prototype.onmessage = function (event) {};
  /** An event listener to be called when an error occurs. */
  ReconnectingWebSocket.prototype.onerror = function (event) {};

  /**
   * Whether all instances of ReconnectingWebSocket should log debug messages.
   * Setting this to true is the equivalent of setting all instances of ReconnectingWebSocket.debug to true.
   */
  ReconnectingWebSocket.debugAll = false;

  ReconnectingWebSocket.CONNECTING = WebSocket.CONNECTING;
  ReconnectingWebSocket.OPEN = WebSocket.OPEN;
  ReconnectingWebSocket.CLOSING = WebSocket.CLOSING;
  ReconnectingWebSocket.CLOSED = WebSocket.CLOSED;

  return ReconnectingWebSocket;
});
