var tmpobj;

/**
 * An autosuggest textbox control.
 * @class
 * @scope public
 */
function AutoSuggestControl(oTextbox /*:HTMLInputElement*/,
                            oProvider /*:SuggestionProvider*/,
                            oSearch /*:Search*/,
                            oParams /*: Object*/) {
    if (!oTextbox || !oProvider) {
        return;
    }
    
    /**
     * The currently selected suggestions.
     * @scope private
     */
    this.cur /*:int*/ = -1;

    /**
     * The dropdown list layer.
     * @scope private
     */
    this.layer = null;

    /**
     * Suggestion provider for the autosuggest feature.
     * @scope private.
     */
    this.provider /*:SuggestionProvider*/ = oProvider;

    /**
     * oSearch
     * Check if Autosuggest must be added
     */
    this.search /*:Search*/ = oSearch;

    /**
     * The textbox to capture.
     * @scope private
     */
    this.textbox /*:HTMLInputElement*/ = oTextbox;
    this.textbox.autocomplete='off';
    this.textbox.setAttribute('autocomplete', 'off');

    if(oParams)
    {
        this.id = oParams.id || false;        
        this.container = document.getElementById(oParams.container) || document.body;
    }  
    
    // Désactiver le formulaire
    if (typeof oParams.autoSubmit == "undefined" || oParams.autoSubmit == false)
    {
        this.form = getParentByTagName(this.textbox, "form");
    }
    
    //initialize the control
    this.init();
}

/**
 * GET form element
 * @scope private
 */
function getParentByTagName (elm, tagName)
{
    var node = elm.parentNode;
    
    while (elm && elm.tagName.toLowerCase() != "body")
    {
        if (elm.tagName.toLowerCase() == tagName)
        {
            return elm;
        }
        elm = elm.parentNode;
    }
    return false;
}

/**
 * GET the suggestion nodes
 * @scope private
 */
AutoSuggestControl.prototype.getSuggestionNodes = function() {    
    var tmp = this.layer.childNodes;
    var result = [];
    
    for (var i=0; i<tmp.length; i++)
    {
        if (tmp[i].nodeType == 1)
            result.push(tmp[i])
    }
    
    return result;
}

/**
 * Creates the dropdown layer to display multiple suggestions.
 * @scope private
 */ 
AutoSuggestControl.prototype.createDropDown = function () 
{
    this.layer = document.createElement("ul");
    if (this.id)
    {
        this.layer.id = this.id;
    }                
    this.layer.className = "suggestions";  
    this.layer.active = false;    
    this.layer.onmouseout = function(e)
    {
        this.active = false;
    };
    
    this.iframe = document.getElementById('iframe-' + this.layer.id); 
    this.container.appendChild(this.layer);  
};

/**
 * Handles three keydown events.
 * @scope private
 * @param oEvent The event object for the keydown event.
 */
AutoSuggestControl.prototype.handleKeyDown = function (oEvent /*:Event*/) {
    switch(oEvent.keyCode) {
        case 38: //up arrow  
            if (!this.layer.active)
            {
                this.layer.active = true;     
                this.showSuggestionElement();    
            } 
            this.previousSuggestion(oEvent);
            break;
        
        case 40: //down arrow
            if (!this.layer.active)
            {
                this.layer.active = true;     
                this.showSuggestionElement();    
            } 
            this.nextSuggestion(oEvent);
            break;
            
        case 27: // esc: Masque l'autosuggestion
            this.layer.active = false;
            this.showSuggestionElement();
            break;
    
        case 13: //enter
        
            // On empeche la validation du formulaire
            if (this.form)
            {
                this.defaultSubmit = this.form.onsubmit;
                this.form.onsubmit = function ()
                {
                    return false;
                };        
            }
        
            // Sélection de la suggestion
            var link = (this.cur < 0 || !this.suggestionElements) ? null : this.suggestionElements[this.cur];
            this.handleClick(link, oEvent);
            
            return false;
            break;
            
        //case 9: // tab <= Problème avec les pseudos qui ne sont pas encore dans la base.
    }
};

