// Copyright 2013 The Closure Library Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * @fileoverview Provides an implementation of a transport that can call methods
 * directly on a frame. Useful if you want to use XPC for crossdomain messaging
 * (using another transport), or same domain messaging (using this transport).
 */


goog.provide('goog.net.xpc.DirectTransport');

goog.require('goog.Timer');
goog.require('goog.async.Deferred');
goog.require('goog.events.EventHandler');
goog.require('goog.log');
goog.require('goog.net.xpc');
goog.require('goog.net.xpc.CfgFields');
goog.require('goog.net.xpc.CrossPageChannelRole');
goog.require('goog.net.xpc.Transport');
goog.require('goog.net.xpc.TransportTypes');
goog.require('goog.object');


goog.scope(function() {
var CfgFields = goog.net.xpc.CfgFields;
var CrossPageChannelRole = goog.net.xpc.CrossPageChannelRole;
var Deferred = goog.async.Deferred;
var EventHandler = goog.events.EventHandler;
var Timer = goog.Timer;
var Transport = goog.net.xpc.Transport;



/**
 * A direct window to window method transport.
 *
 * If the windows are in the same security context, this transport calls
 * directly into the other window without using any additional mechanism. This
 * is mainly used in scenarios where you want to optionally use a cross domain
 * transport in cross security context situations, or optionally use a direct
 * transport in same security context situations.
 *
 * Note: Global properties are exported by using this transport. One to
 * communicate with the other window by, currently crosswindowmessaging.channel,
 * and by using goog.getUid on window, currently closure_uid_[0-9]+.
 *
 * @param {!goog.net.xpc.CrossPageChannel} channel The channel this
 *     transport belongs to.
 * @param {goog.dom.DomHelper=} opt_domHelper The dom helper to use for
 *     finding the correct window/document. If omitted, uses the current
 *     document.
 * @constructor
 * @extends {Transport}
 */
goog.net.xpc.DirectTransport = function(channel, opt_domHelper) {
  goog.net.xpc.DirectTransport.base(this, 'constructor', opt_domHelper);

  /**
   * The channel this transport belongs to.
   * @private {!goog.net.xpc.CrossPageChannel}
   */
  this.channel_ = channel;

  /** @private {!EventHandler<!goog.net.xpc.DirectTransport>} */
  this.eventHandler_ = new EventHandler(this);
  this.registerDisposable(this.eventHandler_);

  /**
   * Timer for connection reattempts.
   * @private {!Timer}
   */
  this.maybeAttemptToConnectTimer_ = new Timer(
      DirectTransport.CONNECTION_ATTEMPT_INTERVAL_MS_, this.getWindow());
  this.registerDisposable(this.maybeAttemptToConnectTimer_);

  /**
   * Fires once we've received our SETUP_ACK message.
   * @private {!Deferred}
   */
  this.setupAckReceived_ = new Deferred();

  /**
   * Fires once we've sent our SETUP_ACK message.
   * @private {!Deferred}
   */
  this.setupAckSent_ = new Deferred();

  /**
   * Fires once we're marked connected.
   * @private {!Deferred}
   */
  this.connected_ = new Deferred();

  /**
   * The unique ID of this side of the connection. Used to determine when a peer
   * is reloaded.
   * @private {string}
   */
  this.endpointId_ = goog.net.xpc.getRandomString(10);

  /**
   * The unique ID of the peer. If we get a message from a peer with an ID we
   * don't expect, we reset the connection.
   * @private {?string}
   */
  this.peerEndpointId_ = null;

  /**
   * The map of sending messages.
   * @private {Object}
   */
  this.asyncSendsMap_ = {};

  /**
   * The original channel name.
   * @private {string}
   */
  this.originalChannelName_ = this.channel_.name;

  // We reconfigure the channel name to include the role so that we can
  // communicate in the same window between the different roles on the
  // same channel.
  this.channel_.updateChannelNameAndCatalog(
      DirectTransport.getRoledChannelName_(
          this.channel_.name, this.channel_.getRole()));

  /**
   * Flag indicating if this instance of the transport has been initialized.
   * @private {boolean}
   */
  this.initialized_ = false;

  // We don't want to mark ourselves connected until we have sent whatever
  // message will cause our counterpart in the other frame to also declare
  // itself connected, if there is such a message.  Otherwise we risk a user
  // message being sent in advance of that message, and it being discarded.

  // Two sided handshake:
  // SETUP_ACK has to have been received, and sent.
  this.connected_.awaitDeferred(this.setupAckReceived_);
  this.connected_.awaitDeferred(this.setupAckSent_);

  this.connected_.addCallback(this.notifyConnected_, this);
  this.connected_.callback(true);

  this.eventHandler_.listen(
      this.maybeAttemptToConnectTimer_, Timer.TICK,
      this.maybeAttemptToConnect_);

  goog.log.info(
      goog.net.xpc.logger,
      'DirectTransport created. role=' + this.channel_.getRole());
};
goog.inherits(goog.net.xpc.DirectTransport, Transport);
var DirectTransport = goog.net.xpc.DirectTransport;


/**
 * @private {number}
 * @const
 */
DirectTransport.CONNECTION_ATTEMPT_INTERVAL_MS_ = 100;


/**
 * The delay to notify the xpc of a successful connection. This is used
 * to allow both parties to be connected if one party's connection callback
 * invokes an immediate send.
 * @private {number}
 * @const
 */
DirectTransport.CONNECTION_DELAY_INTERVAL_MS_ = 0;


/**
 * @param {!Window} peerWindow The peer window to check if DirectTranport is
 *     supported on.
 * @return {boolean} Whether this transport is supported.
 */
DirectTransport.isSupported = function(peerWindow) {
  /** @preserveTry */
  try {
    return window.document.domain == peerWindow.document.domain;
  } catch (e) {
    return false;
  }
};


/**
 * Tracks the number of DirectTransport channels that have been
 * initialized but not disposed yet in a map keyed by the UID of the window
 * object.  This allows for multiple windows to be initiallized and listening
 * for messages.
 * @private {!Object<number>}
 */
DirectTransport.activeCount_ = {};


/**
 * Path of global message proxy.
 * @private {string}
 * @const
 */
// TODO(user): Make this configurable using the CfgFields.
DirectTransport.GLOBAL_TRANPORT_PATH_ = 'crosswindowmessaging.channel';


/**
 * The delimiter used for transport service messages.
 * @private {string}
 * @const
 */
DirectTransport.MESSAGE_DELIMITER_ = ',';


/**
 * Initializes this transport. Registers a method for 'message'-events in the
 * global scope.
 * @param {!Window} listenWindow The window to listen to events on.
 * @private
 */
DirectTransport.initialize_ = function(listenWindow) {
  var uid = goog.getUid(listenWindow);
  var value = DirectTransport.activeCount_[uid] || 0;
  if (value == 0) {
    // Set up a handler on the window to proxy messages to class.
    var globalProxy = goog.getObjectByName(
        DirectTransport.GLOBAL_TRANPORT_PATH_, listenWindow);
    if (globalProxy == null) {
      goog.exportSymbol(
          DirectTransport.GLOBAL_TRANPORT_PATH_,
          DirectTransport.messageReceivedHandler_, listenWindow);
    }
  }
  DirectTransport.activeCount_[uid]++;
};


/**
 * @param {string} channelName The channel name.
 * @param {string|number} role The role.
 * @return {string} The formatted channel name including role.
 * @private
 */
DirectTransport.getRoledChannelName_ = function(channelName, role) {
  return channelName + '_' + role;
};


/**
 * @param {!Object} literal The literal unrenamed message.
 * @return {boolean} Whether the message was successfully delivered to a
 *     channel.
 * @private
 */
DirectTransport.messageReceivedHandler_ = function(literal) {
  var msg = DirectTransport.Message_.fromLiteral(literal);

  var channelName = msg.channelName;
  var service = msg.service;
  var payload = msg.payload;

  goog.log.fine(
      goog.net.xpc.logger, 'messageReceived: channel=' + channelName +
          ', service=' + service + ', payload=' + payload);

  // Attempt to deliver message to the channel. Keep in mind that it may not
  // exist for several reasons, including but not limited to:
  //  - a malformed message
  //  - the channel simply has not been created
  //  - channel was created in a different namespace
  //  - message was sent to the wrong window
  //  - channel has become stale (e.g. caching iframes and back clicks)
  var channel = goog.net.xpc.channels[channelName];
  if (channel) {
    channel.xpcDeliver(service, payload);
    return true;
  }

  var transportMessageType = DirectTransport.parseTransportPayload_(payload)[0];

  // Check if there are any stale channel names that can be updated.
  for (var staleChannelName in goog.net.xpc.channels) {
    var staleChannel = goog.net.xpc.channels[staleChannelName];
    if (staleChannel.getRole() == CrossPageChannelRole.INNER &&
        !staleChannel.isConnected() &&
        service == goog.net.xpc.TRANSPORT_SERVICE_ &&
        transportMessageType == goog.net.xpc.SETUP) {
      // Inner peer received SETUP message but channel names did not match.
      // Start using the channel name sent from outer peer. The channel name
      // of the inner peer can easily become out of date, as iframe's and their
      // JS state get cached in many browsers upon page reload or history
      // navigation (particularly Firefox 1.5+).
      staleChannel.updateChannelNameAndCatalog(channelName);
      staleChannel.xpcDeliver(service, payload);
      return true;
    }
  }

  // Failed to find a channel to deliver this message to, so simply ignore it.
  goog.log.info(goog.net.xpc.logger, 'channel name mismatch; message ignored.');
  return false;
};


/**
 * The transport type.
 * @type {number}
 * @override
 */
DirectTransport.prototype.transportType = goog.net.xpc.TransportTypes.DIRECT;


/**
 * Handles transport service messages.
 * @param {string} payload The message content.
 * @override
 */
DirectTransport.prototype.transportServiceHandler = function(payload) {
  var transportParts = DirectTransport.parseTransportPayload_(payload);
  var transportMessageType = transportParts[0];
  var peerEndpointId = transportParts[1];
  switch (transportMessageType) {
    case goog.net.xpc.SETUP_ACK_:
      if (!this.setupAckReceived_.hasFired()) {
        this.setupAckReceived_.callback(true);
      }
      break;
    case goog.net.xpc.SETUP:
      this.sendSetupAckMessage_();
      if ((this.peerEndpointId_ != null) &&
          (this.peerEndpointId_ != peerEndpointId)) {
        // Send a new SETUP message since the peer has been replaced.
        goog.log.info(
            goog.net.xpc.logger,
            'Sending SETUP and changing peer ID to: ' + peerEndpointId);
        this.sendSetupMessage_();
      }
      this.peerEndpointId_ = peerEndpointId;
      break;
  }
};


/**
 * Sends a SETUP transport service message.
 * @private
 */
DirectTransport.prototype.sendSetupMessage_ = function() {
  // Although we could send real objects, since some other transports are
  // limited to strings we also keep this requirement.
  var payload = goog.net.xpc.SETUP;
  payload += DirectTransport.MESSAGE_DELIMITER_;
  payload += this.endpointId_;
  this.send(goog.net.xpc.TRANSPORT_SERVICE_, payload);
};


/**
 * Sends a SETUP_ACK transport service message.
 * @private
 */
DirectTransport.prototype.sendSetupAckMessage_ = function() {
  this.send(goog.net.xpc.TRANSPORT_SERVICE_, goog.net.xpc.SETUP_ACK_);
  if (!this.setupAckSent_.hasFired()) {
    this.setupAckSent_.callback(true);
  }
};


/** @override */
DirectTransport.prototype.connect = function() {
  var win = this.getWindow();
  if (win) {
    DirectTransport.initialize_(win);
    this.initialized_ = true;
    this.maybeAttemptToConnect_();
  } else {
    goog.log.fine(goog.net.xpc.logger, 'connect(): no window to initialize.');
  }
};


/**
 * Connects to other peer. In the case of the outer peer, the setup messages are
 * likely sent before the inner peer is ready to receive them. Therefore, this
 * function will continue trying to send the SETUP message until the inner peer
 * responds. In the case of the inner peer, it will occasionally have its
 * channel name fall out of sync with the outer peer, particularly during
 * soft-reloads and history navigations.
 * @private
 */
DirectTransport.prototype.maybeAttemptToConnect_ = function() {
  var outerRole = this.channel_.getRole() == CrossPageChannelRole.OUTER;
  if (this.channel_.isConnected()) {
    this.maybeAttemptToConnectTimer_.stop();
    return;
  }
  this.maybeAttemptToConnectTimer_.start();
  this.sendSetupMessage_();
};


/**
 * Prepares to send a message.
 * @param {string} service The name of the service the message is to be
 *     delivered to.
 * @param {string} payload The message content.
 * @override
 */
DirectTransport.prototype.send = function(service, payload) {
  if (!this.channel_.getPeerWindowObject()) {
    goog.log.fine(goog.net.xpc.logger, 'send(): window not ready');
    return;
  }
  var channelName = DirectTransport.getRoledChannelName_(
      this.originalChannelName_, this.getPeerRole_());

  var message = new DirectTransport.Message_(channelName, service, payload);

  if (this.channel_.getConfig()[CfgFields.DIRECT_TRANSPORT_SYNC_MODE]) {
    this.executeScheduledSend_(message);
  } else {
    // Note: goog.async.nextTick doesn't support cancelling or disposal so
    // leaving as 0ms timer, though this may have performance implications.
    this.asyncSendsMap_[goog.getUid(message)] =
        Timer.callOnce(goog.bind(this.executeScheduledSend_, this, message), 0);
  }
};


/**
 * Sends the message.
 * @param {!DirectTransport.Message_} message The message to send.
 * @private
 */
DirectTransport.prototype.executeScheduledSend_ = function(message) {
  var messageId = goog.getUid(message);
  if (this.asyncSendsMap_[messageId]) {
    delete this.asyncSendsMap_[messageId];
  }

  /** @preserveTry */
  try {
    var peerProxy = goog.getObjectByName(
        DirectTransport.GLOBAL_TRANPORT_PATH_,
        this.channel_.getPeerWindowObject());
  } catch (error) {
    goog.log.warning(
        goog.net.xpc.logger, 'Can\'t access other window, ignoring.', error);
    return;
  }

  if (goog.isNull(peerProxy)) {
    goog.log.warning(
        goog.net.xpc.logger, 'Peer window had no global function.');
    return;
  }

  /** @preserveTry */
  try {
    peerProxy(message.toLiteral());
    goog.log.info(
        goog.net.xpc.logger, 'send(): channelName=' + message.channelName +
            ' service=' + message.service + ' payload=' + message.payload);
  } catch (error) {
    goog.log.warning(
        goog.net.xpc.logger, 'Error performing call, ignoring.', error);
  }
};


/**
 * @return {goog.net.xpc.CrossPageChannelRole} The role of peer channel (either
 *     inner or outer).
 * @private
 */
DirectTransport.prototype.getPeerRole_ = function() {
  var role = this.channel_.getRole();
  return role == goog.net.xpc.CrossPageChannelRole.OUTER ?
      goog.net.xpc.CrossPageChannelRole.INNER :
      goog.net.xpc.CrossPageChannelRole.OUTER;
};


/**
 * Notifies the channel that this transport is connected.
 * @private
 */
DirectTransport.prototype.notifyConnected_ = function() {
  // Add a delay as the connection callback will break if this transport is
  // synchronous and the callback invokes send() immediately.
  this.channel_.notifyConnected(
      this.channel_.getConfig()[CfgFields.DIRECT_TRANSPORT_SYNC_MODE] ?
          DirectTransport.CONNECTION_DELAY_INTERVAL_MS_ :
          0);
};


/** @override */
DirectTransport.prototype.disposeInternal = function() {
  if (this.initialized_) {
    var listenWindow = this.getWindow();
    var uid = goog.getUid(listenWindow);
    var value = --DirectTransport.activeCount_[uid];
    if (value == 1) {
      goog.exportSymbol(
          DirectTransport.GLOBAL_TRANPORT_PATH_, null, listenWindow);
    }
  }

  if (this.asyncSendsMap_) {
    goog.object.forEach(
        this.asyncSendsMap_, function(timerId) { Timer.clear(timerId); });
    this.asyncSendsMap_ = null;
  }

  // Deferred's aren't disposables.
  if (this.setupAckReceived_) {
    this.setupAckReceived_.cancel();
    delete this.setupAckReceived_;
  }
  if (this.setupAckSent_) {
    this.setupAckSent_.cancel();
    delete this.setupAckSent_;
  }
  if (this.connected_) {
    this.connected_.cancel();
    delete this.connected_;
  }

  DirectTransport.base(this, 'disposeInternal');
};


/**
 * Parses a transport service payload message.
 * @param {string} payload The payload.
 * @return {!Array<?string>} An array with the message type as the first member
 *     and the endpoint id as the second, if one was sent, or null otherwise.
 * @private
 */
DirectTransport.parseTransportPayload_ = function(payload) {
  var transportParts = /** @type {!Array<?string>} */ (
      payload.split(DirectTransport.MESSAGE_DELIMITER_));
  transportParts[1] = transportParts[1] || null;  // Usually endpointId.
  return transportParts;
};



/**
 * Message container that gets passed back and forth between windows.
 * @param {string} channelName The channel name to tranport messages on.
 * @param {string} service The service to send the payload to.
 * @param {string} payload The payload to send.
 * @constructor
 * @struct
 * @private
 */
DirectTransport.Message_ = function(channelName, service, payload) {
  /**
   * The name of the channel.
   * @type {string}
   */
  this.channelName = channelName;

  /**
   * The service on the channel.
   * @type {string}
   */
  this.service = service;

  /**
   * The payload.
   * @type {string}
   */
  this.payload = payload;
};


/**
 * Converts a message to a literal object.
 * @return {!Object} The message as a literal object.
 */
DirectTransport.Message_.prototype.toLiteral = function() {
  return {
    'channelName': this.channelName,
    'service': this.service,
    'payload': this.payload
  };
};


/**
 * Creates a Message_ from a literal object.
 * @param {!Object} literal The literal to convert to Message.
 * @return {!DirectTransport.Message_} The Message.
 */
DirectTransport.Message_.fromLiteral = function(literal) {
  return new DirectTransport.Message_(
      literal['channelName'], literal['service'], literal['payload']);
};

});  // goog.scope
