const nsISupports            = Components.interfaces.nsISupports;

const nsIBrowserDOMWindow    = Components.interfaces.nsIBrowserDOMWindow;
const nsIChannel             = Components.interfaces.nsIChannel;
const nsIContentHandler      = Components.interfaces.nsIContentHandler;
const nsIDOMChromeWindow     = Components.interfaces.nsIDOMChromeWindow;
const nsIDOMWindow           = Components.interfaces.nsIDOMWindow;
const nsIFactory             = Components.interfaces.nsIFactory;
const nsIHttpProtocolHandler = Components.interfaces.nsIHttpProtocolHandler;
const nsIInterfaceRequestor  = Components.interfaces.nsIInterfaceRequestor;
const nsIPrefBranch          = Components.interfaces.nsIPrefBranch;
const nsIPrefLocalizedString = Components.interfaces.nsIPrefLocalizedString;
const nsISupportsString      = Components.interfaces.nsISupportsString;
const nsIWebNavigation       = Components.interfaces.nsIWebNavigation;
const nsIWindowMediator      = Components.interfaces.nsIWindowMediator;
const nsIWindowWatcher       = Components.interfaces.nsIWindowWatcher;
const nsICategoryManager     = Components.interfaces.nsICategoryManager;
const nsIWebNavigationInfo   = Components.interfaces.nsIWebNavigationInfo;
const nsIStreamListener      = Components.interfaces.nsIStreamListener;
const nsIRequestObserver     = Components.interfaces.nsIRequestObserver;
const nsIURILoader           = Components.interfaces.nsIURILoader;
const nsIURIContentListener  = Components.interfaces.nsIURIContentListener;

const NS_BINDING_ABORTED = 0x80020006;
const NS_ERROR_WONT_HANDLE_CONTENT = 0x805d0001;
const NS_ERROR_ABORT = Components.results.NS_ERROR_ABORT;

function shouldLoadURI(aURI) {
  if (aURI.schemeIs("xri"))
    return true;
  dump("*** Preventing external load of chrome: URI into browser window\n");
  dump("    Use -chrome <uri> instead\n");
  return false;
}




function openWindow(parent, url, target, features, args) {
  var wwatch = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
                         .getService(nsIWindowWatcher);

  var argstring;
  if (args) {
    argstring = Components.classes["@mozilla.org/supports-string;1"]
                            .createInstance(nsISupportsString);
    argstring.data = args;
  }
  return wwatch.openWindow(parent, url, target, features, argstring);
}




function getMostRecentWindow(aType) {
  var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
                     .getService(nsIWindowMediator);
  return wm.getMostRecentWindow(aType);
}




// this returns the most recent non-popup browser window
function getMostRecentBrowserWindow() {
  var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
                     .getService(Components.interfaces.nsIWindowMediator);

  var windowList = wm.getZOrderDOMWindowEnumerator("navigator:browser", true);
  if (!windowList.hasMoreElements())
    return null;

  var win = windowList.getNext();
  while (!win.toolbar.visible) {
    if (!windowList.hasMoreElements()) 
      return null;

    win = windowList.getNext();
  }

  return win;
}


















