/*
References:
- http://mxr.mozilla.org/mozilla-central/source/toolkit/content/aboutAbout.xhtml
  or enter 'view-source:about:about' in location bar
*/

/* 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 isFx = Application.id == "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}";
const isSM = Application.id == "{92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a}";
const isTb = Application.id == "{3550f703-e582-4d05-9a08-453d09bdfdc6}";

this.type = "menu";
this.label = this.tooltipText = "About: Pages";
var xml = '<menupopup xmlns="' + xulns + '"'
        + '           context="toolbar-context-menu"'
        + '           oncontextmenu="inspect(event);"'
        + '           onpopupshowing="populate(this);"'
        + '           oncommand="switchToTabHavingURI('
        + 'event.target.label, true);"'
        + '           onclick="middleClickHandler(event);"></menupopup>';
var menu = this.appendChild($xml(xml));

menu.populate = populate.bind();

this.image = isFx ? "chrome://browser/skin/places/query.png"
                  : isSM
                    ? "chrome://communicator/skin/bookmarks/query.png"
                    : "data:image/png;base64,\
iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJ\
bWFnZVJlYWR5ccllPAAAAS9JREFUeNqkUz1LA0EQfftxsUq0EREUGxux8o9YWVqKnT8hFpJeEOz8\
B1rZ+AvsbBNBRSJpYhE4CB7J7Zczl0bNXmDNg7e73M6beTPsyRAClqF+uVKogxTYp+2w5vreB3Q1\
HY6JO7EICsDume0UZYnxZIKv6RSn/XWMRgVuX1uSQg5E71K2907uLoJzv8RCKeT9j+q8ur01l5zv\
n2+OzrX1UJ4qMP+iRUJO8tntRXtgrabCylsD5lwLY4Pm5kZUzA6Gj5SgcmAtXCTBrEz8u2qszBxY\
B+1MCWYShABrtaHFG0MJTKJegrWVA+4/1YGU8oeDmiEugqchVg6MFdnCIdZAKQ3W6rxAk59UprK0\
Fois1U/vGOTX7Qf8A29DDATtDeIaUSfqLZsQ/Esug28BBgBGIMAJudMj8gAAAABJRU5ErkJggg==";

function populate(aNode) {
  while (aNode.lastChild)
    aNode.removeChild(aNode.lastChild);

  var protocols = [];
  var ios = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
  for (var cid in Cc) {
    let res = cid.match(/@mozilla.org\/network\/protocol\/about;1\?what\=(.*)$/);
    if (res) {
      let aboutType = res[1];
      let contract = "@mozilla.org/network/protocol/about;1?what=" + aboutType;
      try {
        let am = Cc[contract].getService(Ci.nsIAboutModule);
        let uri = ios.newURI("about:" + aboutType, null, null);
        let flags = am.getURIFlags(uri);
        if (!(flags & Ci.nsIAboutModule.HIDE_FROM_ABOUTABOUT))
          protocols.push(aboutType);
      }
      catch (ex) {
        // getService might have thrown if the component doesn't actually
        // implement nsIAboutModule
      }
    }
  }

  var isWin = Services.appinfo.OS === "WINNT";
  if (isWin && (protocols.length >= 20)) {
    var hbox  = aNode.appendChild($xml('<hbox xmlns="' + xulns + '"></hbox>'));
    var vbox1 = hbox.appendChild($xml('<vbox xmlns="' + xulns + '"></vbox>'));
    var vbox2 = hbox.appendChild($xml('<vbox xmlns="' + xulns + '"></vbox>'));
    protocols.sort().forEach(function(aProtocol) {
      let vbox = (aProtocol < protocols[parseInt(protocols.length / 2)])
                  ? vbox1 : vbox2;
      addMenuItem(vbox, "about:" + aProtocol);
    })
  }
  else {
    protocols.sort().forEach(function(aProtocol) {
      addMenuItem(aNode, "about:" + aProtocol);
    })
  }
}

function $xml(aXML) {
  return (new DOMParser).parseFromString(aXML, "application/xml")
                        .documentElement;
}

function addMenuItem(aNode, aLabel) {
  aNode.appendChild($xml('<menuitem xmlns="' + xulns + '"' +
                         ' label="' + aLabel + '"/>'));
}

menu.inspect = function inspect(aEvent) {
  if (!"inspectDOMNode" in window)
    return;
  aEvent.preventDefault();
  inspectDOMNode(aEvent.target);
  closeMenus(aEvent.target);
}

menu.middleClickHandler = function middleClickHandler(aEvent) {
  if (isTb || aEvent.button != 1) return;
  aEvent.preventDefault();
  gBrowser.selectedTab = gBrowser.addTab(aEvent.target.label);
  closeMenus(aEvent.target);
}

//this.boxObject.lastChild.collapsed = true;

////////////////////////////////////////////////////////////////////////////
/////////////////////////// Start Button updater ///////////////////////////

/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0
 *
 * 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/1.1/
 *
 * 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.
 *
 * Original code is Button Updater for Custom Buttons extension
 *
 * The Initial Developer of the Original Code is LouCypher.
 * Portions created by the Initial Developer are Copyright (C) 2011
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 * - LouCypher: original code
 *
 * Alternatively, the contents of this file may be used under the terms of
 * the GNU General Public License Version 2 or later (the "GPL"), in which
 * case the provisions of the GPL are applicable instead of those above.
 *
 * ***** END LICENSE BLOCK ***** */

