if (typeof YAHOO.Edmunds == 'undefined') {
    YAHOO.Edmunds = {};
}

// creates a namespace for this "YAHOO.Edmunds.Inventory"
YAHOO.namespace("YAHOO.Edmunds.Inventory");

YAHOO.Edmunds.Inventory.PidgetLinker = function(baseurl, load, namespace, version){

    if (typeof(window.PidgetConfig) === "undefined") {
        throw "Error, you must provide a window.PidgetConfig object at the window level scope."
    }
    
    if (typeof window.Pidget == "undefined") {
        window.Pidget = {
            configs: {},
            baseURL: null,
            defaultATOMServer: null,
            _debugEnabled: window.PidgetConfig.debug || false,
            
            write: function(value){
                if (value) {
                    document.write(value)
                }
            },
            
            computePidgetUrl: function(load, namespace, version, config){
                return Pidget.baseURL + namespace + "Pidget" + load + "-" + version + ".js"
            }
        }
    }
    
    window.Pidget.baseURL = baseurl ? baseurl + "push/" : "";
    this.load = load ? load : "";
    this.namespace = namespace ? namespace : "";
    this.version = version ? version : "";
    if (this.namespace != "") {
        this.namespace = this.namespace + "/"
    }
    
    if (window.Pidget.baseURL == null || this.load == null) {
        throw "Error, invalid path/pidget load request."
    }
    
    if (!window.PidgetConfig.frameworkVersion) {
        throw "Error, you must provide a Pidget Framework (frameworkVersion) version in your window.PidgetConfig object."
    } else {
        Pidget.frameworkVersion = window.PidgetConfig.frameworkVersion
    }
    
    if (this.version === "") {
        throw "Error, you must provide a version for your Pidget as a URL parameter (&version=#.#.#) to the PidgetLoader"
    }
    
    window.Pidget.configs[this.load] = window.PidgetConfig;
    window.PidgetConfig = null;
    var config = window.Pidget.configs[this.load];
    config._start = new Date();
    config.version = this.version;
    if (!window.Pidget.defaultATOMServer) {
        if (config.data && config.data.server) {
            window.Pidget.defaultATOMServer = config.data.server
        } else {
            window.Pidget.defaultATOMServer = window.Pidget.baseURL.replace(/\/push/, "")
        }
    }
    if (window.Pidget) {
        window.Pidget._start = new Date();
        
        var pidget_included_scripts = [];
        var framework_script_ref = Pidget.baseURL + 'core/PidgetFramework-Packed-' + Pidget.frameworkVersion + '.js';
        
        var me = this;
        var script_callback_function = function() {
            var pidget_script_ref = Pidget.computePidgetUrl(me.load,me.namespace,me.version, config);
            me.addScript(pidget_script_ref, pidget_included_scripts);
        };
        
        if(!this.addScript(framework_script_ref, pidget_included_scripts, script_callback_function)) {
            var pidget_script_ref = Pidget.computePidgetUrl(me.load,me.namespace,me.version, config);
            this.addScript(pidget_script_ref, pidget_included_scripts);
        }
    }
};

YAHOO.Edmunds.Inventory.PidgetLinker.prototype = {

    getDocumentScripts: function(){
        var return_value = [];
        
        var script_tags = document.getElementsByTagName('script');
        var script_tag_count = 0;
        for (script_tag_count = 0; script_tag_count < script_tags.length; script_tag_count++) {
            if (script_tags[script_tag_count].src) {
                return_value.push(script_tags[script_tag_count]);
            }
        }
        
        var upper_case_script_tags = document.getElementsByTagName('SCRIPT');
        var upper_case_script_tag_count = 0;
        for (upper_case_script_tag_count = 0; upper_case_script_tag_count < upper_case_script_tags.length; upper_case_script_tag_count++) {
            if (upper_case_script_tags[upper_case_script_tag_count].src) {
                return_value.push(upper_case_script_tags[upper_case_script_tag_count]);
            }
        }
        
        return return_value;
    },
    
    containsScript: function(script_reference, pidget_included_scripts){
        var return_value = false;
        if (pidget_included_scripts && pidget_included_scripts.toString().indexOf(script_reference) != -1) {
            return_value = true;
        } else {
            var script_tags = this.getDocumentScripts();
            
            var script_tag_count = 0;
            for (script_tag_count = 0; script_tag_count < script_tags.length; script_tag_count++) {
                var script_tag = script_tags[script_tag_count];
                if (script_tag.src == script_reference) {
                    return_value = true;
                }
            }
        }
        
        return return_value;
    },
    
    addScript: function(script_reference, pidget_included_scripts, callback){
        var return_value = false;
        
        if (!this.containsScript(script_reference, pidget_included_scripts)) {
            return_value = true;
            
            var script_tag = document.createElement('script');
            script_tag.type = 'text/javascript';
            script_tag.src = script_reference;
            
            if(callback) {
                script_tag.onload = callback;
                if (YAHOO.env.ua.ie) {
                    script_tag.onreadystatechange = function() {
                        if (this.readyState == 'complete' || this.readyState == 'loaded') {
                            callback();
                        }
                    }
                }
            }
            
            var bodyRef = document.getElementsByTagName("body").item(0);
            
            if (bodyRef) {
                if (YAHOO.env.ua.ie) {
                    var children = YAHOO.util.Dom.getChildren(bodyRef);
                    
                    if (children && children.length > 0) {
                        YAHOO.util.Dom.insertBefore(script_tag, children[children.length - 1]);
                    }
                } else {
                    bodyRef.appendChild(script_tag);
                }
            }
            pidget_included_scripts.push(script_reference);
        }
        
        return return_value;
    }
};