/**
 * Handles keyup events.
 * @scope private
 * @param oEvent The event object for the keyup event.
 */
AutoSuggestControl.prototype.handleKeyUp = function (oEvent /*:Event*/) {
    var iKeyCode = oEvent.keyCode;
    if (iKeyCode == 27 || iKeyCode == 38 || iKeyCode == 40 || iKeyCode == 39)
        return;
     
    // On Réactive la validation du formulaire
    if (iKeyCode == 13)
    {
        if (this.form)
        {
            this.form.onsubmit = this.defaultSubmit;
        }
        return false;
    }
    
    this.cur = -1;
    this.defaultValue = this.textbox.value;
    
    this.provider.requestSuggestions(this);    
};

/**
 * Shows the suggestion dropdown.
 * @scope private
 */
AutoSuggestControl.prototype.showSuggestionElement = function()
{
    this.layer.style.display = (!this.layer.active) ? "none" : "block";
    if (this.iframe)
    {
        this.iframe.style.height = this.layer.offsetHeight;
        this.iframe.style.width = this.layer.offsetWidth;
        this.iframe.style.display = this.layer.style.display;
    }
};

/**
 * Highlights the given node in the suggestions dropdown.
 * @scope private
 * @param oSuggestionNode The node representing a suggestion in the dropdown.
 */
AutoSuggestControl.prototype.highlightSuggestion = function (indice, oEvent) {
    var len = this.suggestionElements.length;    
    if (!len)
    {
        return false;
    }
    
    var indice = (indice < -1) ? len-1 : indice;  
    if (indice >= 0 && indice < len)
    {
        this.suggestionElements[indice].onmouseover(oEvent);
        this.textbox.value = this.suggestionElements[indice].title;
    }
    
    // Bornes: on sort des résultats
    else
    {
        this.suggestionElements[this.cur].onmouseout(oEvent);
        this.cur = -1;
        this.textbox.value = this.defaultValue;
    }
};

/**
 * Initializes the textbox with event handlers for
 * auto suggest functionality.
 * @scope private
 */
AutoSuggestControl.prototype.init = function () {

    //save a reference to this object
    var oThis = this;
    
    // assign CACHE
    this.setCache(this.search.typeAutosuggested);
    
    this.textbox.onkeyup = function (oEvent) {
        oThis.handleKeyUp(oEvent || window.event);
    };

    this.textbox.onkeydown = function (oEvent) {
        oThis.handleKeyDown(oEvent || window.event);
    };
    
    // Affiche/Masque l'autosuggestion
    this.textbox.onblur = function () {
        if (oThis.cur < 0 || !hasClass(oThis.suggestionElements[oThis.cur], "current"))
        {
            oThis.layer.active = false;
            oThis.showSuggestionElement();
        }
    };
    
    /* 
    Hack qui permet de rester appuyer sur la fleche du haut et du bas 
    et de naviguer ainsi dans l'autosuggest 
    */
    if (!document.all)
    {
        this.textbox.onkeypress = this.textbox.onkeydown;
        this.textbox.onkeydown = null;
    }

    //create the suggestions dropdown
    this.createDropDown();
};
/**
 * Highlights the next suggestion in the dropdown and
 * places the suggestion into the textbox.
 * @scope private
 */
AutoSuggestControl.prototype.nextSuggestion = function (oEvent /*:Event*/) {
    this.highlightSuggestion(this.cur + 1, oEvent);
};

/**
 * Highlights the previous suggestion in the dropdown and
 * places the suggestion into the textbox.
 * @scope private
 */
AutoSuggestControl.prototype.previousSuggestion = function (oEvent /*:Event*/) {
    this.highlightSuggestion(this.cur - 1, oEvent);
};

/**
 * Selects a range of text in the textbox.
 * @scope public
 * @param iStart The start index (base 0) of the selection.
 * @param iLength The number of characters to select.
 */
