# copyright 2003-2014 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/>.

"""Some utilities for CubicWeb server/clients."""

from __future__ import division

__docformat__ = "restructuredtext en"

import sys

import decimal

import datetime

import random

import re

import json

from operator import itemgetter

from inspect import getargspec

from itertools import repeat

from uuid import uuid4

from warnings import warn

from threading import Lock

from urlparse import urlparse

from logging import getLogger

from logilab.mtconverter import xml_escape

from logilab.common.deprecation import deprecated

from logilab.common.date import ustrftime

_MARKER = object()

# initialize random seed from current time

random.seed()

def admincnx(appid):

    from cubicweb.cwconfig import CubicWebConfiguration

    from cubicweb.server.repository import Repository

    from cubicweb.server.utils import TasksManager

    config = CubicWebConfiguration.config_for(appid)

    login = config.default_admin_config['login']

    password = config.default_admin_config['password']

    repo = Repository(config, TasksManager())

    session = repo.new_session(login, password=password)

    return session.new_cnx()

def make_uid(key=None):

    """Return a unique identifier string.

    if specified, `key` is used to prefix the generated uid so it can be used

    for instance as a DOM id or as sql table name.

    See uuid.uuid4 documentation for the shape of the generated identifier, but

    this is basically a 32 bits hexadecimal string.

    """

    if key is None:

        return uuid4().hex

    return str(key) + uuid4().hex

def support_args(callable, *argnames):

    """return true if the callable support given argument names"""

    if isinstance(callable, type):

        callable = callable.__init__

    argspec = getargspec(callable)

    if argspec[2]:

        return True

    for argname in argnames:

        if argname not in argspec[0]:

            return False

    return True

class wrap_on_write(object):

    """ Sometimes it is convenient to NOT write some container element

    if it happens that there is nothing to be written within,

    but this cannot be known beforehand.

    Hence one can do this:

    .. sourcecode:: python

       with wrap_on_write(w, '<div class="foo">', '</div>') as wow:

           component.render_stuff(wow)

    """

    def __init__(self, w, tag, closetag=None):

        self.written = False

        self.tag = unicode(tag)

        self.closetag = closetag

        self.w = w

    def __enter__(self):

        return self

    def __call__(self, data):

        if self.written is False:

            self.w(self.tag)

            self.written = True

        self.w(data)

    def __exit__(self, exctype, value, traceback):

        if self.written is True:

            if self.closetag:

                self.w(unicode(self.closetag))

            else:

                self.w(self.tag.replace('<', '</', 1))

# use networkX instead ?

# http://networkx.lanl.gov/reference/algorithms.traversal.html#module-networkx.algorithms.traversal.astar

def transitive_closure_of(entity, rtype, _seen=None):

    """return transitive closure *for the subgraph starting from the given

    entity* (eg 'parent' entities are not included in the results)

    """

    if _seen is None:

        _seen = set()

    _seen.add(entity.eid)

    yield entity

    for child in getattr(entity, rtype):

        if child.eid in _seen:

            continue

        for subchild in transitive_closure_of(child, rtype, _seen):

            yield subchild

class SizeConstrainedList(list):

    """simple list that makes sure the list does not get bigger than a given

    size.

    when the list is full and a new element is added, the first element of the

    list is removed before appending the new one

    >>> l = SizeConstrainedList(2)

    >>> l.append(1)

    >>> l.append(2)

    >>> l

    [1, 2]

    >>> l.append(3)

    >>> l

    [2, 3]

    """

    def __init__(self, maxsize):

        self.maxsize = maxsize

    def append(self, element):

        if len(self) == self.maxsize:

            del self[0]

        super(SizeConstrainedList, self).append(element)

    def extend(self, sequence):

        super(SizeConstrainedList, self).extend(sequence)

        keepafter = len(self) - self.maxsize

        if keepafter > 0:

            del self[:keepafter]

    __iadd__ = extend

class RepeatList(object):

    """fake a list with the same element in each row"""

    __slots__ = ('_size', '_item')

    def __init__(self, size, item):

        self._size = size

        self._item = item

    def __repr__(self):

        return '<cubicweb.utils.RepeatList at %s item=%s size=%s>' % (

            id(self), self._item, self._size)

    def __len__(self):

        return self._size

    def __iter__(self):

        return repeat(self._item, self._size)

    def __getitem__(self, index):

        return self._item

    def __delitem__(self, idc):

        assert self._size > 0

        self._size -= 1

    def __getslice__(self, i, j):

        # XXX could be more efficient, but do we bother?

        return ([self._item] * self._size)[i:j]

    def __add__(self, other):

        if isinstance(other, RepeatList):

            if other._item == self._item:

                return RepeatList(self._size + other._size, self._item)

            return ([self._item] * self._size) + other[:]

        return ([self._item] * self._size) + other

    def __radd__(self, other):

        if isinstance(other, RepeatList):

            if other._item == self._item:

                return RepeatList(self._size + other._size, self._item)

            return other[:] + ([self._item] * self._size)

        return other[:] + ([self._item] * self._size)

    def __eq__(self, other):

        if isinstance(other, RepeatList):

            return other._size == self._size and other._item == self._item

        return self[:] == other

    # py3k future warning "Overriding __eq__ blocks inheritance of __hash__ in 3.x"

    # is annoying but won't go away because we don't want to hash() the repeatlist

    def pop(self, i):

        self._size -= 1