/** Pidget loader **/
YAHOO.Edmunds.Inventory.PidgetLoader = function(framework_version){
    if (!YAHOO.Edmunds.Util.activeXEnabled) {
        alert("Your browser's ActiveX controller may be blocked by a firewall or a high security setting. Please adjust your settings and try again.");
        return;
    }
    
    // default framework version #
    this.default_framework_version = '1.1.9';
    
    // default pidget version #s
    this.default_pidget_versions = [];
    this.default_pidget_versions['SRL'] = '1.2.5';
    this.default_pidget_versions['DealerInfo'] = '1.1.8';
    this.default_pidget_versions['DealerDetails'] = '1.1.3';
    this.default_pidget_versions['Specials'] = '1.1.5';
    this.default_pidget_versions['NCAL'] = '1.2.0';
    this.default_pidget_versions['SRLDetailed'] = '1.1.0';
    this.default_pidget_versions['SRLStats'] = '0.1.1';
    this.default_pidget_versions['Vehicle'] = '1.2.1';

    if(framework_version) {
        this.framework_version = framework_version;
    } else {
        this.framework_version = this.default_framework_version;
    }

    this.PIDGET_DEBUG = YAHOO.Edmunds.Inventory.isPidgetDebug();
    this.server_url = 'http://pidget.autotrader.com/pidget/';
};

YAHOO.Edmunds.Inventory.PidgetLoader.prototype = {

    addPidget: function(component_version, containerID, callback, type, loader_data, extra_config_parameters, callback_scope){
        var pidget_loader_data = loader_data;
        
        if (pidget_loader_data && pidget_loader_data.parameters) {
            pidget_loader_data.parameters.server = this.server_url;
        }
        
        var current_pidget_loader = callback_scope ? callback_scope : this;
        var callback_function_wrapper = function(){
            callback.call(current_pidget_loader);
        };
        
        window.PidgetConfig = {
            apiKey: "889883a9-3b0d-4b7d-b162-38eebbdc4ce3",
            "apiKey": "889883a9-3b0d-4b7d-b162-38eebbdc4ce3",
            onload: callback_function_wrapper,
            frameworkVersion: this.framework_version,
            debug: this.PIDGET_DEBUG,
            whiteLabel: true,
            noCSS: true,
            partnerCode: "edmunds",
            containerID: containerID,
            phoneBgFadeR: 250,
            phoneBgFadeG: 251,
            phoneBgFadeB: 246,
            parameters: {
                partner: "edmunds"
            },
            data: pidget_loader_data
        };
        
        // add extra config parameters
        if (extra_config_parameters) {
            for (var i in extra_config_parameters) {
                window.PidgetConfig[i] = extra_config_parameters[i];
            }
        }
        
        var pidget_component_version = this.default_pidget_versions[type];
        if(component_version) {
            pidget_component_version = component_version;
        }
        
        if(pidget_component_version) {
            var pidget_linker = new YAHOO.Edmunds.Inventory.PidgetLinker(this.server_url, type, null, pidget_component_version);
        } else {
            alert("The component version for type '" + type + "' is invalid, this needs to be registered!");
        }
    }
};