/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

'use strict';

/* global asyncStorage */
/* global BaseModule */
/* global ERROR_INVALID_SYNC_ACCOUNT */
/* global ERROR_NO_KEY_FETCH_TOKEN */
/* global ERROR_REQUEST_SYNC_REGISTRATION */
/* global ERROR_SYNC_APP_GENERIC */
/* global ERROR_SYNC_APP_KILLED */
/* global ERROR_SYNC_REQUEST */
/* global ERROR_UNVERIFIED_ACCOUNT */
/* global FxAccountsClient */
/* global IACHandler */
/* global LazyLoader */
/* global Service */
/* global SyncErrors */
/* global SyncRecoverableErrors */
/* global Telemetry */
/* global uuid */

/**
 * This module manages the lifecycle of Firefox Sync on Firefox OS.
 * It connects the Settings application where the Firefox Sync UI is presented
 * to the user with the Sync app that is responsible of doing the actual
 * synchronization of the user's data.
 *
 * SyncManager reacts to changes done on the Settings Sync UI that triggers
 * IAC requests or Settings API changes and translates these changes into
 * actions. It makes use of the SyncStateMachine to control that these actions
 * are possible on the current situation of Sync and communicates with the
 * Sync application via IAC API messages when needed.
 *
 * The IAC based API that is exposed to the Settings app (or any other
 * future consumer that requires to manage Sync) expects IAC messages with
 * a single property 'name' that can have any of the following values:
 *    'enable': requests to enable Sync.
 *    'disable': requests to disable Sync.
 *    'sync': requests a sync on demand. Although we have scheduled
 *            synchronizations, we allow on demand sync requests.
 *    'getInfo': gets the current information about the state of Sync
 *               including the state (enabled, disabled, etc.), the
 *               last time a successful sync happened and the last error
 *               if there's any.
 *
 * It also triggers one message through the same IAC API with name
 * 'onsyncchange' when something (state, error, lastSync) changes on Sync.
 *
 * SyncManager also communicates with the Sync app via IAC. Every time a
 * synchronization is required (either because the requestSync timer fires or
 * because the user requested a sync on demand), we wake the Sync app up and
 * give it the required information to perform the synchronization that
 * includes the URL of the Syncto server, a valid FxA assertion and its
 * associated encryption keys and the list of collections to be synchronized.
 */

