/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is the Firefox Browser Glue Service.
 *
 * The Initial Developer of the Original Code is
 * Giorgio Maone
 * Portions created by the Initial Developer are Copyright (C) 2005
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Giorgio Maone <g.maone@informaction.com>
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

// Constructor

function BrowserGlue() {
  this._init();
}

BrowserGlue.prototype = {

  mPrefService: null,

  QueryInterface: function nsBG_QI(iid) 
  {
     xpcomCheckInterfaces(iid, kServiceIIds, Components.results.NS_ERROR_NO_INTERFACE);
     return this;
  },

  // nsIObserver implementation 
  observe: function nsBG_observe(subject, topic, data) 
  {
    switch(topic) {
      case "xpcom-shutdown":
        this._dispose();
        break;
      case "profile-change-teardown": 
        this._onProfileShutdown();
        break;
      case "final-ui-startup":
        this._onProfileStartup();
        break;
    }
  },

  // initialization (called on application startup) 
  _init: function nsBG_init() 
  {
    // observer registration
    const osvr = Components.classes['@mozilla.org/observer-service;1']
                           .getService(Components.interfaces.nsIObserverService);
    osvr.addObserver(this, "profile-change-teardown", false);
    osvr.addObserver(this, "xpcom-shutdown", false);
    osvr.addObserver(this, "final-ui-startup", false);
  },

  // cleanup (called on application shutdown)
  _dispose: function nsBG_dispose() 
  {
    // observer removal 
    const osvr = Components.classes['@mozilla.org/observer-service;1']
                           .getService(Components.interfaces.nsIObserverService);
    osvr.removeObserver(this, "profile-change-teardown");
    osvr.removeObserver(this, "xpcom-shutdown");
    osvr.removeObserver(this, "final-ui-startup");
  },

  // profile startup handler (contains profile initialization routines)
  _onProfileStartup: function nsBG_onProfileStartup() 
  {
    if (this.prefService.getBoolPref("browser.shell.checkDefaultBrowser"))
      this.checkDefaultBrowser();

    this.Sanitizer.onStartup();

    // check if we're in safe mode
    var app = Components.classes["@mozilla.org/xre/app-info;1"]
                        .getService(Components.interfaces.nsIXULAppInfo)
                        .QueryInterface(Components.interfaces.nsIXULRuntime);
    if (app.inSafeMode) {
      var ww = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
                         .getService(Components.interfaces.nsIWindowWatcher);
      ww.openWindow(null, "chrome://browser/content/safeMode.xul", 
                    "_blank", "chrome,centerscreen,modal,resizable=no", null);
    }
  },

  // profile shutdown handler (contains profile cleanup routines)
  _onProfileShutdown: function nsBG_onProfileShutdown() 
  {
    // here we enter last survival area, in order to avoid multiple
    // "quit-application" notifications caused by late window closings
    const appStartup = Components.classes['@mozilla.org/toolkit/app-startup;1']
                                 .getService(Components.interfaces.nsIAppStartup);
    try {
      appStartup.enterLastWindowClosingSurvivalArea();

      this.Sanitizer.onShutdown();

    } catch(ex) {
    } finally {
      appStartup.exitLastWindowClosingSurvivalArea();
    }
  },

  // returns the (cached) Sanitizer constructor
  get Sanitizer() 
  {
    if(typeof(Sanitizer) != "function") { // we should dynamically load the script
      Components.classes["@mozilla.org/moz/jssubscript-loader;1"]
                .getService(Components.interfaces.mozIJSSubScriptLoader)
                .loadSubScript("chrome://browser/content/sanitize.js", null);
    }
    return Sanitizer;
  },

  get prefService()
  {
    if (!this.mPrefService) 
      this.mPrefService =
                   Components.classes["@mozilla.org/preferences-service;1"]
                             .getService(Components.interfaces.nsIPrefBranch2);

    return this.mPrefService;
  },

  // ------------------------------
  // public nsIBrowserGlue members
  // ------------------------------

  sanitize: function nsBG_sanitize(aParentWindow) 
  {
    this.Sanitizer.sanitize(aParentWindow);
  },

  checkDefaultBrowser: function nsBG_checkDefaultBrowser(aUserInitiated,
                                                         aParentWindow)
  {
    var shell;
    try {
      shell = Components.classes["@mozilla.org/browser/shell-service;1"]
                        .getService(Components.interfaces.nsIShellService);
    } catch (ex) { }

    if (!shell)
      return;

    const cID     = "@mozilla.org/intl/stringbundle;1";
    const nsISBS  = Components.interfaces.nsIStringBundleService;
    var bundleSvc = Components.classes[cID].getService(nsISBS);

    const brandURL = "chrome://branding/locale/brand.properties";
    var brandBundle = bundleSvc.createBundle(brandURL);
    const shellURL = "chrome://browser/locale/shellservice.properties";
    var shellBundle = bundleSvc.createBundle(shellURL);

    var brandShortName = brandBundle.GetStringFromName("brandShortName");

    var promptTitle = shellBundle.GetStringFromName("setDefaultBrowserTitle");
    var promptMessage =
                 shellBundle.formatStringFromName("setDefaultBrowserMessage",
                                                  [brandShortName], 1);
    var checkboxLabel =
                   shellBundle.formatStringFromName("setDefaultBrowserDontAsk",
                                                    [brandShortName], 1);
    var checkEveryTime = { value: true };

    const nsIPS = Components.interfaces.nsIPromptService;
    var ps = Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
                       .getService(nsIPS);

    var parentWindow = aParentWindow || null;

    if (!shell.isDefaultBrowser()) {

      if (aUserInitiated) {
        // Don't show the checkbox if this dialog is forced
        checkboxLabel = null;
        checkEveryTime = {};
      }

      var rv = ps.confirmEx(parentWindow, promptTitle, promptMessage,
                            (nsIPS.BUTTON_TITLE_YES * nsIPS.BUTTON_POS_0) +
                            (nsIPS.BUTTON_TITLE_NO * nsIPS.BUTTON_POS_1),
                            null, null, null, checkboxLabel, checkEveryTime);

      if (rv == 0)
        shell.setDefaultBrowser(true, false);

      if (!aUserInitiated)
        this.prefService.setBoolPref("browser.shell.checkDefaultBrowser",
                                     checkEveryTime.value);

    } else if (aUserInitiated) {
      promptMessage = shellBundle.formatStringFromName("alreadyDefaultBrowser",
                                                       [brandShortName], 1);
      ps.alert(parentWindow, promptTitle, promptMessage);
    }
  }
}

