/*==============================================================================
 * Ce fichier contient la definition du controlleur de formulaire. La creattion des des handler et l'association aux evenements de tous les controles du formulaire est genere par cet objet
*/

IAD_PageController.FormHandler = Class.create(
{
    initialize: function (pc, params)
    {
        /**
        * Contient tous les parametre passes au formulaire pour son creation et son fonctionnement.
        */
        var _params = params;
        /**
        * Retourne l'identifiant du formulaire associe a ce controleur.
        */
        this.getId = function ()
        {
            return _params.formId;
        }
        /**
        * Le controleur de la page. Il initialise tous les controleur, en particulier celui-ci.
        */
        var _pc = pc;
        this.getPageController = function ()
        {
            return _pc;
        }

        /**
        * Le formulaire a controler
        */
        var _form = getElt(_params.formId, true);
        this.getForm = function ()
        {
            return _form;
        }
        this.setAction = function(a)
        {
            _form.action = a;
        }
        /**
        * Soumet son formulaire
        */
        this.submitForm = function ()
        {
            return _form.submit();
        }
        /**
        * Url a utiliser lors des requete ajax. Elle sera eventuellement completee avant de lancer la requete.
        */
        var _url = _params.url ? _params.url : "?";
        this.getUrl = function ()
        {
            return _url;
        }
        this.setUrl = function (u)
        {
            _url = u;
        }

        /**
        * Controles dont le contenu  sera utilise pour completer l'url. La methode getValue des handlers de ces controles sera utilisee pour recuperer la valeur. Ainsi un controle pourra fournir des valeurs defferentes pour des evenement different meme si son etat est le meme au momenet de ces evenements.
        Ces controles sont stockes sous la form id=>control
        */
        var _dataControls = $H({});
        this.getDataControl = function (id)
        {
            if(!id)
            {
                return _dataControls;
            }
            return _dataControls.get(id);
        }
        this.addDataControl = function (id, e)
        {
            _dataControls.set(id, e);
        }
        this.removeDataControl = function(id)
        {
            _dataControls.unset(id);
        }

        /**
        * Controles de contenu. Ce sont en general des controles contenu dans une resulat AJAX (comme les icones MODIFIER ou SUPPRIMER du tableau des indicateurs disponibles). Cela laisse la possibilite de supprimer les handler associes a ces controles au moment ou une autre requete AJAX ramene un autre contenu
        */
        var _contentControls = {};
        this.getContentControl = function (id)
        {
            if(!id)
            {
                return _contentControls;
            }
            return _contentControls[id];
        }
        this.addContentControl = function (id, e)
        {
            _contentControls[id] = e;
        }
        this.removeContentControl = function(id)
        {
            delete(_contentControls[id]);
        }
        /**
        * Controle qui contiendra la valeur du submitted by. Cela donne un moyen simple de determiner la raison de la soumission d'un formulaire et de prendre ainsi la bonne decision quand a la page a fournir par le serveur
        */
        var _submittedByControl = getElt(_params.submittedBy, true);
        _submittedByControl.value = null;
        this.getSubmittedByControl = function ()
        {
            return _submittedByControl;
        }

        /*Lorsque l'on soumet le formulaire pour cause de mise a jour de donnee, document, ou indicateur
        le submittedBy contiendre cette constante et l'identifiant de la donnee sera rangée dans le hidden
        input dont l'idenfiant est celui de cette constante. Cette constantant permet d'eviter
        d fournir cette information pour chaque page
        */
        var _dataIdentControl = _params.dataIdent ? getElt(_params.dataIdent, true) : null;
        this.getDataIdentControl = function ()
        {
            return _dataIdentControl;
        }

        var _ajaxRequestHandler = _params.requestHandler ? (eval("new IAD_Ajax."+_params.requestHandler+"Handler(pc)")) : pc.getAjaxRequesHandler();
        this.getAjaxRequesHandler = function ()
        {
            return _ajaxRequestHandler;
        }
        this.setAjaxRequestHandler = function (h)
        {
            _ajaxRequestHandler = h;
        }
        /**
        * Cette sera appelee par le PageController a apres la creation du formulaire. Si son parametre load vaut true alors elle execute une requete AJAX pour initialiser le contenu du formulaire.
        */
        this.load = function(evt)
        {
            if(!_params.load)
            {
                return;
            }
            if(Object.isUndefined(evt))
            {
                evt = {type:"load"};
            }
            var lp = Object.toQueryString(_params.onloadParams);
            //alert("FormHandler.load, lp="+lp);
            lp = lp ? ("&"+lp) : "";
            this.getAjaxRequesHandler().handleRequest(this.getUrl()+"&target=load"+lp, this.getDataControl(), evt);
        }
    }
});

/**
 *Cette fonction doit etre appelee avant toute soumission. Cela permet de centraliser les controles
 *avant soumission. Par exemple si une requete AJAX est en cours on doit attendre sa reponse,
 *ou si on a deja demandé une soumission on ne doit pas soumetre une fois supplémentaire
 *on doit attendre. TODO: implement checking before submitting
 */
IAD_PageController.FormHandler.addMethods
(
{
    submitBy: function (val)
    {
        this.getSubmittedByControl().value = val;
        return true;
    }
    ,


    /**
    * Cette methode ajoute le handler de l'evement eventtype associe au control d'identifiant id au tableau qui stocke les handler afin de pouvoir les recuperer par controle et type de'evenement. Un seul handler est enregistre par control et evenement, un duplicata ecrase le precedent.
    */

    addElementHandler: function (id, eventtype, handler)
    {
        this.getPageController().addElementHandler(id, eventtype, handler);
        if(handler.setFormHandler)
        {
            handler.setFormHandler(this);
        }else
        {
            var that = this;
            handler.getFormHandler = function(){return that};
        }
        return handler;
    }
    ,

    /**
    * Cette methode retourne le handler de l'evement eventtype associe au control d'identifiant id. Si eventtype vaut * le premier handler associe au control id est retourne (peu importe son type d'evenement associe)
    */
    getElementHandler: function (id, eventtype, raiseExceptionFlag)
    {
        return this.getPageController().getElementHandler(id, eventtype, raiseExceptionFlag);
    }
    ,

    /**
    * Cette methode propose un moyen standard de faire les requete AJAX pour les controles du formulaire.
    */
    handleRequest: function (handler, evt, dataControls)
    {
        dataControls = (typeof dataControls == "undefined") ? this.getDataControl() : dataControls;
        var elt = handler.getElement();
        var url = Object.isUndefined(elt.url) ? this.getUrl() : elt.url;
        var tg = Object.isUndefined(elt.target) ? elt.id : elt.target;
        this.getAjaxRequesHandler().handleRequest(url + "&target=" + tg, dataControls, evt);
    }
});