/**
 * @license
 * Copyright 2016 Google Inc.
 *
 * 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.
 */

goog.provide('shaka.offline.DBEngine');

goog.require('goog.asserts');
goog.require('shaka.log');
goog.require('shaka.offline.IStorageEngine');
goog.require('shaka.util.Error');
goog.require('shaka.util.Functional');
goog.require('shaka.util.PublicPromise');



/**
 * This manages all operations on an IndexedDB.  This wraps all operations
 * in Promises.  All Promises will resolve once the transaction has completed.
 * Depending on the browser, this may or may not be after the data is flushed
 * to disk.  https://goo.gl/zMOeJc
 *
 * @struct
 * @constructor
 * @implements {shaka.offline.IStorageEngine}
 */
shaka.offline.DBEngine = function() {
  goog.asserts.assert(
      shaka.offline.DBEngine.isSupported(),
      'DBEngine should not be called when DBEngine is not supported');

  /** @private {IDBDatabase} */
  this.db_ = null;

  /** @private {!Array.<shaka.offline.DBEngine.Operation>} */
  this.operations_ = [];

  /** @private {!Object.<string, number>} */
  this.currentIdMap_ = {};
};


/**
 * @typedef {{
 *   transaction: !IDBTransaction,
 *   promise: !shaka.util.PublicPromise
 * }}
 *
 * @property {!IDBTransaction} transaction
 *   The transaction that this operation is using.
 * @property {!shaka.util.PublicPromise} promise
 *   The promise associated with the operation.
 */
shaka.offline.DBEngine.Operation;


/** @private {string} */
shaka.offline.DBEngine.DB_NAME_ = 'shaka_offline_db';


/** @private @const {number} */
shaka.offline.DBEngine.DB_VERSION_ = 1;


/**
 * Determines if the browsers supports IndexedDB.
 * @return {boolean}
 */
shaka.offline.DBEngine.isSupported = function() {
  return window.indexedDB != null;
};


/**
 * Delete the database.  There must be no open connections to the database.
 * @return {!Promise}
 */
shaka.offline.DBEngine.deleteDatabase = function() {
  if (!window.indexedDB)
    return Promise.resolve();
  var request =
      window.indexedDB.deleteDatabase(shaka.offline.DBEngine.DB_NAME_);

  var p = new shaka.util.PublicPromise();
  request.onsuccess = function(event) {
    goog.asserts.assert(event.newVersion == null, 'Unexpected database update');
    p.resolve();
  };
  request.onerror = shaka.offline.DBEngine.onError_.bind(null, request, p);
  return p;
};


/** @override */
shaka.offline.DBEngine.prototype.initialized = function() {
  return this.db_ != null;
};


/** @override */
shaka.offline.DBEngine.prototype.init = function(storeMap, opt_retryCount) {
  goog.asserts.assert(!this.db_, 'Already initialized');

  return this.createConnection_(storeMap, opt_retryCount).then(function() {
    // For each store, get the next ID and store in the map.
    var stores = Object.keys(storeMap);
    return Promise.all(stores.map(function(store) {
      return this.getNextId_(store).then(function(id) {
        this.currentIdMap_[store] = id;
      }.bind(this));
    }.bind(this)));
  }.bind(this));
};


/** @override */
shaka.offline.DBEngine.prototype.destroy = function() {
  return Promise.all(this.operations_.map(function(op) {
    try {
      // If the transaction is considered finished but has not called the
      // callbacks yet, it will still be in the list and this call will fail.
      // Simply ignore errors.
      op.transaction.abort();
    } catch (e) {}

    var Functional = shaka.util.Functional;
    return op.promise.catch(Functional.noop);
  })).then(function() {
    goog.asserts.assert(this.operations_.length == 0,
                        'All operations should have been closed');
    if (this.db_) {
      this.db_.close();
      this.db_ = null;
    }
  }.bind(this));
};


/** @override */
shaka.offline.DBEngine.prototype.get = function(storeName, key) {
  /** @type {!IDBRequest} */
  var request;
  return this.createTransaction_(storeName, 'readonly', function(store) {
    request = store.get(key);
  }).then(function() { return request.result; });
};


/** @override */
shaka.offline.DBEngine.prototype.forEach = function(storeName, callback) {
  return this.createTransaction_(storeName, 'readonly', function(store) {
    var request = store.openCursor();
    request.onsuccess = function(event) {
      var cursor = event.target.result;
      if (cursor) {
        callback(cursor.value);
        cursor.continue();
      }
    };
  });
};


/** @override */
shaka.offline.DBEngine.prototype.insert = function(storeName, value) {
  return this.createTransaction_(storeName, 'readwrite', function(store) {
    store.put(value);
  });
};


/** @override */
shaka.offline.DBEngine.prototype.remove = function(storeName, key) {
  return this.createTransaction_(storeName, 'readwrite', function(store) {
    store.delete(key);
  });
};


/** @override */
shaka.offline.DBEngine.prototype.removeKeys = function(storeName,
                                                       keys,
                                                       opt_onKeyRemoved) {
  return this.createTransaction_(storeName, 'readwrite', function(store) {
    for (var i = 0; i < keys.length; i++) {
      var request = store.delete(keys[i]);
      request.onsuccess = opt_onKeyRemoved || function(event) { };
    }
  });
};


/** @override */
shaka.offline.DBEngine.prototype.reserveId = function(storeName) {
  goog.asserts.assert(storeName in this.currentIdMap_,
                      'Store name must be passed to init()');
  return this.currentIdMap_[storeName]++;
};