// XPCOM Scaffolding code

// component defined in this file

const kServiceName = "Firefox Browser Glue Service";
const kServiceId = "{eab9012e-5f74-4cbc-b2b5-a590235513cc}";
const kServiceCtrId = "@mozilla.org/browser/browserglue;1";
const kServiceConstructor = BrowserGlue;

const kServiceCId = Components.ID(kServiceId);

// interfaces implemented by this component
const kServiceIIds = [ 
  Components.interfaces.nsIObserver,
  Components.interfaces.nsISupports,
  Components.interfaces.nsISupportsWeakReference,
  Components.interfaces.nsIBrowserGlue
  ];

// categories which this component is registered in
const kServiceCats = ["app-startup"];

// Factory object
const kServiceFactory = {
  _instance: null,
  createInstance: function (outer, iid) 
  {
    if (outer != null) throw Components.results.NS_ERROR_NO_AGGREGATION;

    xpcomCheckInterfaces(iid, kServiceIIds, 
                          Components.results.NS_ERROR_INVALID_ARG);
    return this._instance == null ?
      this._instance = new kServiceConstructor() : this._instance;
  }
};

function xpcomCheckInterfaces(iid, iids, ex) {
  for (var j = iids.length; j-- >0;) {
    if (iid.equals(iids[j])) return true;
  }
  throw ex;
}

// Module

var Module = {
  registered: false,

  registerSelf: function(compMgr, fileSpec, location, type) 
  {
    if (!this.registered) {
      compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar)
             .registerFactoryLocation(kServiceCId,
                                      kServiceName,
                                      kServiceCtrId, 
                                      fileSpec,
                                      location, 
                                      type);
      const catman = Components.classes['@mozilla.org/categorymanager;1']
                               .getService(Components.interfaces.nsICategoryManager);
      var len = kServiceCats.length;
      for (var j = 0; j < len; j++) {
        catman.addCategoryEntry(kServiceCats[j],
          kServiceCtrId, kServiceCtrId, true, true, null);
      }
      this.registered = true;
    } 
  },

  unregisterSelf: function(compMgr, fileSpec, location) 
  {
    compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar)
           .unregisterFactoryLocation(kServiceCId, fileSpec);
    const catman = Components.classes['@mozilla.org/categorymanager;1']
                             .getService(Components.interfaces.nsICategoryManager);
    var len = kServiceCats.length;
    for (var j = 0; j < len; j++) {
      catman.deleteCategoryEntry(kServiceCats[j], kServiceCtrId, true);
    }
  },

  getClassObject: function(compMgr, cid, iid) 
  {
    if(cid.equals(kServiceCId))
      return kServiceFactory;
    
    throw Components.results[
      iid.equals(Components.interfaces.nsIFactory)
      ? "NS_ERROR_NO_INTERFACE"
      : "NS_ERROR_NOT_IMPLEMENTED"
    ];
    
  },

  canUnload: function(compMgr) 
  {
    return true;
  }
};

// entrypoint
function NSGetModule(compMgr, fileSpec) {
  return Module;
}