AutoSuggestControl.prototype.selectRange = function (iStart /*:int*/, iLength /*:int*/) {

    //use text ranges for Internet Explorer
    if (this.textbox.createTextRange) {
        var oRange = this.textbox.createTextRange();
        oRange.moveStart("character", iStart);
        oRange.moveEnd("character", iLength - this.textbox.value.length);
        oRange.select();

    //use setSelectionRange() for Mozilla
    } else if (this.textbox.setSelectionRange) {
        this.textbox.setSelectionRange(iStart, iLength);
    }

    //set focus back to the textbox
    this.textbox.focus();
};
 
/*
 * Catch the results from AjaxRequest
 * @scope private
 * @param result the ajaxResponseDocument
*/                
AutoSuggestControl.prototype.catchNodes = function (result) 
{
    if (!result)
    {
        return false;
    }    
    result = result.replace(/[\t\r\n\v\f]/gi, '');
    var tab = [];
    
    // Si le résultat est du code HTML en format texte,
    // on considére que chaque réponse est séparée par un commentaire vide
    var res = (!this.search.html) ? result.getElementsByTagName("n") : result.split("<!---->");
    var len = res.length;
    for (var i=0; i<len; i++)
    {
        if (res[i].replace(/[ ]/gi, '').length)
        {
            tab.push(res[i]);
        }
    }
    return tab;
};
    
/*
 * fill the suggestion elm, with the resultsNode
 * @scope private
 * @param elm The DOM elm which list the results
 * @param node The result node from ajaxRequest
*/
AutoSuggestControl.prototype.fillSuggestions = function (elm /*:NODE*/,
                                                        node /*:NODE*/) {    
    if (!elm || !node)
    {
        return false;
    }
    elm.value = node;
    elm.appendChild(document.createTextNode(node));
    
    return false;
};

/**
 * Builds the suggestion layer contents, moves it into position,
 * and displays the layer.
 * @scope private
 * @param aSuggestions An array of suggestions for the control.
 */
AutoSuggestControl.prototype.setAutosuggestElement = function (aSuggestions /*:Array*/) 
{
    var oDiv = null;
    this.layer.innerHTML = "";  //clear contents of the layer
    this.cur = -1;
    
    // FIXME: dans l'idéal (récupération du résultat en responseXML)
    // On ne ferait qu'une boucle: création de l'élèment DOM + son comportement
    var len = aSuggestions.length;
    for (var i=0; i<len; i++)
    {
        var suggestion = aSuggestions[i];
        
        // On génére l'HTML (résultat = contenu texte)
        if (!this.search.html)
        {
            oDiv = document.createElement("li");
            this.fillSuggestions(oDiv, suggestion);
            this.layer.appendChild(oDiv);
            continue;
        }
        
        // On insére l'HTML
        this.layer.innerHTML += suggestion;
    }
    
    // Comportements des suggestions
    var oThis = this;
    this.suggestionElements = this.layer.getElementsByTagName("li");
    var len = this.suggestionElements.length;
    for (var i=0; i<len; i++)
    {        
        var suggestion = this.suggestionElements[i];
        suggestion.cur = i;
        
        suggestion.onmouseup = function(e) {
            oThis.handleClick(this, e || window.event);
            return false;
        };
        suggestion.onmouseover = function(e) {
            oThis.handleMouseover(this, e || window.event);
        };
        suggestion.onmouseout = function(e) {
            return oThis.handleMouseout(this, e || window.event)
        };
    }
    
    // Positionnement de l'autosuggestion
    var left = this.getLeft();
    if (typeof left != "undefined")
    {
        this.layer.style.left = left + "px";
        if (this.iframe)
        {
            this.iframe.style.left = this.layer.style.left;
        }
    }
    
    var top = this.getTop();
    if (typeof top != "undefined")
    {
        this.layer.style.top = top + "px";
        if (this.iframe)
        {
            this.iframe.style.top = this.layer.style.top;
        }
    }
    
    // Affiche l'autosuggestion globale
    this.layer.active = len;
    this.showSuggestionElement();
    
    return;
};

AutoSuggestControl.prototype.handleClick = function(link, oEvent)
{
    if (this.suggestionElements && this.cur >= 0)
    {    
        var suggestion = this.suggestionElements[this.cur];
        if (typeof suggestion != "undefined")
        {
            this.textbox.value = suggestion.title;
        }
    }
    
    // Masque l'autosuggestion
    this.layer.active = false;
    this.showSuggestionElement();
};