var xrdsContentHandler = {

  /** browser window */
  contentWindow: null,

  /** XRDS buffer */
  buf: null,

  scriptableInStream: null,

  init: function(contentWin) {
    this.contentWindow = contentWindow;
  },

  close: function() {
    this.contentWindow = null;
  },

  /* nsISupports */
  QueryInterface : function(iid) {
    dump("xrdsCH ... ");
    if (iid.equals(nsISupports)) {
	    dump("QI(nsISupports)\n");
    }
    else if (iid.equals(nsIContentHandler)) {
	    dump("QI(nsIContentHandler)\n");
    }
    else if (iid.equals(nsIStreamListener)) {
	    dump("QI(nsIStreamListener)\n");
    }
    else if (iid.equals(nsIRequestObserver)) {
	    dump("QI(nsIRequestObserver)\n");
    }
    else if (iid.equals(Components.interfaces.nsIURIContentListener)) {
	    dump("QI(nsIURIContentListener)\n");
    }
    else if (iid.equals(nsIFactory)) {
	    dump("QI(nsIFactory)\n");
    }
    else {
	    dump("QI(" + iid + ") - IDONTKNOW!!!!!\n");
    }

    if (!iid.equals(nsISupports) &&
        !iid.equals(nsIContentHandler) &&
        !iid.equals(nsIURIContentListener) &&
        !iid.equals(nsIStreamListener) &&
        !iid.equals(nsIRequestObserver) &&
        !iid.equals(nsIFactory))
      throw Components.results.NS_ERROR_NO_INTERFACE;

    dump("QI returning this..\n");
    return this;
  },


  /* nsIURIContentListener */
  loadCookie: null,

  parentContentListener: null,

  onStartURIOpen: function(uri)
  {
    dump("xrdsCH onStartURIOpen '" + uri + "'");
    // ignore and don't abort
    return false;
  },

  doContent: function(contentType, isContentPreferred, request, contentHandler)
  {
	dump("doContent called\n");
        // forward the doContent to our content area webshell
        var docShell = this.contentWindow.docShell;
        var contentListener;
        try {
            contentListener =
                docShell.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
                .getInterface(Components.interfaces.nsIURIContentListener);
        } catch (ex) {
            dump(ex);
        }

	dump("no content listener from docShell!\n");
        if (!contentListener) return false;

	var rv = contentListener.doContent(contentType, isContentPreferred, request, contentHandler);

	if (rv) {
		dump("docShell wants to handle the load..\n");
	}
	else {
		dump("docShell does NOT want to handle the load..\n");

		contentHandler = contentHandler.value;
	}

	return rv;

  },

  isPreferred: function(contentType, desiredContentType)
  {
    dump("isPreferred '" + contentType + "'\n");
        switch(contentType) {
            case "application/xrds+xml":
            case "application/xrd+xml":
		dump("yes!!!\n");
                return true;
        }
	dump("erm.. nope!\n");
        return false;
  },

  canHandleContent: function(contentType, isContentPreferred, desiredContentType)
  {
    dump("canHandleContent '" + contentType + "'\n");
    return this.isPreferred(contentType, desiredContentType);
  },



  /* nsIRequestObserver */
  onStartRequest: function(request, ctx)
  {
    dump("xrdsContentHandler - onStartRequest\n");
  },

  onStopRequest: function(request, ctx, status)
  {
    dump("xrdsContentHandler - onStopRequest\n");
    this.scriptableInStream.close();
  },


  /* nsIStreamListener */
  onDataAvailable: function(request, domWindow, inputStream, offset, count)
  {
    dump("onDataAvailable, offset=" + offset + ", count=" + count + "\n");
    if (offset == 0) {
      this.scriptableInStream.init(inputStream);
    }

    buf += this.scriptableInStream.read(count);

    if (!request.isPending()) {
      dump("request finished, buf = " + buf + "\n");
      var html = domWindow.document.createElement("html");
      html.createTextNode(buf);
      this.scriptableInStream = null;
    }
    else {
      dump("request pending...\n");
    }
  },

  /* nsIContentHandler */

  handleContent : function(contentType, context, request)
  {
    dump("handleContent " + contentType + "\n");
    var parentWin;
    try {
      parentWin = context.getInterface(nsIDOMWindow);
    }
    catch (e) {
      alert("no parent!!!"); // XXX
      return;
    }

    dump("getting channel\n");
    var channel = request.QueryInterface(nsIChannel);
    if (!channel) {
      dump("no channel!!!\n");
      return;
    }

    if (this.scriptableInStream) {
      dump("Hey! You can't possibly be reusing this handler?!\n");
      return;
    }

    dump("making scriptableInStream\n");
    this.scriptableInStream = Components.classes["@mozilla.org/scriptableinputstream;1"]
                                   .createInstance(Components.interfaces.nsIScriptableInputStream);

    buf = '';

/*
    try {
	    dump("before asyncOpen\n");
	    channel.asyncOpen(this, parentWin);
            return;
    }
    catch (e) {
	dump("shit cannot asyncOpen... " + e + "\n");
    }

    dump("try blocking open\n");
    var instream = channel.open();
    this.scriptableinputstream.init(instream);
    while (true) {
      var n = this.scriptableinputstream.available();
      if (n > 0) {
        dump(this.scriptableinputstream.read(n) + "\n");
      }
    }

    dump("channel opened\n");
*/

    dump("handleContent returning \n");
  },

  /* nsIFactory */
  createInstance: function(outer, iid)
  {
    dump("xrdsCH createInstance called..\n");
    if (outer != null)
      throw Components.results.NS_ERROR_NO_AGGREGATION;

    dump("xrdsCH ok\n");
    return this.QueryInterface(iid);
  },
    
  lockFactory : function bch_lock(lock) {
    /* no-op */
  }
};

const CLASS_ID = Components.ID("{e857f11b-fd59-4285-8f4a-c27cf9051a36}");
const CLASS_NAME = "XRDS Content Handler";
const CONTRACTID_PREFIX = "@mozilla.org/uriloader/content-handler;1?type=";



var Module = {
  /* nsISupports */
  QueryInterface: function(iid)
  {
    dump("QI called\n");
    if (iid.equals(Components.interfaces.nsIModule) ||
        iid.equals(Components.interfaces.nsISupports))
      return this;

    dump("QI throwing!!\n");
    throw Components.results.NS_ERROR_NO_INTERFACE;
  },


  /* nsIModule */
  getClassObject: function(compMgr, cid, iid)
  {
    dump("getClassObject called\n");
    if (cid.equals(CLASS_ID))
      return xrdsContentHandler.QueryInterface(iid);

    dump("gCO throwing!!\n");
    throw Components.results.NS_ERROR_NO_INTERFACE;
  },
 

  registerSelf: function(compMgr, fileSpec, location, type)
  {
    var compReg =
      compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);

    compReg.registerFactoryLocation( CLASS_ID,
			       CLASS_NAME,
			       CONTRACTID_PREFIX + "application/xrds+xml",
			       fileSpec,
			       location,
			       type );

    compReg.registerFactoryLocation( CLASS_ID,
			       CLASS_NAME,
			       CONTRACTID_PREFIX + "text/uri-list",
			       fileSpec,
			       location,
			       type );

    dump("done registerSelf..\n");
  },
 

  unregisterSelf: function(compMgr, location, type)
  {
    var compReg = compMgr.QueryInterface(nsIComponentRegistrar);
    compReg.unregisterFactoryLocation(CLASS_ID, location);
  },


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

// NSGetModule: Return the nsIModule object.
function NSGetModule(compMgr, fileSpec) {
  return Module;
}