const nsIFile                           = Components.interfaces.nsIFile;
const nsILocalFile                      = Components.interfaces.nsILocalFile;

const CACHE_FIXER_CONSOLE_SERVICE       = Components.classes["@mozilla.org/consoleservice;1"]
                                                    .getService(Components.interfaces.nsIConsoleService);

const CACHE_FIXER_PREFSERVICE_BRANCH    = Components.classes["@mozilla.org/preferences-service;1"]
                                                    .getService(Components.interfaces.nsIPrefService)
                                                    .getBranch("browser.cache.disk.");

const CACHE_FIXER_OBSERVER_SERVICE      = Components.classes["@mozilla.org/observer-service;1"]
                                                    .getService(Components.interfaces.nsIObserverService);

const CACHE_FIXER_DIR_LOCATOR           = Components.classes["@mozilla.org/file/directory_service;1"]
                                                    .getService(Components.interfaces.nsIProperties);


function nsCacheFixer() {
    CACHE_FIXER_OBSERVER_SERVICE.addObserver(this,"profile-after-change",false);
    this.debug = true;
}

nsCacheFixer.prototype = {

    _dump: function(msg) {
        if (!this.debug) return;
        
        msg = "[fixer]: " + msg + "\n";
        CACHE_FIXER_CONSOLE_SERVICE.logStringMessage(msg);
        dump(msg);
    },
    
    //~ nsIObserver interface
    observe: function(aSubject, aTopic, aData) {
        if (aTopic == "profile-after-change") {
            try {
                this.debug = CACHE_FIXER_PREFSERVICE_BRANCH.getBoolPref("cache_fixer_debug");
            } catch(e) {}
            
            var cacheDir, cacheMapFile;
            
            try { //~ prefs
                cacheDir = CACHE_FIXER_PREFSERVICE_BRANCH.getCharPref("parent_directory");
                this._dump("Cache dir: " + cacheDir);
            } catch(e) {
                try { //~ FF1.1
                    cacheDir = CACHE_FIXER_DIR_LOCATOR.get("ProfLD", nsIFile).path;
                    this._dump("Cache dir: " + cacheDir);
                } catch(e) {
                    try { //~ FF1.0-
                        cacheDir = CACHE_FIXER_DIR_LOCATOR.get("ProfD", nsIFile).path;
                        this._dump("Cache dir: " + cacheDir);
                    } catch(e) {
                        return this._dump("Error... Can't find cache dir...")
                    }
                }
            }
            
            if (cacheDir) {
                cacheMapFile = Components.classes["@mozilla.org/file/local;1"].createInstance(nsILocalFile);
                cacheMapFile.initWithPath(cacheDir);
                cacheMapFile.append("Cache");
                cacheMapFile.append("_CACHE_MAP_");
            }
            
            if (!cacheMapFile || !cacheMapFile.exists())
                return this._dump("Error... Can't found _CACHE_MAP_ file...");
            
            var ios = Components.classes["@mozilla.org/network/io-service;1"]
                                .getService(Components.interfaces.nsIIOService);
            
            var URL = ios.getProtocolHandler("file")
                                 .QueryInterface(Components.interfaces.nsIFileProtocolHandler)
                                 .getURLSpecFromFile(cacheMapFile);
            var channel = ios.newChannelFromURI( ios.newURI(URL,"utf8",null) );
            
            var binaryIS = Components.classes["@mozilla.org/binaryinputstream;1"]
                                     .createInstance(Components.interfaces.nsIBinaryInputStream);
            binaryIS.setInputStream(channel.open());
            
            var result = binaryIS.readByteArray(binaryIS.available());
            
            //~ leaks?!
            binaryIS.close();
            channel = null;
            
            if (result[15] == 1) {
                this._dump("FF was crashed, found 0F-byte == 1...");
                
                result[15] = 0; //~ Hi!
                
                var fs = Components.classes["@mozilla.org/network/file-output-stream;1"]
                                   .getService(Components.interfaces.nsIFileOutputStream);
                fs.init(cacheMapFile, 0x02 | 0x08 | 0x20, 0644, 0);
                
                var binaryOS = Components.classes["@mozilla.org/binaryoutputstream;1"]
                                          .createInstance(Components.interfaces.nsIBinaryOutputStream);
                binaryOS.setOutputStream(fs);
                binaryOS.writeByteArray(result, result.length);
                
                binaryOS.flush();
                fs.close();
                binaryOS.close();
                
                fs = null;
                binaryOS = null;
                result = null;
                
                this._dump("_CACHE_MAP_ was patched... That's it!");
            } else {
                this._dump("_CACHE_MAP_ ok, no patch needed...");
            }
        }
    },
    
    QueryInterface: function(iid) {
        if (!iid.equals(Components.interfaces.nsISupports) &&
            !iid.equals(Components.interfaces.nsISupportsWeakReference) &&
            !iid.equals(Components.interfaces.nsIObserver))
        {
            dump("nsCacheFixer: QI unknown interface: " + iid + "\n");
            throw Components.results.NS_ERROR_NO_INTERFACE;
        }
        return this;
    },

    //~ This Component's module implementation.
    module: {
        
        // registerSelf: Register this component.
        registerSelf: function (compMgr, fileSpec, location, type) {
            var compReg = compMgr.QueryInterface( Components.interfaces.nsIComponentRegistrar );
            compReg.registerFactoryLocation( this.cid,
                                             "nsCacheFixer JS component",
                                             this.contractId,
                                             fileSpec, location, type );
            
            var catman = Components.classes["@mozilla.org/categorymanager;1"]
                                   .getService(Components.interfaces.nsICategoryManager);
            catman.addCategoryEntry("app-startup", "nsCacheFixer", this.contractId, true, true);
        },
        
        unregisterSelf: function(compMgr, fileSpec, location) {
            compMgr = compMgr.QueryInterface( Components.interfaces.nsIComponentRegistrar );
            compMgr.unregisterFactoryLocation( this.cid, fileSpec );
            var catman = Components.classes["@mozilla.org/categorymanager;1"]
                                   .getService(Components.interfaces.nsICategoryManager);
            catman.deleteCategoryEntry("app-startup", this.contractId, true);
        },
        
        // getClassObject: Return this component's factory object.
        getClassObject: function (compMgr, cid, iid) {
            if (!cid.equals(this.cid))
                throw Components.results.NS_ERROR_NO_INTERFACE;
            
            if (!iid.equals(Components.interfaces.nsIFactory))
                throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
            
            return this.factory;
        },
        
        /* CID for this class */
        //~ extensions.roachfiend.com/cgi-bin/guid.pl
        cid: Components.ID("{ddbfe606-9b5a-4780-af06-38fc3705a3b8}"),
        
        /* Contract ID for this class */
        contractId: "@mozilla.org/cachefixer;1",
        
        /* factory object */
        factory: {
            // createInstance: Return a new nsCacheFixer object.
            createInstance: function (outer, iid) {
                if (outer != null)
                    throw Components.results.NS_ERROR_NO_AGGREGATION;
                
                return (new nsCacheFixer()).QueryInterface(iid);
            }
        },
        
        // canUnload: n/a (returns true)
        canUnload: function(compMgr) {
            return true;
        }
    }
}

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