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

       var src = elem.getAttribute('src');

       if (src) {

           jQuery.ajax({

               url: 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;

    },

    _buildMissingResourcesUrl: function(url, loadedResources) {

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

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

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

        });

        cw.utils.extend(loadedResources, missingResources);

        var missingResourceUrl = null;

        if (missingResources.length == 1) {

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

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

            missingResourceUrl = 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);

            });

            missingResourceUrl = dataurl + '??' + missing_path.join(',');

        }

        return missingResourceUrl;

    },

    _loadAjaxStylesheets: function($responseHead, $head) {

        $responseHead.find('link[href]').each(function(i) {

            var $srcnode = $(this);

            var url = $srcnode.attr('href');

            if (url) {

                var missingStylesheetsUrl = cw.ajax._buildMissingResourcesUrl(url, cw.loaded_links);

                // compute concat-like url for missing resources and append <link>

                // element to $head

                if (missingStylesheetsUrl) {

                    $srcnode.attr('href', missingStylesheetsUrl);

                    $srcnode.appendTo($head);

                }

            }

        });

        $responseHead.find('link[href]').remove();

    },

    _loadAjaxScripts: function($responseHead, $head) {

        $responseHead.find('pre.script').each(function(i) {

            var $srcnode = $(this);

            var url = $srcnode.attr('src');

            if (url) {

                var missingScriptsUrl = cw.ajax._buildMissingResourcesUrl(url, cw.loaded_scripts);

                if (missingScriptsUrl) {

                    $srcnode.attr('src', missingScriptsUrl);

                    /* 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). */

                    cw.ajax.evalscripts($srcnode);

                }

            } else {

                // <script> contains inlined javascript code, node content

                // must be evaluated

    	        jQuery.globalEval($srcnode.text());

    	    }

        });

        $responseHead.find('pre.script').remove();

    }

});

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

/**

 * .. 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;

    }

    cw.ajax._loadAjaxStylesheets($responseHead, $head);

    cw.ajax._loadAjaxScripts($responseHead, $head);

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

 *

 * 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 called with more than one element');

    } else if (this.size() < 1) {

        cw.log('loadxhtml called without an 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;