/**
 * Gets the ID to start at.
 *
 * @param {string} storeName
 * @return {!Promise.<number>}
 * @private
 */
shaka.offline.DBEngine.prototype.getNextId_ = function(storeName) {
  var id = 0;
  return this.createTransaction_(storeName, 'readonly', function(store) {
    var request = store.openCursor(null, 'prev');
    request.onsuccess = function(event) {
      var cursor = event.target.result;
      if (cursor) {
        id = cursor.key + 1;
      }
    };
  }).then(function() { return id; });
};


/**
 * Creates a new transaction for the given store name and calls |action| to
 * modify the store. The transaction will resolve or reject the promise
 * returned by this function.
 *
 * @param {string} storeName
 * @param {string} type
 * @param {!function(IDBObjectStore)} action
 *
 * @return {!Promise}
 * @private
 */
shaka.offline.DBEngine.prototype.createTransaction_ = function(storeName,
                                                               type,
                                                               action) {

  goog.asserts.assert(this.db_, 'DBEngine must not be destroyed');
  goog.asserts.assert(type == 'readonly' || type == 'readwrite',
                      'Type must be "readonly" or "readwrite"');

  var op = {
    transaction: this.db_.transaction([storeName], type),
    promise: new shaka.util.PublicPromise()
  };

  op.transaction.oncomplete = (function(event) {
    this.closeOperation_(op);
    op.promise.resolve();
  }.bind(this));

  // We will see an onabort call via:
  //   1. request error -> transaction error -> transaction abort
  //   2. transaction commit fail -> transaction abort
  // As any transaction error will result in an abort, it is better to listen
  // for an abort so that we will catch all failed transaction operations.
  op.transaction.onabort = (function(event) {
    this.closeOperation_(op);
    shaka.offline.DBEngine.onError_(op.transaction, op.promise, event);
  }.bind(this));

  // We need to prevent default on the onerror event or else Firefox will
  // raise an error which will cause a karma failure. This will not stop the
  // onabort callback from firing.
  op.transaction.onerror = (function(event) {
    event.preventDefault();
  }.bind(this));

  var store = op.transaction.objectStore(storeName);
  action(store);

  this.operations_.push(op);

  return op.promise;
};


/**
 * Close an open operation.
 *
 * @param {!shaka.offline.DBEngine.Operation} op
 * @private
 */
shaka.offline.DBEngine.prototype.closeOperation_ = function(op) {
  var i = this.operations_.indexOf(op);
  goog.asserts.assert(i >= 0, 'Operation must be in the list.');
  this.operations_.splice(i, 1);
};


/**
 * Creates a new connection to the database.
 *
 * On IE/Edge, it is possible for the database to not be deleted when the
 * success callback is fired.  This means that when we delete the database and
 * immediately create a new connection, we will connect to the old database.
 * If this happens, we need to close the connection and retry.
 *
 * @see https://goo.gl/hOYJvN
 *
 * @param {!Object.<string, string>} storeMap
 * @param {number=} opt_retryCount
 * @return {!Promise}
 * @private
 */
shaka.offline.DBEngine.prototype.createConnection_ = function(
    storeMap, opt_retryCount) {
  var DBEngine = shaka.offline.DBEngine;

  var indexedDB = window.indexedDB;
  var request = indexedDB.open(DBEngine.DB_NAME_, DBEngine.DB_VERSION_);

  var upgraded = false;
  var createPromise = new shaka.util.PublicPromise();
  request.onupgradeneeded = function(event) {
    upgraded = true;
    var db = event.target.result;
    goog.asserts.assert(event.oldVersion == 0,
                        'Must be upgrading from version 0');
    goog.asserts.assert(db.objectStoreNames.length == 0,
                        'Version 0 database should be empty');
    for (var name in storeMap) {
      db.createObjectStore(name, {keyPath: storeMap[name]});
    }
  };
  request.onsuccess = (function(event) {
    if (opt_retryCount && !upgraded) {
      event.target.result.close();

      shaka.log.info('Didn\'t get an upgrade event... trying again.');
      setTimeout(function() {
        var p = this.createConnection_(storeMap, opt_retryCount - 1);
        p.then(createPromise.resolve, createPromise.reject);
      }.bind(this), 1000);
      return;
    }


    goog.asserts.assert(opt_retryCount == undefined || upgraded,
                        'Should get upgrade event');
    this.db_ = event.target.result;
    createPromise.resolve();
  }.bind(this));
  request.onerror = DBEngine.onError_.bind(null, request, createPromise);

  return createPromise;
};


/**
 * Rejects the given Promise using the error fromt the transaction.
 *
 * @param {!IDBTransaction|!IDBRequest} errorSource
 * @param {!shaka.util.PublicPromise} promise
 * @param {Event} event
 * @private
 */
shaka.offline.DBEngine.onError_ = function(errorSource, promise, event) {

  if (errorSource.error) {
    promise.reject(new shaka.util.Error(
        shaka.util.Error.Severity.CRITICAL,
        shaka.util.Error.Category.STORAGE,
        shaka.util.Error.Code.INDEXED_DB_ERROR, errorSource.error));
  } else {
    promise.reject(new shaka.util.Error(
        shaka.util.Error.Severity.CRITICAL,
        shaka.util.Error.Category.STORAGE,
        shaka.util.Error.Code.OPERATION_ABORTED));
  }

  // Firefox will raise an error which will cause a karma failure.
  event.preventDefault();
};