/* copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

 * contact http://www.logilab.fr/ -- mailto:contact@logilab.fr

 *

 * This file is part of CubicWeb.

 *

 * CubicWeb is free software: you can redistribute it and/or modify it under the

 * terms of the GNU Lesser General Public License as published by the Free

 * Software Foundation, either version 2.1 of the License, or (at your option)

 * any later version.

 *

 * CubicWeb is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more

 * details.

 *

 * You should have received a copy of the GNU Lesser General Public License along

 * with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

 */

/**

 * .. function:: Deferred

 *

 * dummy ultra minimalist implementation of deferred for jQuery

 */

function Deferred() {

    this.__init__(this);

}

jQuery.extend(Deferred.prototype, {

    __init__: function() {

        this._onSuccess = [];

        this._onFailure = [];

        this._req = null;

        this._result = null;

        this._error = null;

    },

    addCallback: function(callback) {

        if ((this._req.readyState == 4) && this._result) {

            var args = [this._result, this._req];

            jQuery.merge(args, cw.utils.sliceList(arguments, 1));

            callback.apply(null, args);

        }

        else {

            this._onSuccess.push([callback, cw.utils.sliceList(arguments, 1)]);

        }

        return this;

    },

    addErrback: function(callback) {

        }

        else {

            this._onFailure.push([callback, cw.utils.sliceList(arguments, 1)]);

        }

        return this;

    },

    success: function(result) {

        this._result = result;

        try {

            for (var i = 0; i < this._onSuccess.length; i++) {

                var callback = this._onSuccess[i][0];

                var args = [result, this._req];

                jQuery.merge(args, this._onSuccess[i][1]);

                callback.apply(null, args);

            }

        } catch(error) {

            this.error(this.xhr, null, error);

        }

    },

    error: function(xhr, status, error) {

        this._error = error;

        for (var i = 0; i < this._onFailure.length; i++) {

            var callback = this._onFailure[i][0];

            var args = [error, this._req];

            jQuery.merge(args, this._onFailure[i][1]);

            callback.apply(null, args);

        }

    }

});

var JSON_BASE_URL = baseuri() + 'json?';

//============= utility function handling remote calls responses. ==============//

function _loadAjaxHtmlHead($node, $head, tag, srcattr) {

    var jqtagfilter = tag + '[' + srcattr + ']';

    if (cw['loaded_'+srcattr] === undefined) {

        cw['loaded_'+srcattr] = [];

        var loaded = cw['loaded_'+srcattr];

        jQuery('head ' + jqtagfilter).each(function(i) {

                   loaded.push(this.getAttribute(srcattr));

               });

    } else {

        var loaded = cw['loaded_'+srcattr];

    }

    $node.find(tag).each(function(i) {

        var url = this.getAttribute(srcattr);

        if (url) {

            if (jQuery.inArray(url, loaded) == -1) {

                // take care to <script> tags: jQuery append method script nodes

                // don't appears in the DOM (See comments on

                // http://api.jquery.com/append/), which cause undesired

                // duplicated load in our case. After trying to use bare DOM api

                // to avoid this, we switched to handle a list of already loaded

                // stuff ourselves, since bare DOM api gives bug with the

                // server-response event, since we loose control on when the

                // script is loaded (jQuery load it immediatly).

                loaded.push(url);

                jQuery(this).appendTo($head);

            }

        } else {

            jQuery(this).appendTo($head);

        }

    });

    $node.find(jqtagfilter).remove();

}

/**

 * .. function:: function loadAjaxHtmlHead(response)

 *

 * inspect dom response (as returned by getDomFromResponse), search for

 * a <div class="ajaxHtmlHead"> node and put its content into the real

 * document's head.

 * This enables dynamic css and js loading and is used by replacePageChunk

 */

function loadAjaxHtmlHead(response) {

    var $head = jQuery('head');

    var $responseHead = jQuery(response).find('div.ajaxHtmlHead');

    // no ajaxHtmlHead found, no processing required

    if (!$responseHead.length) {

        return response;

    }

    _loadAjaxHtmlHead($responseHead, $head, 'script', 'src');

    _loadAjaxHtmlHead($responseHead, $head, 'link', 'href');

    // add any remaining children (e.g. meta)

    $responseHead.children().appendTo($head);

    // remove original container, which is now empty

    $responseHead.remove();

    // if there was only one actual node in the reponse besides

    // the ajaxHtmlHead, then remove the wrapper created by

    // getDomFromResponse() and return this single element

    // For instance :

    // 1/ CW returned the following content :

    //    <div>the-actual-content</div><div class="ajaxHtmlHead">...</div>

    // 2/ getDomFromReponse() wrapped this into a single DIV to hold everything

    //    in one, unique, dom element

    // 3/ now that we've removed the ajaxHtmlHead div, the only

    //    node left in the wrapper if the 'real' node built by the view,

    //    we can safely return this node. Otherwise, the view itself

    //    returned several 'root' nodes and we need to keep the wrapper

    //    created by getDomFromResponse()

    if (response.childNodes.length == 1 && response.getAttribute('cubicweb:type') == 'cwResponseWrapper') {

        return response.firstChild;

    }

    return response;

}

