/* -*- Mode: js; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */

/* global NotificationHelper */

define(['require','modules/bluetooth/bluetooth_adapter_manager','modules/bluetooth/bluetooth_context','views/pair_expired_dialog'],function(require) {
  'use strict';

  var AdapterManager = require('modules/bluetooth/bluetooth_adapter_manager');
  var BtContext = require('modules/bluetooth/bluetooth_context');
  var PairExpiredDialog = require('views/pair_expired_dialog');

  var _debug = false;
  var debug = function() {};
  if (_debug) {
    debug = function btam_debug(msg) {
      console.log('--> [PairManager]: ' + msg);
    };
  }

  /*
   * PairManager is responsible for:
   *   1. Handling system message 'bluetooth-pairing-request' while there is an
   *      incoming/outgoing pairing request.
   *   2. Handling dom event from BluetoothPairingListener while there is an
   *      incoming/outgoing pairing request.
   *   3. Handling dom event 'ondeviceunpaired' while some remote devices
   *      request for canceling an overdue pairing request. The reason could be
   *      authentication fails, remote device down, and internal error happens.
   */
  var PairManager = {
    /**
     * Default adapter of Bluetooth.
     *
     * @access private
     * @memberOf PairManger
     * @type {Object} BluetoothAdapter
     */
    _defaultAdapter: null,
    /**
     * Indicate if the pair request is expired
     * @type {Boolean}
     */
    _isExpired: false,

    init: function() {
      // Observe 'defaultAdapter' property for reaching default adapter.
      AdapterManager.observe('defaultAdapter',
        this._onDefaultAdapterChanged.bind(this));
      this._onDefaultAdapterChanged(AdapterManager.defaultAdapter);

      // Watch pairing events.
      this._watchOndisplaypasskeyreq();
      this._watchOnenterpincodereq();
      this._watchOnpairingconfirmationreq();
      this._watchOnpairingconsentreq();
      this._watchOnpairingaborted();

      navigator.mozSetMessageHandler('bluetooth-pairing-request',
        this._onRequestPairingFromSystemMessage.bind(this)
      );

      // Observe screen lockscreen locked/unlocked state for show pending
      // pairing request immediately.
      navigator.mozSettings.addObserver('lockscreen.locked',
        function gotScreenLockedChanged(event) {
          this.showPendingPairing(event.settingValue);
      }.bind(this));

      // Observe Bluetooth 'enabled' property from hardware side.
      // Then, close pairing dialog immediately.
      BtContext.observe('enabled', (enabled) => {
        if (!enabled) {
          this.onBluetoothDisabled();
        }
      });
    },

    /**
     * 'defaultAdapter' change event handler from adapter manager for
     * updating it immediately.
     *
     * @access private
     * @memberOf PairManager
     * @param {Object} BluetoothAdapter newAdapter
     */
    _onDefaultAdapterChanged: function(newAdapter) {
      // save default adapter
      this._defaultAdapter = newAdapter;
    },

    /**
     * Watch 'ondisplaypasskeyreq' dom event for pairing.
     * A handler to trigger when a remote bluetooth device requests to display
     * passkey on the screen during pairing process.
     *
     * @access private
     * @memberOf PairManager
     */
    _watchOndisplaypasskeyreq: function() {
      if (!this._defaultAdapter || !this._defaultAdapter.pairingReqs) {
        debug('_watchOndisplaypasskeyreq() no adapter or pairingReqs');
        return;
      }

      this._defaultAdapter.pairingReqs.addEventListener('displaypasskeyreq',
        (evt) => {
        debug('_watchOndisplaypasskeyreq()');
        this._handlePairingRequest({
          method: 'displaypasskey',
          evt: evt
        });
      });
    },

    /**
     * Watch 'onenterpincodereq' dom event for pairing.
     * A handler to trigger when a remote bluetooth device requests user enter
     * PIN code during pairing process.
     *
     * @access private
     * @memberOf PairManager
     */
    _watchOnenterpincodereq: function() {
      if (!this._defaultAdapter || !this._defaultAdapter.pairingReqs) {
        debug('_watchOnenterpincodereq() no adapter or pairingReqs');
        return;
      }

      this._defaultAdapter.pairingReqs.addEventListener('enterpincodereq',
        (evt) => {
        debug('_watchOnenterpincodereq()');
        this._handlePairingRequest({
          method: 'enterpincode',
          evt: evt
        });
      });
    },

    /**
     * Watch 'onpairingconfirmationreq' dom event for pairing.
     * A handler to trigger when a remote bluetooth device requests user
     * confirm passkey during pairing process. Applications may prompt passkey
     * to user for confirmation, or confirm the passkey for user proactively.
     *
     * @access private
     * @memberOf PairManager
     */
    _watchOnpairingconfirmationreq: function() {
      if (!this._defaultAdapter || !this._defaultAdapter.pairingReqs) {
        debug('_watchOnpairingconfirmationreq() no adapter or pairingReqs');
        return;
      }

      this._defaultAdapter.pairingReqs.addEventListener(
        'pairingconfirmationreq', (evt) => {
        debug('_watchOnpairingconfirmationreq: evt = ' + JSON.stringify(evt));
        this._handlePairingRequest({
          method: 'confirmation',
          evt: evt
        });
      });
    },

    /**
     * Watch 'onpairingconsentreq' dom event for pairing.
     * A handler to trigger when a remote bluetooth device requests user
     * confirm pairing during pairing process. Applications may prompt user
     * for confirmation or confirm for user proactively.
     *
     * @access private
     * @memberOf PairManager
     */
    _watchOnpairingconsentreq: function() {
      if (!this._defaultAdapter || !this._defaultAdapter.pairingReqs) {
        debug('_watchOnpairingconsentreq() no adapter or pairingReqs');
        return;
      }

      this._defaultAdapter.pairingReqs.addEventListener('pairingconsentreq',
        (evt) => {
        debug('_watchOnpairingconsentreq: evt = ' + JSON.stringify(evt));
        this._handlePairingRequest({
          method: 'consent',
          evt: evt
        });
      });
    },

    /**
     * Watch 'onpairingaborted' dom event for pairing aborted.
     * A handler to trigger when pairing fails due to one of
     * following conditions:
     * - authentication fails
     * - remote device down (bluetooth ACL becomes disconnected)
     * - internal error happens
     *
     * @access private
     * @memberOf PairManager
     */
    _watchOnpairingaborted: function() {
      if (!this._defaultAdapter) {
        return;
      }

      this._defaultAdapter.addEventListener('pairingaborted',
        this._onPairingAborted.bind(this));
    },

    /**
     * A handler to handle 'onpairingaborted' event while it's coming.
     *
     * @access private
     * @memberOf PairManager
     */
    _onPairingAborted: function(evt) {
      debug('_onPairingAborted(): evt = ' + JSON.stringify(evt));
      // if the attention screen still open, close it
      if (this.childWindow) {
        this.childWindow.Pairview.closeInput();
        this.childWindow.close();
      }

      // If "onpairingaborted" event is coming, and there is a pending pairing
      // request, we have reset the object. Because the callback is useless
      // since the older pairing request is expired.
      // The moment is fit to notify user that the later pairing request
      // is timeout or canceled. According to user story, do nothing here.
      // Clear up the pending pairing request only.
      if (this.pendingPairing) {
        this.pendingPairing = null;
      }

      // Close pairing expired dialog if it is showing.
      if (PairExpiredDialog.isVisible) {
        PairExpiredDialog.close();
        // Have to close Bluetooth app after the dialog is closed.
        window.close();
      }
    },

    /**
     * Receive the system message event for launch Bluetooth app here.
     *
     * @access private
     * @memberOf PairManager
     */
    _onRequestPairingFromSystemMessage: function() {
      debug('onRequestPairingFromSystemMessage():');
    },

    /**
     * It is used to handle each pairing request from different pairing methods.
     *
     * @memberOf PairManager
     * @access private
     * @param {Object} pairingInfo
     * @param {Object} pairingInfo.method - method of this pairing request
     * @param {Object} pairingInfo.evt - DOM evt of this pairing request
     */
    _handlePairingRequest: function(pairingInfo) {
      debug('_onRequestPairing():' +
            ' pairingInfo.method = ' + pairingInfo.method +
            ' pairingInfo.evt = ' + pairingInfo.evt);

      var req = navigator.mozSettings.createLock().get('lockscreen.locked');
      req.onsuccess = () => {
        if (req.result['lockscreen.locked']) {
          // notify user that we are receiving pairing request
          this.fireNotification(pairingInfo);
        } else {
          // We have clear up pending one before show the new pairing requst.
          // Becasue the pending pairing request is no longer usefull.
          this.cleanPendingPairing();

          // show pair view directly while lock screen is unlocked
          this.showPairview(pairingInfo);
        }
      };
      req.onerror = () => {
        // We have clear up pending one before show the new pairing requst.
        // Becasue the pending pairing request is no longer usefull.
        this.cleanPendingPairing();

        // fallback to default value 'unlocked'
        this.showPairview(pairingInfo);
      };
    },

    fireNotification: function(pairingInfo) {
      // Once we received a pairing request in screen locked mode,
      // overwrite the object with the latest pairing request. Because the
      // older pairing request might be timeout and useless now.
      this.pendingPairing = {
        showPairviewCallback: this.showPairview.bind(this, pairingInfo)
      };
      // Prepare notification toast.
      var titleL10n = 'bluetooth-pairing-request-now-title';
      var bodyL10n = pairingInfo.evt.deviceName ?
        { raw: pairingInfo.evt.deviceName } :
        'unnamed-device';
      var iconUrl =
        'app://bluetooth.gaiamobile.org/style/images/icon_bluetooth.png';
      // We always use tag "pairing-request" to manage these notifications.
      var notificationId = 'pairing-request';
      return NotificationHelper.send(titleL10n, {
        bodyL10n: bodyL10n,
        icon: iconUrl,
        tag: notificationId,
        closeOnClick: false
      }).then(notification => {
        // set onclick handler for the notification
        notification.onclick =
          this.pairingRequestExpiredNotificationHandler.bind(this,
                                                             notification);
      });
    },

    // According to user story, it won't notify user again
    // while the pending pairing request is just timeout or canceled.
    // So we have to set onclick handler in this moment.
    // The handler will pop out a pairing request expired prompt only.
    pairingRequestExpiredNotificationHandler: function(notification) {
      var req = navigator.mozSettings.createLock().get('lockscreen.locked');
      req.onsuccess = () => {
        // Avoid to do nothting while the notification toast is showing
        // and a user is able to trigger onclick event. Make sure screen
        // is unlocked, then show the prompt in bluetooth app.
        if (!req.result['lockscreen.locked']) {
          // Clean the pairing request notficiation which is expired.
          notification.close();

          navigator.mozApps.getSelf().onsuccess = (evt) => {
            var app = evt.target.result;

            // launch bluetooth app to foreground for showing the prompt
            if (PairExpiredDialog.isVisible) {
              app.launch();
            }

            // show an alert with the overdue message
            if (!PairExpiredDialog.isVisible && this._isExpired) {
              debug('show expired dialog');
              PairExpiredDialog.showConfirm(function() {
                // Have to close Bluetooth app after the dialog is closed.
                window.close();
              });
            }
          };
        }
      };
    },

    // If there is a pending pairing request while a user just unlocks screen,
    // we will show pair view immediately. Then, we clear up the notification.
    // If pendingPairing object is not exist, it means pair request is expired.
    showPendingPairing: function(screenLocked) {
      debug('showPendingPairing when screenLocked:' + screenLocked);
      if (!screenLocked) {
        if (this.pendingPairing) {
          this._isExpired = false;
          // show pair view from the callback function
          if (this.pendingPairing.showPairviewCallback) {
            this.pendingPairing.showPairviewCallback();
          }

          this.cleanPendingPairing();
        } else {
          this._isExpired = true;
        }
      }
    },

    cleanPendingPairing: function() {
      debug('cleanPendingPairing(): has pendingPairing = ' +
                 (this.pendingPairing));

      // Clear up the pending pairing request
      if (this.pendingPairing) {
        this.pendingPairing = null;
      }

      // Clear up the pairing request from notification.
      this.cleanNotifications();
    },

    // Clean all notifications which are fired with tag 'pairing-request'.
    cleanNotifications: function() {
      Notification.get().then(function(notifications) {
        if (notifications) {
          notifications.forEach(function(notification) {
            // Compare tags, as the tag is based on the "pairing-request" and
            // we only have one notification for the request. Plus, there
            // is no "id" field on the notification.
            if (notification.tag === 'pairing-request' &&
                notification.close) {
                notification.close();
            }
          });
        }
      });
    },

    showPairview: function(pairingInfo) {
      debug('showPairview(): pairingInfo = ' + pairingInfo);
      var protocol = window.location.protocol;
      var host = window.location.host;
      this.childWindow = window.open(protocol + '//' + host + '/onpair.html',
                  'pair_screen', 'attention');
      this.childWindow.onload = () => {
        this.childWindow.Pairview.init(pairingInfo.method, pairingInfo.evt);
      };
    },

    onBluetoothDisabled: function() {
      debug('onBluetoothDisabled():');

      // if the attention screen still open, close it
      if (this.childWindow) {
        this.childWindow.Pairview.closeInput();
        this.childWindow.close();
      }

      // Since Bluetooth is off, close itself.
      window.close();
    }
  };

  return PairManager;
});