(function(exports) {
  const FXA_EVENT = 'mozFxAccountsUnsolChromeEvent';

  const SYNC_TASK = 'gaia::system::firefoxsync';
  const SYNC_REQUEST_IAC_KEYWORD = 'gaia::sync::request';
  const SYNC_MANAGEMENT_API_IAC_KEYWORD = 'gaia-sync-management';

  const COLLECTIONS = ['history', 'passwords', 'bookmarks'];

  // Keys of asyncStorage persisted data.
  const SYNC_STATE = 'sync.state';
  const SYNC_STATE_ERROR = 'sync.state.error';
  const SYNC_LAST_TIME = 'sync.lastTime';
  const SYNC_USER = 'sync.user';

  var SyncManager = function() {};

  SyncManager.STATES = [];

  SyncManager.SERVICES = [];

  SyncManager.SETTINGS = [
    /** READ ONLY SETTINGS **/

    // The user can choose the collections she wants to sync. These settings
    // indicates the user choice per collection.
    'sync.collections.history.enabled',
    'sync.collections.passwords.enabled',
    'sync.collections.bookmarks.enabled',

    // Setting any of these two settings to true will make the synchronization
    // of the collection readonly. That means that we will only be retrieving
    // data from Firefox Sync and we won't be pushing any of the local
    // modifications to the collections source.
    'sync.collections.history.readonly',
    'sync.collections.passwords.readonly',
    'sync.collections.bookmarks.readonly',

    // Limit the number of records fetched from the server in a single request.
    // Once the sync engine supports pagination, the limit will be the page
    // size.
    'sync.collections.history.limit',
    'sync.collections.passwords.limit',
    'sync.collections.bookmarks.limit',

    'sync.server.url',
    'sync.scheduler.interval',
    'sync.scheduler.wifionly',

    'sync.fxa.audience'
  ];

  SyncManager.EVENTS = [
    /** IAC based sync management API **/
    'iac-' + SYNC_MANAGEMENT_API_IAC_KEYWORD,

    /** Sync State Machine events **/
    'onsyncdisabled',
    'onsyncdisabling',
    'onsyncenabled',
    'onsyncenabling',
    'onsyncerrored',
    'onsyncsyncing',

    /** Sync app lifecycle **/
    'appterminated'
  ];

  SyncManager.SUB_MODULES = [
    'SyncStateMachine'
  ];

  BaseModule.create(SyncManager, {
    name: 'SyncManager',
    DEBUG: false,
    EVENT_PREFIX: 'sync',
    store: new Map(),

    /** BaseModule life cycle **/

    _start: function() {
      return new Promise((resolve, reject) => {
        LazyLoader.load('/shared/js/sync/errors.js', () => {
          navigator.mozSetMessageHandler('request-sync', event => {
            this.debug('Sync request');
            if (event.task != SYNC_TASK) {
              return;
            }
            Service.request('SyncStateMachine:sync');
          });

          this.initStore().then(() => {
            this.debug('Sync.state setting initial value', this.state);
            // SyncStateMachine starts by default with 'disabled', so we can
            // request to enable sync or stay in the disabled state.
            // We need to make sure that we didn't end up in an inconsistent
            // state during the latest run (i.e. error, success, syncing,
            // enabling, disabling).
            switch(this.state) {
              case 'enabled':
              case 'success':
              case 'syncing':
                Service.request('SyncStateMachine:enable').then(resolve);
                break;
              case 'disabling':
              case 'enabling':
                this.updateState('disabled');
                resolve();
                break;
              case 'errored':
                if (this.error == ERROR_UNVERIFIED_ACCOUNT) {
                  // We try to enable Sync. This will check if the account is
                  // verified or not. If it's not verified, we go back to the
                  // errored state, otherwise, the user logs in.
                  Service.request('SyncStateMachine:enable').then(resolve);
                  break;
                }
                this.updateState('disabled');
                resolve();
                break;
              case 'disabled':
                resolve();
                break;
              default:
                console.error('Unexpected sync.state value', this.state);
                reject();
                break;
            }
          });
        });
      });
    },

    _stop: function() {},

    /** Event handlers **/

    // We expose a very simple IAC based API to allow the Settings app to
    // manage Sync.
    //
    // We expect IAC messages to contain a property named 'name' with any
    // of the following values corresponding to the requests that we are
    // able to handle:
    //   - enable
    //   - disable
    //   - sync
    //   - getInfo
    //
    // SyncStateMachine is responsible of checking if the request is valid in
    // the current situation and progressing it accordingly by publishing the
    // corresponding events.
    '_handle_iac-gaia-sync-management': function(event) {
      if (!event || !event.detail) {
        console.error('Wrong IAC Sync event');
        return;
      }

      var request = event.detail;
      switch(request.name) {
        case 'enable':
        case 'disable':
        case 'sync':
          try {
            Service.request('SyncStateMachine:' + request.name).then(() => {
              return LazyLoader.load('/shared/js/sync/telemetry.js');
            }).then(() => {
              Telemetry.logUserAction(request.name);
            }).catch(e => {
              console.error(e);
            });
          } catch(e) {
            console.error(e);
          }
          break;
        case 'getInfo':
          if (!request.id) {
            console.warn('IAC request ignored. Missing id');
            return;
          }
          this.getAccount().then(() => {
            this.managementPortMessage({
              id: request.id,
              state: this.state,
              error: this.error,
              lastSync: this.lastSync,
              user: this.user
            });
          });
          break;
        default:
          console.warn('Unknown IAC Sync request', request.name);
          break;
      }
    },

    /** SyncStateMachine event handlers **/

    _handle_onsyncdisabled: function() {
      this.debug('onsyncdisabled observed');
      this.updateState();
      this.user = null;
      this.lastSync = null;
      this.error = null;
      this.cleanup();
    },

    _handle_onsyncdisabling: function() {
      this.debug('onsyncdisabling observed');
      this.updateState();

      // Go back to default settings, so new users won't inherit old users'
      // preferences.
      this.saveUserSettings().then(() => {
        return this.restoreDefaultSettings();
      }).then(() => {
        Service.request('SyncStateMachine:success');
      });
    },

    _handle_onsyncenabled: function(event) {
      this.debug('onsyncenabled observed');
      this.updateState();

      // If we got to this point with no user, something went wrong, so we
      // need to disable Sync.
      if (!this.user) {
        this.debug('No user');
        Service.request('SyncStateMachine:disable');
        return;
      }

      this.registerSyncRequest().then(() => {
        this.debug('Sync request registered');
        var from = event.detail && event.detail.from;
        // After login in with a new account or rebooting the device,
        // we trigger a sync request.
        if (from === 'enabling') {
          Service.request('SyncStateMachine:sync');
        }
      }).catch(error => {
        console.error('Could not register sync request', error);
        Service.request('SyncStateMachine:error',
                        ERROR_REQUEST_SYNC_REGISTRATION);
      });
    },

    _handle_onsyncenabling: function() {
      this.debug('onsyncenabling observed');
      this.updateState();

     // Because we need to bind this to the event handler, we need to save
      // a reference to it so we can properly remove it later.
      this.fxaEventHandler = this._handle_fxaEvent.bind(this);
      window.addEventListener(FXA_EVENT, this.fxaEventHandler);

      // We need to verify that we have everything that we need to start
      // synchronizing data. This is: a valid FxA, the ability to obtain
      // a valid assertion and encryption keys and the remote crypto/keys
      // record.
      var args = [];
      this.updateStateDeferred.then(() => {
        return this.getAssertion();
      }).then(assertion =>{
        args.push(assertion);
        return this.getKeys();
      }).then(keys => {
        args.push(keys);
        return this.getAccount();
      }).then(() => {
        // We request a sync without any collection. This should fetch the
        // crypto/keys object. If it is available, we will successfully
        // continue the enabling process. If it is not available, that probably
        // means that this FxA has never been used before with Sync.
        // In that case, until we are able to create new Sync user, we need
        // to disable Sync and let the user know about this situation.
        return this.trySync.apply(this, args);
      }).then(() => {
        // We save default settings so we can revert user changes to the
        // default values when the user logs out from Sync. So new users don't
        // inherit old users' preferences.
        return this.saveDefaultSettings();
      }).then(() => {
        return this.restoreUserSettings();
      }).then(() => {
        Service.request('SyncStateMachine:success');
      }).catch(error => {
        // XXX Bug 1200284 - Normalize all Firefox Accounts error reporting.
        error = error.message || error.name || error.error || error;
        console.error('Could not enable sync', error);

        if (error == 'UNVERIFIED_ACCOUNT') {
          this.getAccount().then(() => {
            Service.request('SyncStateMachine:error', ERROR_UNVERIFIED_ACCOUNT);
          });
          return;
        }

        error = SyncErrors[error] || error;

        Service.request('SyncStateMachine:error', error);
      });
    },

    _handle_onsyncerrored: function(event) {
      this.debug('onsyncerrored observed');

      var error = event.detail && Array.isArray(event.detail.args) ?
                  event.detail.args[0] : null;
      if (!error) {
        return;
      }

      this.error = error;

      // We don't update the state until we set the error.
      this.updateState();

      var from = event.detail && event.detail.from;

      // There are some cases where we want to show to the user
      // the enabled state but warn her about the invalid state of her
      // account. So we stay in the errored state.
      if ([ERROR_UNVERIFIED_ACCOUNT].indexOf(error) > -1) {
        return;
      }

      // If the error is recoverable and we are coming from the syncing
      // state, we go back to the enabled state, otherwise, we disable Sync.
      if ((SyncRecoverableErrors.indexOf(error) > -1 && from === 'syncing') ||
          // XXX ERROR_INVALID_SYNC_ACCOUNT is an unrecoverable error, but we
          // temporarily treat it in a different way depending on the device.
          // On TVs, we show a dialog asking the user to go to Desktop or
          // Android to create an account and we move to the disabled state.
          // On phones, we move to the enabled state, but we show a warning to
          // the user about her account being empty.
          error == ERROR_INVALID_SYNC_ACCOUNT) {
        Service.request('SyncStateMachine:enable');
        return;
      }

      // If the current FxA login does not contain the token to fetch sync keys
      // we need to log the user out. Unfortunately the FxA auth server does not
      // allow to obtain this token outside of the initial sign in flow.
      if (error == ERROR_NO_KEY_FETCH_TOKEN) {
        // No need to disable Sync here as we will be doing it as soon as the
        // logout is done.
        FxAccountsClient.logout();
        return;
      }

      this.debug('Unrecoverable error');
      Service.request('SyncStateMachine:disable');
    },

    _handle_onsyncsyncing: function() {
      this.debug('onsyncsyncing observed');
      this.updateState();

      // In case that we are syncing on user demand, we unregister the
      // sync request.
      // It's harmless to unregister an expired request, so it's also ok
      // to do it for a periodic sync.
      this.unregisterSyncRequest();

      if (!navigator.onLine) {
        Service.request('SyncStateMachine:success');
        return;
      }

      var collections = {};
      COLLECTIONS.forEach(name => {
        if (this._settings['sync.collections.' + name + '.enabled']) {
          collections[name] = {
            readonly: this._settings['sync.collections.' + name + '.readonly'],
            limit: this._settings['sync.collections.' + name + '.limit']
          };
        }
      });

      if (!Object.keys(collections).length) {
        Service.request('SyncStateMachine:success');
        return;
      }

      var args = [];
      this.getAssertion().then(assertion => {
        args.push(assertion);
        return this.getKeys();
      }).then(keys => {
        args.push(keys);
        args.push(collections);
        this.doSync.apply(this, args);
      }).catch(error => {
        console.error('Sync error', error);
        Service.request('SyncStateMachine:error', ERROR_SYNC_REQUEST);
      });
    },

    _handle_fxaEvent: function(event) {
      // We don't care about FxA events if we are already disabling.
      if (this.state === 'disabling') {
        return;
      }

      if (!event || !event.detail) {
        console.error('Wrong event');
        return;
      }

      switch (event.detail.eventName) {
        case 'onlogout':
          // Logging out from Firefox Accounts should disable Sync.
          Service.request('SyncStateMachine:disable');
          break;
        case 'onverified':
          // Once the user verified her account, we can continue with the
          // enabling procedure.
          if (this.state == 'errored' &&
              this.error == ERROR_UNVERIFIED_ACCOUNT) {
            this.getAccount().then(() => {
              if (this.user) {
                Service.request('SyncStateMachine:enable');
              }
            });
          }
          break;
      }
    },

    _handle_appterminated(event) {
      // If the Sync app is closed, we need to release the reference to
      // its IAC port, so we can get a new connection on the next sync
      // request. Unfortunately, the IAC API doesn't take care of
      // notifying when a port is dead. So we need to do it manually.
      if (!this._port) {
        return;
      }
      this.isSyncApp(event.detail ? event.detail.origin : null).then(() => {
        this._port = null;
      });
    },

    onportclose() {
      // The synchronizer app can be killed while it's handling a sync
      // request. In that case, we need to record an error and notify
      // the state machine about it. Otherwise we could end up on a
      // permanent 'syncing' state.
      if (this.state !== 'syncing') {
        return;
      }
      this.debug('Synchronizer closed before completing the sync request');
      Service.request('SyncStateMachine:error', ERROR_SYNC_APP_KILLED);
    },

    /** Helpers **/

    initStore: function() {
      var promises = [];
      [SYNC_STATE,
       SYNC_STATE_ERROR,
       SYNC_LAST_TIME,
       SYNC_USER].forEach(key => {
        var promise = new Promise(resolve => {
          asyncStorage.getItem(key, value => {
            this.debug(key + ': ' + value);
            this.store.set(key, value);
            resolve();
          });
        });
        promises.push(promise);
      });
      return Promise.all(promises);
    },

    updateState: function(state) {
      this.state = state || Service.query('SyncStateMachine.state');
    },

    registerSyncRequest: function() {
      return navigator.sync.registrations().then(registrations => {
        var existingReg;
        registrations.some(reg => {
          if (reg.task === SYNC_TASK) {
            return !!(existingReg = reg);
          }
        });

        if (existingReg) {
          this.debug('Sync request already exists');
          return Promise.resolve();
        }

        this.debug('Registering sync request', location.href);

        // XXX We need to default to the settings value (3600 and false)
        // because of
        // Bug 1206004 - BaseModule._settings is not be available during
        //               BaseModule._start
        var minInterval = this.DEBUG ? 120
                          : this._settings['sync.scheduler.interval'] || 3600;
        var wifiOnly = this._settings['sync.scheduler.wifionly'] || false;

        return navigator.sync.register(SYNC_TASK, {
          minInterval: minInterval, // minInterval is in seconds.
          oneShot: true,
          wifiOnly: wifiOnly,
          data: null,
          wakeUpPage: location.href
        });
      });
    },

    unregisterSyncRequest: function() {
      navigator.sync.unregister(SYNC_TASK).catch(e => {
        // A failure unregistering the sync task might be expected
        // depending on the state we are (i.e. enabling). In any case,
        // we show a warning, so a bug can be identified or discarded.
        console.warn('Could not unregister sync task', e,
                     Service.query('SyncStateMachine.state'));
      });
    },

    getKeys: function() {
      return new Promise((resolve, reject) => {
        LazyLoader.load('js/fx_accounts_client.js', () => {
          FxAccountsClient.getKeys(resolve, reject);
        });
      });
    },

    getAssertion: function() {
      return new Promise((resolve, reject) => {
        LazyLoader.load('js/fx_accounts_client.js', () => {
          FxAccountsClient.getAssertion({
            audience: this._settings['sync.fxa.audience']
          }, resolve, reject);
        });
      });
    },

    getAccount: function() {
      return new Promise((resolve, reject) => {
        LazyLoader.load('js/fx_accounts_client.js', () => {
          FxAccountsClient.getAccount(account => {
            this.user = account ? account.email : null;
            resolve(account);
          }, reject);
        });
      });
    },

    managementPortMessage: function(message) {
      var port = IACHandler.getPort(SYNC_MANAGEMENT_API_IAC_KEYWORD, this);
      if (!port) {
        this.debug('No management API consumers');
        // We may not have any consumers yet. So in that case
        // we simply bail out here.
        return;
      }
      port.postMessage(message);
    },

    notifyStateChange: function() {
      this.managementPortMessage({
        name: 'onsyncchange',
        state: this.state,
        error: this.error,
        lastSync: this.lastSync,
        user: this.user
      });
    },

    connect: function() {
      if (this._port) {
        return Promise.resolve(this._port);
      }

      return new Promise((resolve, reject) => {
        navigator.mozApps.getSelf().onsuccess = event => {
          var app = event.target.result;
          app.connect(SYNC_REQUEST_IAC_KEYWORD, {
            // For now we only allow one synchronizer app.
            pageURLs: 'app://sync.gaiamobile.org'
          }).then(ports => {
            if (!ports || !ports.length) {
              return reject();
            }
            this._port = ports[0];
            this._port.onclose = this.onportclose.bind(this);
            resolve(this._port);
          }).catch(error => {
            console.error(error);
            reject(error);
          });
        };
      });
    },

    iacRequest: function(request) {
      return new Promise((resolve, reject) => {
        this.connect().then(port => {
          LazyLoader.load('/shared/js/uuid.js', () => {
            var id = uuid();
            request.id = id;
            port.postMessage(request);
            port.onmessage = event => {
              var message = event.data;
              if (!message || (message.id != id)) {
                return;
              }
              resolve(message);
            };
          });
        });
      });
    },

    doSync: function(assertion, keys, collections) {
      this.debug('Syncing with', JSON.stringify(collections));
      this.iacRequest({
        name: 'sync',
        URL: this._settings['sync.server.url'],
        assertion: assertion,
        keys: keys,
        collections: collections
      }).then(result => {
        if (result.error) {
          var error = result.error;
          error = error.message ? error.message : error;
          console.error('Error while trying to sync', error);

          error = SyncErrors[error] || ERROR_SYNC_APP_GENERIC;

          Service.request('SyncStateMachine:error', error);
          return;
        }

        // If we made a successfull synchronization we are good and so
        // we don't care about past errors anymore.
        this.error = null;

        this.debug('Sync succeded');
        this.lastSync = Date.now();

        Service.request('SyncStateMachine:success');
      });
    },

    trySync: function(assertion, keys) {
      return this.iacRequest({
        name: 'sync',
        URL: this._settings['sync.server.url'],
        assertion: assertion,
        keys: keys,
        collections: {}
      }).then(result => {
        if (result && result.error) {
          console.error('Error trying sync', result.error.message);
          throw result.error.message;
        }
      });
    },

    cancelSync: function() {
      this.iacRequest({
        name: 'cancel'
      });
    },

    cleanup: function() {
      this.unregisterSyncRequest();
      window.removeEventListener(FXA_EVENT, this.fxaEventHandler);
      // If we disabled Sync while a sync request was in progress, we need to
      // cancel the request.
      if (this.state === 'syncing') {
        this.cancelSync();
      }
    },

    isSyncApp: function(origin) {
      if (!origin) {
        return Promise.reject();
      }
      return new Promise((resolve, reject) => {
        navigator.mozApps.getSelf().onsuccess = event => {
          var app = event.target.result;
          app.getConnections().then(connections => {
            connections.forEach(connection => {
              if (connection.keyword != SYNC_REQUEST_IAC_KEYWORD ||
                  connection.subscriber.indexOf(origin) < 0) {
                return;
              }
              resolve();
            });
            reject();
          });
        };
      });
    },

    updateStatePreference: function() {
      // Changing the value of this setting changes the value of
      // the 'services.sync.enabled' preference as well.
      // We don't retrieve the Sync keys unless this pref is set to true.
      const CHROME_EVENT = 'mozPrefChromeEvent';
      return new Promise((resolve, reject) => {
        var onprefchange = event => {
          this.debug('Preference change', event.detail);
          if (event.detail.prefName !== 'services.sync.enabled') {
            return;
          }
          window.removeEventListener(CHROME_EVENT, onprefchange);
          resolve();
        };
        window.addEventListener(CHROME_EVENT, onprefchange);
        navigator.mozSettings.createLock().set({
          'services.sync.enabled': this.state !== 'disabled'
        }).onerror = reject;
      });
    },

    saveSettings(prefix) {
      var saveSetting = setting => {
        return new Promise(resolve => {
          asyncStorage.getItem(prefix + setting, value => {
            if (value !== null) {
              this.debug('Setting value already saved', setting);
              resolve();
              return;
            }
            this.debug('Saving setting', prefix + setting,
                       this._settings[setting]);
            asyncStorage.setItem(prefix + setting, this._settings[setting],
                                 resolve);
          });
        });
      };

      var promises = [];
      SyncManager.SETTINGS.forEach(setting => {
        promises.push(saveSetting(setting));
      });

      return Promise.all(promises);
    },

    saveDefaultSettings() {
      this.debug('Saving default settings');
      return this.saveSettings('');
    },

    saveUserSettings() {
      this.debug('Saving user settings');
      return this.saveSettings(this.user + '.');
    },

    restoreSettings(prefix) {
      var revertSetting = setting => {
        return new Promise((resolve, reject) => {
          asyncStorage.getItem(prefix + setting, value => {
            this.debug('Restoring setting ' + prefix + setting, value);
            if (value === null) {
              resolve();
              return;
            }
            // We need to remove the setting from asyncStorage to allow
            // default setting changes within OTA updates.
            asyncStorage.removeItem(prefix + setting, () => {
              var settingObject = {};
              settingObject[setting] = value;
              var req = navigator.mozSettings.createLock().set(settingObject);
              req.onerror = error => {
                console.error(error);
                reject();
              };
              req.onsuccess = resolve;
            });
          });
        });
      };

      var promises = [];
      SyncManager.SETTINGS.forEach(setting => {
        promises.push(revertSetting(setting));
      });

      return Promise.all(promises);
    },

    restoreDefaultSettings() {
      this.debug('Restoring default settings');
      return this.restoreSettings('');
    },

    restoreUserSettings() {
      this.debug('Restoring user settings');
      return this.restoreSettings(this.user + '.');
    }
  }, {
    state: {
      set: function(state) {
        state = state || Service.query('SyncStateMachine.state');
        this.debug('Setting state', state);
        this.store.set(SYNC_STATE, state);
        this.updateStateDeferred = new Promise(resolve => {
          asyncStorage.setItem(SYNC_STATE, state, () => {
            if (state === 'disabled' || state === 'enabled' ||
                state === 'enabling') {
              this.updateStatePreference().then(() => {
                this.notifyStateChange();
                resolve();
              });
              return;
            }
            this.notifyStateChange();
          });
        });
      },
      get: function() {
        var state = this.store.get(SYNC_STATE);
        return state ? state : 'disabled';
      }
    },

    error: {
      set: function(error) {
        this.store.set(SYNC_STATE_ERROR, error);
        asyncStorage.setItem(SYNC_STATE_ERROR, error);
      },
      get: function() {
        return this.store.get(SYNC_STATE_ERROR);
      }
    },

    lastSync: {
      set: function(now) {
        var lastSync = now;
        this.store.set(SYNC_LAST_TIME, lastSync);
        asyncStorage.setItem(SYNC_LAST_TIME, lastSync);
      },
      get: function() {
        return this.store.get(SYNC_LAST_TIME);
      }
    },

    user: {
      set: function(user) {
        // We need to check if there's a user logged in during the enabled
        // state handler, so we cannot wait for the asyncStorage write.
        this.store.set(SYNC_USER, user);
        asyncStorage.setItem(SYNC_USER, user, () => {}, () => {
          // This should never happen, but if something goes wrong storing the
          // user we delete the user from memory and disable Sync to avoid
          // inconsistent states.
          this.store.delete(SYNC_USER);
          Service.request('SyncStateMachine:disable');
        });
      },
      get: function() {
        return this.store.get(SYNC_USER);
      }
    }
  });

  // Exported only for testing purposes.
  exports.SyncManager = SyncManager;
}(window));