function _postAjaxLoad(node) {

    // find sortable tables if there are some

    if (typeof(Sortable) != 'undefined') {

        Sortable.sortTables(node);

    }

    // find textareas and wrap them if there are some

    if (typeof(FCKeditor) != 'undefined') {

        buildWysiwygEditors();

    }

    if (typeof initFacetBoxEvents != 'undefined') {

        initFacetBoxEvents(node);

    }

    if (typeof buildWidgets != 'undefined') {

        buildWidgets(node);

    }

    if (typeof roundedCorners != 'undefined') {

        roundedCorners(node);

    }

    if (typeof setFormsTarget != 'undefined') {

        setFormsTarget(node);

    }

    _loadDynamicFragments(node);

    // XXX [3.7] jQuery.one is now used instead jQuery.bind,

    // jquery.treeview.js can be unpatched accordingly.

    jQuery(CubicWeb).trigger('server-response', [true, node]);

    jQuery(node).trigger('server-response', [true, node]);

}

function remoteCallFailed(err, req) {

    cw.log(err);

    if (req.status == 500) {

        updateMessage(err);

    } else {

        updateMessage(_("an error occurred while processing your request"));

    }

}

//============= base AJAX functions to make remote calls =====================//

/**

 * .. function:: ajaxFuncArgs(fname, form, *args)

 *

 * extend `form` parameters to call the js_`fname` function of the json

 * controller with `args` arguments.

 */

function ajaxFuncArgs(fname, form /* ... */) {

    form = form || {};

    $.extend(form, {

        'fname': fname,

        'pageid': pageid,

        'arg': $.map(cw.utils.sliceList(arguments, 2), jQuery.toJSON)

    });

    return form;

}

/**

 * .. function:: loadxhtml(url, form, reqtype='get', mode='replace', cursor=true)

 *

 * build url given by absolute or relative `url` and `form` parameters

 * (dictionary), fetch it using `reqtype` method, then evaluate the

 * returned XHTML and insert it according to `mode` in the

 * document. Possible modes are :

 *

 *    - 'replace' to replace the node's content with the generated HTML

 *    - 'swap' to replace the node itself with the generated HTML

 *    - 'append' to append the generated HTML to the node's content

 *

 * If `cursor`, turn mouse cursor into 'progress' cursor until the remote call

 * is back.

 */

jQuery.fn.loadxhtml = function(url, form, reqtype, mode, cursor) {

    if (this.size() > 1) {

        cw.log('loadxhtml was called with more than one element');

    }

    var callback = null;

    if (form && form.callback) {

        cw.log('[3.9] callback given through form.callback is deprecated, add ' + 'callback on the defered');

        callback = form.callback;

        delete form.callback;

    }

    var node = this.get(0); // only consider the first element

    if (cursor) {

        setProgressCursor();

    }

    var d = loadRemote(url, form, reqtype);

    d.addCallback(function(response) {

        var domnode = getDomFromResponse(response);

        domnode = loadAjaxHtmlHead(domnode);

        mode = mode || 'replace';

        // make sure the component is visible

        $(node).removeClass("hidden");

        if (mode == 'swap') {

            var origId = node.id;

            node = cw.swapDOM(node, domnode);

            if (!node.id) {

                node.id = origId;

            }

        } else if (mode == 'replace') {

            jQuery(node).empty().append(domnode);

        } else if (mode == 'append') {

            jQuery(node).append(domnode);

        }

        _postAjaxLoad(node);

        while (jQuery.isFunction(callback)) {

            callback = callback.apply(this, [domnode]);

        }

    });

    d.addErrback(remoteCallFailed);

    if (cursor) {

        d.addCallback(resetCursor);

        d.addErrback(resetCursor);

    }

    return d;

}

/**

 * .. function:: loadRemote(url, form, reqtype='GET', sync=false)

 *

 * Asynchronously (unless `async` argument is set to false) load an url or path

 * and return a deferred whose callbacks args are decoded according to the

 * Content-Type response header. `form` should be additional form params

 * dictionary, `reqtype` the HTTP request type (get 'GET' or 'POST').

 */

function loadRemote(url, form, reqtype, sync) {

    if (!url.startswith(baseuri())) {

        url = baseuri() + url;

    }

    if (!sync) {

        var deferred = new Deferred();

        jQuery.ajax({

            url: url,

            type: (reqtype || 'GET').toUpperCase(),

            data: form,

            async: true,

            beforeSend: function(xhr) {

                deferred._req = xhr;

            },

            success: function(data, status) {

                if (deferred._req.getResponseHeader("content-type") == 'application/json') {

                    data = cw.evalJSON(data);

                }

                deferred.success(data);

            },

            error: function(xhr, status, error) {

                try {

                    if (xhr.status == 500) {

                        var reason_dict = cw.evalJSON(xhr.responseText);

                        deferred.error(xhr, status, reason_dict['reason']);

                        return;

                    }

                } catch(exc) {

                    cw.log('error with server side error report:' + exc);

                }

                deferred.error(xhr, status, null);

            }

        });

        return deferred;

    } else {

        var result = jQuery.ajax({

            url: url,

            type: (reqtype || 'GET').toUpperCase(),

            data: form,

            async: false

        });

        // check result.responseText instead of result to avoid error encountered with IE

        if (result.responseText) {

            // XXX no good reason to force json here,

            // it should depends on request content-type

            result = cw.evalJSON(result.responseText);

        }

        return result;

    }

}

//============= higher level AJAX functions using remote calls ===============//

/**

 * .. function:: _(message)

 *

 * emulation of gettext's _ shortcut

 */

function _(message) {

    return loadRemote('json', ajaxFuncArgs('i18n', null, [message]), 'GET', true)[0];

}

/**

 * .. function:: _loadDynamicFragments(node)

 *

 * finds each dynamic fragment in the page and executes the

 * the associated RQL to build them (Async call)

 */

function _loadDynamicFragments(node) {