/* copyright 2003-2011 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

 */

cw.ajax = new Namespace('cw.ajax');

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) {

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

            callback.apply(null, [this._error, this._req]);

        }

        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?';

jQuery.extend(cw.ajax, {

    /* variant of jquery evalScript with cache: true in ajax call */

    _evalscript: function ( i, elem ) {

       if ( elem.src ) {

           jQuery.ajax({

               url: elem.src,

               async: false,

               cache: true,

               dataType: "script"

           });

       } else {

           jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );

       }

       if ( elem.parentNode ) {

           elem.parentNode.removeChild( elem );

       }

    },

    evalscripts: function ( scripts ) {

        if ( scripts.length ) {

            jQuery.each(scripts, cw.ajax._evalscript);

        }

    },

    /**

     * returns true if `url` is a mod_concat-like url

     * (e.g. http://..../data??resource1.js,resource2.js)

     */

    _modconcatLikeUrl: function(url) {

        var base = baseuri();

        if (!base.endswith('/')) { base += '/'; }

        var modconcat_rgx = new RegExp('(' + base + 'data/([a-z0-9]+/)?)\\?\\?(.+)');

        return modconcat_rgx.exec(url);

    },

    /**

     * decomposes a mod_concat-like url into its corresponding list of

     * resources' urls

     * >>> _listResources('http://foo.com/data/??a.js,b.js,c.js')

     * ['http://foo.com/data/a.js', 'http://foo.com/data/b.js', 'http://foo.com/data/c.js']

     */

    _listResources: function(src) {

        var resources = [];

        var groups = cw.ajax._modconcatLikeUrl(src);

        if (groups == null) {

            resources.push(src);

        } else {

            var dataurl = groups[1];

            $.each(cw.utils.lastOf(groups).split(','),

                 function() {

                     resources.push(dataurl + this);

                 }

            );

        }

        return resources;

    }

});

//============= 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) {

            // tab1.push.apply(tab1, tab2) <=> tab1 += tab2 (python-wise)

            loaded.push.apply(loaded, cw.ajax._listResources(this.getAttribute(srcattr)));

        });

    } else {

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

    }

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

        var $srcnode = jQuery(this);

        var url = $srcnode.attr(srcattr);

        if (url) {

            /* special handling of <script> tags: script nodes appended by jquery

             * use uncached ajax calls and do not appear in the DOM

             * (See comments in response to Syt on // http://api.jquery.com/append/),

             * which cause undesired duplicated load in our case. We now handle

             * a list of already loaded resources, since bare DOM api gives bugs with the

             * server-response event, and we lose control on when the

             * script is loaded (jQuery loads it immediately). */

            var resources = cw.ajax._listResources(url);

            var missingResources = $.grep(resources, function(resource) {

                return $.inArray(resource, loaded) == -1;

            });

            loaded.push.apply(loaded, missingResources);

            if (missingResources.length == 1) {

                // only one resource missing: build a node with a single resource url

                // (maybe the browser has it in cache already)

                $srcnode.attr(srcattr, missingResources[0]);

            } else if (missingResources.length > 1) {

                // several resources missing: build a node with a concatenated

                // resources url

                var dataurl = cw.ajax._modconcatLikeUrl(url)[1];

                var missing_path = $.map(missingResources, function(resource) {

                    return resource.substring(dataurl.length);

                });

                $srcnode.attr(srcattr, dataurl + '??' + missing_path.join(','));

            }

            // === will work if both arguments are of the same type

            if ( $srcnode.attr('type') === 'text/javascript' ) {

                cw.ajax.evalscripts($srcnode);

            } else {

                $srcnode.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(cw).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]);

        }