this.updater = {
  btnClick: self.onclick,
  btnType: self.type,
  btnImage: self.image,
  btnTooltip: self.tooltipText,

  baseURL: "https://loucypher.googlecode.com/svn/custombuttons/xml/",

  get updateURL() {
    return this.baseURL + encodeURIComponent(self.name.replace(/(\/|:)/g, "-"))
                        + ".xml";
  },

  openUpdateURL: function updater_openUpdateURL() {
    switchToTabHavingURI(this.updateURL);
  },

  get stdIcon() {
    var stdIcon = parseInt(self.cbStdIcon.match(/\d/));
    switch (stdIcon) {
       case 4: return "chrome://custombuttons/skin/stdicons/bbutton.png";
       case 3: return "chrome://custombuttons/skin/stdicons/gbutton.png";
       case 2: return "chrome://custombuttons/skin/stdicons/rbutton.png";
      default: return "chrome://custombuttons/skin/button.png";
    }
  },

  get bsyIcon() {
    switch (Application.id) {
      case "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}":
        if (Application.version >= "4")
          return "chrome://browser/skin/tabbrowser/connecting.png";
        else
          return "chrome://global/skin/icons/loading_16.png";

      case "{92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a}":
        return "chrome://communicator/skin/icons/loading.gif";

      default:
        return "chrome://global/skin/icons/loading_16.png";
    }
  },

  // Check if the URI is Custom Button URI (custombutton://...)
  isValidCbURI: function updater_isValidCbURI(aURL) {
    if (!aURL) return false;
    return /^custombutton\:\/\//.test(aURL);
  },

  // Convert 'custombutton:' URI to DOM
  convertURItoDOM: function updater_convertURItoDOM(aURL) {
    if (!this.isValidCbURI(aURL)) {
      custombuttons.alertBox(self.name, "Not a Custom Buttons link!");
      return;
    }
    var string = unescape(aURL.replace(/^custombutton\:\/\//, "").toString());
    var parser = new DOMParser();
    var dom = parser.parseFromString(string, "text/xml");
    if (dom.documentElement.nodeName == "parsererror")
      return null;
    else
      return dom.documentElement;
  },

  // Get value from XML element
  getParamValue: function updater_getParamValue(aDocument, aNodeName) {
    var node = aDocument.querySelector(aNodeName);
    if (!node)
      return "";
    if (!node.firstChild || (node.firstChild &&
        (node.firstChild.nodeType == node.TEXT_NODE))) {
      return node.textContent;
    }
    else
      return node.firstChild.textContent;
  },

  // Set button parameters from XML alement
  getButtonParameters: function updater_getButtonParameters(aButtonLink, aURL) {
    var dom = this.convertURItoDOM(aURL);
    var params = custombuttons.cbService.getButtonParameters(aButtonLink)
                                        .wrappedJSObject;
    params.name             = this.getParamValue(dom, "name")
    params.date             = this.getParamValue(dom, "date") || "";
    params.image            = this.getParamValue(dom, "image") ||
                              this.getParamValue(dom, "stdicon");
    params.code             = this.getParamValue(dom, "code")
    params.initCode         = this.getParamValue(dom, "initcode")
    params.help             = this.getParamValue(dom, "help")
    params.accelkey         = this.getParamValue(dom, "accelkey")
    params.mode             = this.getParamValue(dom, "mode")
    params.wrappedJSObject  = params;
    return params;
  },

  // Reset button attribute if user click the button during update
  resetAttributes: function updater_resetAttributes() {
    self.image = this.btnImage;
    self.tooltipText = self.name;
    self.removeAttribute("busy");
    self.onclick = this.btnClick;
    self.type = this.btnType;
    self.tooltipText = this.btnTooltip;
  },

  // Check button for update
  checkForUpdate: function updater_checkForUpdate(aCallback) {
    if (!navigator.onLine) {                // If browser is in offline mode
                                            // ask to switch to online
      var online = custombuttons.confirmBox(self.name,
                             "Firefox is currently in offline mode.\n"
                           + "Switch to online mode and try again?",
                             "Yes", "No");
      if (!online) return;
      BrowserOffline.toggleOfflineStatus(); // switch to online
    }

    var url = this.updateURL + "?" + Date.now();
    var req = new XMLHttpRequest();
    req.open("GET", url, true);
    if (self.hasAttribute("busy")) {
      this.resetAttributes();
      return
    }
    var updater = this;
    req.onreadystatechange = function (aEvent) {
      self.onclick = function(aEvent) {
        aEvent.preventDefault();
        req.abort();
        self.updater.resetAttributes();
      }
      self.image = updater.bsyIcon;
      self.setAttribute("busy", "");
      self.removeAttribute("type");
      self.tooltipText = "Checking for update...\nClick to abort.";
      if (req.readyState == 4 && req.status == 200) {
        updater.resetAttributes();
        aCallback(req.responseXML);
      }
    }
    req.send(null);
  },

  // Get update from XML
  getUpdate: function updater_getUpdate(aDocument) {
    if (aDocument.documentElement.localName != "custombutton") {
      custombuttons.alertBox(self.name,
                             "Not a valid Custom Buttons XML file!");
      return;
    }

    //inspectDOMDocument(aDocument); return;
    let icon = self.updater.btnImage ? self.updater.btnImage
                                     : self.updater.stdIcon;
    let button = aDocument.getElementById("button");
    let link = button.getElementsByTagNameNS(xhtmlns, "a")[0];
    if (link.href == self.URI) {
      let as = Cc['@mozilla.org/alerts-service;1'].
               getService(Ci.nsIAlertsService);
      as.showAlertNotification(icon, "No update found!",
                               "Finish checking", false, "", null);
      return;
    } 

    var install = custombuttons.confirmBox(self.name, "Update found! " +
                                           "Update this button?",
                                           "Yes", "No");
    if (!install) return;
    let btnLink = custombuttons.makeButtonLink("update", self.id);
    let params = self.updater.getButtonParameters(btnLink, link.href);
    //inspectObject(params); return;
    custombuttons.cbService.installButton(params);
    custombuttons.alertBox(self.name, "Button updated!");
    self.setAttribute("cb-edit-state", "active");
  },

  init: function updater_onLoad() {

    var icon = this.btnImage ? this.btnImage : this.stdIcon;

    function $(aId) {
      return document.getElementById(aId);
    }

    function addMenuItem(aNewIDs, aNodeIDs, aSeparator) {
      // Remove previously created menuitems if any
      if ($(aNewIDs)) {
        if (aSeparator &&
            ($(aNewIDs).nextSibling.localName == "menuseparator")) {
          $(aNewIDs).parentNode.removeChild($(aNewIDs).nextSibling);
        }
        $(aNewIDs).parentNode.removeChild($(aNewIDs));
      }

      var mi = $xml(
                    '<menuitem xmlns="' + xulns + '"'
                  + ' id="' + aNewIDs + '"'
                  + ' class="menuitem-iconic"'
                  + ' image="' + icon + '"'
                  + ' label="Check for updates for this button"'
                  + ' onclick="if (event.button == 1) {'
                  + ' var btn = document.getElementById(\''
                  + self.id + '\'); btn.updater.openUpdateURL(); }" '
                  + ' oncommand="var btn = document.getElementById(\''
                  + self.id + '\'); btn.updater.checkForUpdate('
                  + 'btn.updater.getUpdate);"'
                  + ' observes="custombuttons-contextbroadcaster-primary"/>');
      $(aNodeIDs).parentNode.insertBefore(mi, $(aNodeIDs).nextSibling);
      if (aSeparator) {
        var sep = $xml('<menuseparator xmlns="' + xulns + '"'
                            + ' id="' + mi.id + '-separator"/>');
        mi.parentNode.insertBefore(sep, mi.nextSibling);
      }
    }

    function initUpdaterCbPopup(aEvent) {
      var popupNode = "triggerNode" in aEvent.target
                        ? aEvent.target.triggerNode : document.popupNode;
      $(kIDs).hidden = (popupNode != self);
      ($(kIDs).nextSibling.id == $(kIDs).id + "-separator") &&
      ($(kIDs).nextSibling.hidden = (popupNode != self));
    }

    var kIDs = self.id + "-checkForUpdate";
    var uIDs = "custombuttons-contextpopup-updateButton";

    // Add 'Check for Update...' menuitem to CB contextmenu
    addMenuItem(kIDs, uIDs, true);

    $(uIDs).parentNode.addEventListener("popupshowing",
                                           initUpdaterCbPopup, false);
    $(uIDs).parentNode.removeEventListener("popuphiding",
                                              initUpdaterCbPopup, false);

    self.onDestroy = function(aReason) {
      if (aReason != "delete") return;
      $(uIDs).parentNode.removeEventListener("popupshowing",
                                             initUpdaterCbPopup, false);
      $(kIDs).parentNode.removeChild($(kIDs + "-separator"));
      $(kIDs).parentNode.removeChild($(kIDs));
    }
  }
}

this.updater.init();

//////////////////////////// End Button updater ////////////////////////////
////////////////////////////////////////////////////////////////////////////

// Start backward compatibility
if ("switchToTabHavingURI" in window)
  return;

menu.switchToTabHavingURI = function switchToTabHavingURI(aURI, aOpenNew) {
  if (isTb) {
    openContentTab(aURI, "tab", "^(https?|about):");
    return;
  }

  function switchIfURIInWindow(aWindow) {
    var browsers = aWindow.gBrowser.browsers;
    for (let i = 0; i < browsers.length; i++) {
      let browser = browsers[i];
      if (browser.currentURI.equals(aURI)) {
        aWindow.focus();
        aWindow.gBrowser.tabContainer.selectedIndex = i;
        return true;
      }
    }
    return false;
  }

  if (!(aURI instanceof Ci.nsIURI)) {
    aURI = makeURI(aURI, null, null);
  }
  var isBrowserWindow = !!window.gBrowser;
  if (isBrowserWindow && switchIfURIInWindow(window)) {
    return true;
  }
  var wm = Cc["@mozilla.org/appshell/window-mediator;1"].
           getService(Ci.nsIWindowMediator);
  var winEnum = wm.getEnumerator("navigator:browser");
  while (winEnum.hasMoreElements()) {
    let browserWin = winEnum.getNext();
    if (browserWin.closed || browserWin == window) {
      continue;
    }
    if (switchIfURIInWindow(browserWin)) {
      return true;
    }
  }
  if (aOpenNew) {
    if (isBrowserWindow && isTabEmpty(gBrowser.selectedTab)) {
      gBrowser.selectedBrowser.loadURI(aURI.spec);
      gBrowser.tabContainer.mTabstrip
                           .ensureElementIsVisible(gBrowser.selectedTab);
    }
    else
      openUILinkIn(aURI.spec, "tab");
  }
  return false;
}

function isTabEmpty(aTab) {
  var browser = aTab.linkedBrowser;
  var uri = browser.currentURI.spec;
  var body = browser.contentDocument.body;
  return browser.sessionHistory.count < 2 &&
         (uri == "about:blank") &&
         (!body || !body.hasChildNodes()) &&
         !aTab.hasAttribute("busy");
}