/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-

 * vim: sw=2 ts=2 sts=2 expandtab filetype=javascript

 * 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/. */

const Cc = Components.classes;

const Ci = Components.interfaces;

const Cr = Components.results;

const Cu = Components.utils;

Cu.import("resource://gre/modules/XPCOMUtils.jsm");

Cu.import("resource://gre/modules/Services.jsm");

Cu.import("resource://gre/modules/PlacesUtils.jsm");

this.EXPORTED_SYMBOLS = [ "PlacesDBUtils" ];

////////////////////////////////////////////////////////////////////////////////

//// Constants

const FINISHED_MAINTENANCE_TOPIC = "places-maintenance-finished";

const BYTES_PER_MEBIBYTE = 1048576;

////////////////////////////////////////////////////////////////////////////////

//// Smart getters

XPCOMUtils.defineLazyGetter(this, "DBConn", function() {

  return PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase).DBConnection;

});

////////////////////////////////////////////////////////////////////////////////

//// PlacesDBUtils

this.PlacesDBUtils = {

  /**

   * Executes a list of maintenance tasks.

   * Once finished it will pass a array log to the callback attached to tasks.

   * FINISHED_MAINTENANCE_TOPIC is notified through observer service on finish.

   *

   * @param aTasks

   *        Tasks object to execute.

   */

  _executeTasks: function PDBU__executeTasks(aTasks)

  {

    if (PlacesDBUtils._isShuttingDown) {

      aTasks.log("- We are shutting down. Will not schedule the tasks.");

      aTasks.clear();

    }

    let task = aTasks.pop();

    if (task) {

      task.call(PlacesDBUtils, aTasks);

    }

    else {

      // All tasks have been completed.

      // Telemetry the time it took for maintenance, if a start time exists.

      if (aTasks._telemetryStart) {

        Services.telemetry.getHistogramById("PLACES_IDLE_MAINTENANCE_TIME_MS")

                          .add(Date.now() - aTasks._telemetryStart);

        aTasks._telemetryStart = 0;

      }

      if (aTasks.callback) {

        let scope = aTasks.scope || Cu.getGlobalForObject(aTasks.callback);

        aTasks.callback.call(scope, aTasks.messages);

      }

      // Notify observers that maintenance finished.

      Services.prefs.setIntPref("places.database.lastMaintenance", parseInt(Date.now() / 1000));

      Services.obs.notifyObservers(null, FINISHED_MAINTENANCE_TOPIC, null);

    }

  },

  _isShuttingDown : false,

  shutdown: function PDBU_shutdown() {

    PlacesDBUtils._isShuttingDown = true;

  },

  /**

   * Executes integrity check and common maintenance tasks.

   *

   * @param [optional] aCallback

   *        Callback to be invoked when done.  The callback will get a array

   *        of log messages.

   * @param [optional] aScope

   *        Scope for the callback.

   */

  maintenanceOnIdle: function PDBU_maintenanceOnIdle(aCallback, aScope)

  {

    let tasks = new Tasks([

      this.checkIntegrity

    , this.checkCoherence

    , this._refreshUI

    ]);

    tasks._telemetryStart = Date.now();

    tasks.callback = aCallback;

    tasks.scope = aScope;

    this._executeTasks(tasks);

  },

  /**

   * Executes integrity check, common and advanced maintenance tasks (like

   * expiration and vacuum).  Will also collect statistics on the database.

   *

   * @param [optional] aCallback

   *        Callback to be invoked when done.  The callback will get a array

   *        of log messages.

   * @param [optional] aScope

   *        Scope for the callback.

   */

  checkAndFixDatabase: function PDBU_checkAndFixDatabase(aCallback, aScope)

  {

    let tasks = new Tasks([

      this.checkIntegrity

    , this.checkCoherence

    , this.expire

    , this.vacuum

    , this.stats

    , this._refreshUI

    ]);

    tasks.callback = aCallback;

    tasks.scope = aScope;

    this._executeTasks(tasks);

  },

  /**

   * Forces a full refresh of Places views.

   *

   * @param [optional] aTasks

   *        Tasks object to execute.

   */

  _refreshUI: function PDBU__refreshUI(aTasks)

  {

    let tasks = new Tasks(aTasks);

    // Send batch update notifications to update the UI.

    PlacesUtils.history.runInBatchMode({

      runBatched: function (aUserData) {}

    }, null);

    PlacesDBUtils._executeTasks(tasks);

  },

  _handleError: function PDBU__handleError(aError)

  {

    Cu.reportError("Async statement execution returned with '" +

                   aError.result + "', '" + aError.message + "'");

  },

  /**

   * Tries to execute a REINDEX on the database.

   *

   * @param [optional] aTasks

   *        Tasks object to execute.

   */

  reindex: function PDBU_reindex(aTasks)

  {

    let tasks = new Tasks(aTasks);

    tasks.log("> Reindex");

    let stmt = DBConn.createAsyncStatement("REINDEX");

    stmt.executeAsync({

      handleError: PlacesDBUtils._handleError,

      handleResult: function () {},

      handleCompletion: function (aReason)

      {

        if (aReason == Ci.mozIStorageStatementCallback.REASON_FINISHED) {

          tasks.log("+ The database has been reindexed");

        }

        else {

          tasks.log("- Unable to reindex database");

        }

        PlacesDBUtils._executeTasks(tasks);

      }

    });

    stmt.finalize();

  },

  /**

   * Checks integrity but does not try to fix the database through a reindex.

   *

   * @param [optional] aTasks

   *        Tasks object to execute.

   */

  _checkIntegritySkipReindex: function PDBU__checkIntegritySkipReindex(aTasks)

    this.checkIntegrity(aTasks, true),

  /**

   * Checks integrity and tries to fix the database through a reindex.

   *

   * @param [optional] aTasks

   *        Tasks object to execute.

   * @param [optional] aSkipdReindex

   *        Whether to try to reindex database or not.

   */

  checkIntegrity: function PDBU_checkIntegrity(aTasks, aSkipReindex)

  {

    let tasks = new Tasks(aTasks);

    tasks.log("> Integrity check");

    // Run a integrity check, but stop at the first error.

    let stmt = DBConn.createAsyncStatement("PRAGMA integrity_check(1)");

    stmt.executeAsync({

      handleError: PlacesDBUtils._handleError,

      _corrupt: false,

      handleResult: function (aResultSet)

      {

        let row = aResultSet.getNextRow();

        this._corrupt = row.getResultByIndex(0) != "ok";

      },

      handleCompletion: function (aReason)

      {

        if (aReason == Ci.mozIStorageStatementCallback.REASON_FINISHED) {

          if (this._corrupt) {

            tasks.log("- The database is corrupt");

            if (aSkipReindex) {

              tasks.log("- Unable to fix corruption, database will be replaced on next startup");

              Services.prefs.setBoolPref("places.database.replaceOnStartup", true);

              tasks.clear();

            }

            else {

              // Try to reindex, this often fixed simple indices corruption.

              // We insert from the top of the queue, they will run inverse.

              tasks.push(PlacesDBUtils._checkIntegritySkipReindex);

              tasks.push(PlacesDBUtils.reindex);

            }

          }

          else {

            tasks.log("+ The database is sane");

          }

        }

        else {

          tasks.log("- Unable to check database status");

          tasks.clear();

        }

        PlacesDBUtils._executeTasks(tasks);

      }

    });

    stmt.finalize();

  },

  /**

   * Checks data coherence and tries to fix most common errors.

   *

   * @param [optional] aTasks

   *        Tasks object to execute.

   */

  checkCoherence: function PDBU_checkCoherence(aTasks)

  {

    let tasks = new Tasks(aTasks);

    tasks.log("> Coherence check");

    let stmts = PlacesDBUtils._getBoundCoherenceStatements();

    DBConn.executeAsync(stmts, stmts.length, {

      handleError: PlacesDBUtils._handleError,

      handleResult: function () {},

      handleCompletion: function (aReason)

      {

        if (aReason == Ci.mozIStorageStatementCallback.REASON_FINISHED) {

          tasks.log("+ The database is coherent");

        }

        else {

          tasks.log("- Unable to check database coherence");

          tasks.clear();

        }

        PlacesDBUtils._executeTasks(tasks);

      }

    });

    stmts.forEach(function (aStmt) aStmt.finalize());

  },

  _getBoundCoherenceStatements: function PDBU__getBoundCoherenceStatements()

  {

    let cleanupStatements = [];

    // MOZ_ANNO_ATTRIBUTES

    // A.1 remove obsolete annotations from moz_annos.

    // The 'weave0' idiom exploits character ordering (0 follows /) to

    // efficiently select all annos with a 'weave/' prefix.

    let deleteObsoleteAnnos = DBConn.createAsyncStatement(

      `DELETE FROM moz_annos

       WHERE anno_attribute_id IN (

         SELECT id FROM moz_anno_attributes

         WHERE name BETWEEN 'weave/' AND 'weave0'

       )`);

    cleanupStatements.push(deleteObsoleteAnnos);

    // A.2 remove obsolete annotations from moz_items_annos.

    let deleteObsoleteItemsAnnos = DBConn.createAsyncStatement(

      `DELETE FROM moz_items_annos

       WHERE anno_attribute_id IN (

         SELECT id FROM moz_anno_attributes

         WHERE name = 'sync/children'

            OR name = 'placesInternal/GUID'

            OR name BETWEEN 'weave/' AND 'weave0'

       )`);

    cleanupStatements.push(deleteObsoleteItemsAnnos);

    // A.3 remove unused attributes.

    let deleteUnusedAnnoAttributes = DBConn.createAsyncStatement(

      `DELETE FROM moz_anno_attributes WHERE id IN (

         SELECT id FROM moz_anno_attributes n

         WHERE NOT EXISTS

             (SELECT id FROM moz_annos WHERE anno_attribute_id = n.id LIMIT 1)

           AND NOT EXISTS

             (SELECT id FROM moz_items_annos WHERE anno_attribute_id = n.id LIMIT 1)

       )`);

    cleanupStatements.push(deleteUnusedAnnoAttributes);

    // MOZ_ANNOS

    // B.1 remove annos with an invalid attribute

    let deleteInvalidAttributeAnnos = DBConn.createAsyncStatement(

      `DELETE FROM moz_annos WHERE id IN (

         SELECT id FROM moz_annos a

         WHERE NOT EXISTS

           (SELECT id FROM moz_anno_attributes

             WHERE id = a.anno_attribute_id LIMIT 1)

       )`);

    cleanupStatements.push(deleteInvalidAttributeAnnos);

    // B.2 remove orphan annos

    let deleteOrphanAnnos = DBConn.createAsyncStatement(

      `DELETE FROM moz_annos WHERE id IN (

         SELECT id FROM moz_annos a

         WHERE NOT EXISTS

           (SELECT id FROM moz_places WHERE id = a.place_id LIMIT 1)

       )`);

    cleanupStatements.push(deleteOrphanAnnos);

    // Bookmarks roots

    // C.1 fix missing Places root

    //     Bug 477739 shows a case where the root could be wrongly removed

    //     due to an endianness issue.  We try to fix broken roots here.

    let selectPlacesRoot = DBConn.createStatement(

      "SELECT id FROM moz_bookmarks WHERE id = :places_root");

    selectPlacesRoot.params["places_root"] = PlacesUtils.placesRootId;

    if (!selectPlacesRoot.executeStep()) {

      // We are missing the root, try to recreate it.

      let createPlacesRoot = DBConn.createAsyncStatement(

        `INSERT INTO moz_bookmarks (id, type, fk, parent, position, title,

                                    guid)

         VALUES (:places_root, 2, NULL, 0, 0, :title, :guid)`);

      createPlacesRoot.params["places_root"] = PlacesUtils.placesRootId;

      createPlacesRoot.params["title"] = "";

      createPlacesRoot.params["guid"] = PlacesUtils.bookmarks.rootGuid;

      cleanupStatements.push(createPlacesRoot);

      // Now ensure that other roots are children of Places root.

      let fixPlacesRootChildren = DBConn.createAsyncStatement(

        `UPDATE moz_bookmarks SET parent = :places_root WHERE guid IN

           ( :menuGuid, :toolbarGuid, :unfiledGuid, :tagsGuid )`);

      fixPlacesRootChildren.params["places_root"] = PlacesUtils.placesRootId;

      fixPlacesRootChildren.params["menuGuid"] = PlacesUtils.bookmarks.menuGuid;

      fixPlacesRootChildren.params["toolbarGuid"] = PlacesUtils.bookmarks.toolbarGuid;

      fixPlacesRootChildren.params["unfiledGuid"] = PlacesUtils.bookmarks.unfiledGuid;

      fixPlacesRootChildren.params["tagsGuid"] = PlacesUtils.bookmarks.tagsGuid;

      cleanupStatements.push(fixPlacesRootChildren);

    }

    selectPlacesRoot.finalize();

    // C.2 fix roots titles

    //     some alpha version has wrong roots title, and this also fixes them if

    //     locale has changed.

    let updateRootTitleSql = `UPDATE moz_bookmarks SET title = :title

                              WHERE id = :root_id AND title <> :title`;

    // root

    let fixPlacesRootTitle = DBConn.createAsyncStatement(updateRootTitleSql);

    fixPlacesRootTitle.params["root_id"] = PlacesUtils.placesRootId;

    fixPlacesRootTitle.params["title"] = "";

    cleanupStatements.push(fixPlacesRootTitle);

    // bookmarks menu

    let fixBookmarksMenuTitle = DBConn.createAsyncStatement(updateRootTitleSql);

    fixBookmarksMenuTitle.params["root_id"] = PlacesUtils.bookmarksMenuFolderId;

    fixBookmarksMenuTitle.params["title"] =

      PlacesUtils.getString("BookmarksMenuFolderTitle");

    cleanupStatements.push(fixBookmarksMenuTitle);

    // bookmarks toolbar

    let fixBookmarksToolbarTitle = DBConn.createAsyncStatement(updateRootTitleSql);

    fixBookmarksToolbarTitle.params["root_id"] = PlacesUtils.toolbarFolderId;