/*
    1. Masquer l'ancienne suggestion active
    2. Rendre active la nouvelle suggestion
*/
AutoSuggestControl.prototype.handleMouseover = function(suggestion, e)
{
    // Contenu inactif
    if (this.cur >= 0 && this.cur < this.suggestionElements.length)
    {
        this.suggestionElements[this.cur].onmouseout(e);
    }

    // Contenu actif
    addClass(suggestion, "current");
    this.cur = suggestion.cur;
    this.layer.active = true;
};

AutoSuggestControl.prototype.handleMouseout = function(suggestion, e)
{
    removeClass(suggestion, "current");
    return false;
}; 

AutoSuggestControl.prototype.setCache = function(keys /*:Array*/)
{    
    if (!keys)
    {
        this.cache = false;
        return false;
    }    
    
    this.cache = {};
    for (var i=0; i<keys.length; i++)
    {
        this.cache[keys[i].type] = new Array();
    }
    return false;
}

/**
 * Gets the left coordinate of the textbox.
 * @scope private
 * @return The left coordinate of the textbox in pixels.
 */
AutoSuggestControl.prototype.getLeft = function () /*:int*/ {

    var oNode = this.textbox;
    
    // Do not set the property if the Suggestion is written 
    // in the same container as the 'textbox'
    if (oNode.parentNode == this.container)
    {
        return;
    }
    
    var iLeft = 0;
    while (oNode.offsetParent && oNode != this.container) {
        iLeft += oNode.offsetLeft;
        oNode = oNode.offsetParent;
    }
    return iLeft;
};

/**
 * Gets the top coordinate of the textbox.
 * @scope private
 * @return The top coordinate of the textbox in pixels.
 */
AutoSuggestControl.prototype.getTop = function () /*:int*/ {

    var oNode = this.textbox;
    
    // Do not set the property if the Suggestion is written 
    // in the same container as the 'textbox'
    if (oNode.parentNode == this.container)
    {
        return;
    }
    
    var iTop = 0;
    while (oNode.offsetParent) {
        iTop += oNode.offsetTop;
        oNode = oNode.offsetParent;
    }

    return iTop + this.textbox.offsetHeight - 1;
};


/**
 * Search
 * @class
 * @scope public
 */
function Search(str, paramSuggestions, isHTML)
{
    if ((!paramSuggestions || !paramSuggestions.length) || !str)
    {
        return false;
    }    
    
    // 1. stocker ttes les infos concernant chaque Search/Autosuggestion
    //this.valAutosuggest = (paramSuggestions) ? paramSuggestions : false;
    if (paramSuggestions && paramSuggestions.length)
    {
        this.typeAutosuggested = [];
        for (var i=0; i<paramSuggestions.length; i++)
        {
            this.typeAutosuggested.push(paramSuggestions[i]);
        }
    }
    if (!this.typeAutosuggested)
    {
        return false;
    }
    
    // 2 traiter la recherche en cours, en prenant en compte 'str' = type au chargement de la page
    this.setType(str);
    
    this.html = isHTML || false;
}

/*
 * return if oSearch accept Autosuggestion
 * @scope private
 */
Search.prototype.isAutosuggest = function()
{
    return this.getAutosuggestByType();
}

Search.prototype.getAutosuggestByType = function()
{
    var tmp = this.typeAutosuggested;
    for (var i=0; i<tmp.length; i++)
    {
        if (tmp[i].type && tmp[i].type == this.type)
        {
            return tmp[i];
        }
    }
    return false;
}

/*
 * concatains Parameters with their values in a string
 * @scope private
 * @param name The name of the parameters
 * @param str The value of the parameters
 */