class UStringIO(list):

    """a file wrapper which automatically encode unicode string to an encoding

    specifed in the constructor

    """

    def __init__(self, tracewrites=False, *args, **kwargs):

        self.tracewrites = tracewrites

        super(UStringIO, self).__init__(*args, **kwargs)

    def __nonzero__(self):

        return True

    def write(self, value):

        assert isinstance(value, unicode), u"unicode required not %s : %s"\

                                     % (type(value).__name__, repr(value))

        if self.tracewrites:

            from traceback import format_stack

            stack = format_stack(None)[:-1]

            escaped_stack = xml_escape(json_dumps(u'\n'.join(stack)))

            escaped_html = xml_escape(value).replace('\n', '<br/>\n')

            tpl = u'<span onclick="alert(%s)">%s</span>'

            value = tpl % (escaped_stack, escaped_html)

        self.append(value)

    def getvalue(self):

        return u''.join(self)

    def __repr__(self):

        return '<%s at %#x>' % (self.__class__.__name__, id(self))

class HTMLHead(UStringIO):

    """wraps HTML header's stream

    Request objects use a HTMLHead instance to ease adding of

    javascripts and stylesheets

    """

    js_unload_code = u'''if (typeof(pageDataUnloaded) == 'undefined') {

    jQuery(window).unload(unloadPageData);

    pageDataUnloaded = true;

}'''

    script_opening = u'<script type="text/javascript">\n'

    script_closing = u'\n</script>'

    def __init__(self, req, *args, **kwargs):

        super(HTMLHead, self).__init__(*args, **kwargs)

        self.jsvars = []

        self.jsfiles = []

        self.cssfiles = []

        self.ie_cssfiles = []

        self.post_inlined_scripts = []

        self.pagedata_unload = False

        self._cw = req

        self.datadir_url = req.datadir_url

    def add_raw(self, rawheader):

        self.write(rawheader)

    def define_var(self, var, value, override=True):

        """adds a javascript var declaration / assginment in the header

        :param var: the variable name

        :param value: the variable value (as a raw python value,

                      it will be jsonized later)

        :param override: if False, don't set the variable value if the variable

                         is already defined. Default is True.

        """

        self.jsvars.append( (var, value, override) )

    def add_post_inline_script(self, content):

        self.post_inlined_scripts.append(content)

    def add_onload(self, jscode):

        self.add_post_inline_script(u"""$(cw).one('server-response', function(event) {

%s});""" % jscode)

    def add_js(self, jsfile):

        """adds `jsfile` to the list of javascripts used in the webpage

        This function checks if the file has already been added

        :param jsfile: the script's URL

        """

        if jsfile not in self.jsfiles:

            self.jsfiles.append(jsfile)

    def add_css(self, cssfile, media='all'):

        """adds `cssfile` to the list of javascripts used in the webpage

        This function checks if the file has already been added

        :param cssfile: the stylesheet's URL

        """

        if (cssfile, media) not in self.cssfiles:

            self.cssfiles.append( (cssfile, media) )

    def add_ie_css(self, cssfile, media='all', iespec=u'[if lt IE 8]'):

        """registers some IE specific CSS"""

        if (cssfile, media, iespec) not in self.ie_cssfiles:

            self.ie_cssfiles.append( (cssfile, media, iespec) )

    def add_unload_pagedata(self):

        """registers onunload callback to clean page data on server"""

        if not self.pagedata_unload:

            self.post_inlined_scripts.append(self.js_unload_code)

            self.pagedata_unload = True

    def concat_urls(self, urls):

        """concatenates urls into one url usable by Apache mod_concat

        This method returns the url without modifying it if there is only

        one element in the list

        :param urls: list of local urls/filenames to concatenate

        """

        if len(urls) == 1:

            return urls[0]

        len_prefix = len(self.datadir_url)

        concated = u','.join(url[len_prefix:] for url in urls)

        return (u'%s??%s' % (self.datadir_url, concated))

    def group_urls(self, urls_spec):

        """parses urls_spec in order to generate concatenated urls

        for js and css includes

        This method checks if the file is local and if it shares options

        with direct neighbors

        :param urls_spec: entire list of urls/filenames to inspect

        """

        concatable = []

        prev_islocal = False

        prev_key = None

        for url, key in urls_spec:

            islocal = url.startswith(self.datadir_url)

            if concatable and (islocal != prev_islocal or key != prev_key):

                yield (self.concat_urls(concatable), prev_key)

                del concatable[:]

            if not islocal:

                yield (url, key)

            else:

                concatable.append(url)

            prev_islocal = islocal

            prev_key = key

        if concatable:

            yield (self.concat_urls(concatable), prev_key)

    def getvalue(self, skiphead=False):

        """reimplement getvalue to provide a consistent (and somewhat browser

        optimzed cf. http://stevesouders.com/cuzillion) order in external

        resources declaration

        """

        w = self.write

        # 1/ variable declaration if any

        if self.jsvars:

            w(self.script_opening)

            for var, value, override in self.jsvars:

                vardecl = u'%s = %s;' % (var, json.dumps(value))

                if not override:

                    vardecl = (u'if (typeof %s == "undefined") {%s}' %

                               (var, vardecl))

                w(vardecl + u'\n')

            w(self.script_closing)

        # 2/ css files

        ie_cssfiles = ((x, (y, z)) for x, y, z in self.ie_cssfiles)

        if self.datadir_url and self._cw.vreg.config['concat-resources']:

            cssfiles = self.group_urls(self.cssfiles)

            ie_cssfiles = self.group_urls(ie_cssfiles)

            jsfiles = (x for x, _ in self.group_urls((x, None) for x in self.jsfiles))

        else:

            cssfiles = self.cssfiles