Search.prototype.getParam = function(param)
{
    if (!param)
    {
        return false;
    }
    
    // add '&' if the url ever contains paramters
    var tmp = "";
    var len = this.url.length;
    if (this.url[len-1] != "&")
    {
        tmp += "&";
    }
    
    // encode parameters
    for (key in param)
    {
        var value = encodeURIComponent(param[key]);
        if (value)
        {
            tmp += key  + "=" + value ;
        }
    }
    // FIX ME: parametres propres à la recherche
    // mettre le param direct dans l'url
    if (this.type == 'profiles')
        tmp += '&code_search=' + this.type;
    
    return tmp;
}

/*
 * Update oSearch Type property
 * @scope private
 * @param val The new value for oSearch.type
 */
Search.prototype.setType = function(val)
{
    if (!val || this.type == val )
        return false;
    
    // change TYPE
    this.type = val;
    
    // change URL & minLength
    this.setParamsForType();
}

/*
 * Set URL for AjaxRequest (depends of oSeach.type)
 * Set min length in textbox for AjaxRequest (depends of oSeach.type)
 * @scope private
 */
Search.prototype.setParamsForType = function()
{
    var tmp = this.getAutosuggestByType();
    if (tmp)
    {
        this.url = tmp.url;
        this.minlength = tmp.minlength;
    }    
    return false;
}

/**
 * Simple Dummy Cache for suggestions.
 * @class
 * @scope public
 */
function SimpleDummyCache(str)
{
    this.str = str;
    this.results = new Array();
}

SimpleDummyCache.prototype.toString = function()
{
    return this.str + ' -> \n{' + this.results + '}\n';
}

/**
 * Provides suggestions.
 * @class
 * @scope public
 */
function RemoteStateSuggestions()
{    
    if (typeof XMLHttpRequest != 'undefined')
        this.http = new XMLHttpRequest();
    else if (typeof ActiveXObject != 'undefined')
        this.http = new ActiveXObject('MSXML2.XmlHttp');
    else
        this.http = false;
}

/**
 * Request suggestions for the given autosuggest control.
 * @scope protected
 * @param oAutoSuggestControl The autosuggest control to provide suggestions for.
 */

RemoteStateSuggestions.prototype.requestSuggestions = function (oAutoSuggestControl /*:AutoSuggestControl*/)
{
    var oHttp  = this.http;
    var oSearch = oAutoSuggestControl.search;
    
    // Step1: On annule l'autosuggest (on masque)
    if (!oHttp || !oSearch || oAutoSuggestControl.textbox.value.length < oSearch.minlength || !oSearch.isAutosuggest())
    {
        oAutoSuggestControl.setAutosuggestElement(Array());
        return false;
    }
    
    // Step2: if there is already a live request, cancel it
    if (oHttp.readyState != 0)
    {
        oHttp.abort();
    }
    
    // Step3: Recupération du cache 
    var oCache = oAutoSuggestControl.cache[oSearch.type];  // cache value
    var len = oCache.length;
    var str = encodeURIComponent(oAutoSuggestControl.textbox.value);
    for (var i = 0; i < len; i++)
    {
        if (oCache[i].str == str)
        {
            oAutoSuggestControl.setAutosuggestElement(oCache[i].results);
            return true;
        }
    }
    
    // Step4: Requete AJAX
    var oCache = oAutoSuggestControl.cache[oSearch.type];
    var len = 0;
    
    oHttp.open('get', oSearch.url + oSearch.getParam({"n": str}) , true);
	oHttp.setRequestHeader("Content-Type", "text/plain;charset=ISO-8859-1");    
    oHttp.onreadystatechange = function ()
    {
        if (oHttp.readyState == 4)
        {
            var tbl = oAutoSuggestControl.catchNodes((!oSearch.html) ? oHttp.responseXML: oHttp.responseText); // new Nodes            
            if (tbl && tbl.length)
            {                
                // create a SimpleDummyCache and add it at the end of our cache Array
                var co  = new SimpleDummyCache(str);
                co.results = tbl;
                oCache.push(co);

                // remove the oldest SimpleDummyCache in our cache Array if necessary
                // to keep our cache small
                if (oCache.length > 42)
                    oCache.shift();
            }
            
            // provide suggestions to the control
            oAutoSuggestControl.setAutosuggestElement(tbl);      
        }
    };
    oHttp.send(null);

    return true;
}