"""Base class for entity objects manipulated in clients

:organization: Logilab

:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

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

"""

__docformat__ = "restructuredtext en"

from warnings import warn

from logilab.common import interface

from logilab.common.compat import all

from logilab.common.decorators import cached

from logilab.common.deprecation import obsolete

from logilab.mtconverter import TransformData, TransformError, html_escape

from rql.utils import rqlvar_maker

from cubicweb import Unauthorized

from cubicweb.rset import ResultSet

from cubicweb.selectors import yes

from cubicweb.appobject import AppRsetObject

from cubicweb.schema import RQLVocabularyConstraint, RQLConstraint, bw_normalize_etype

try:

    from cubicweb.common.uilib import printable_value, soup2xhtml

    from cubicweb.common.mixins import MI_REL_TRIGGERS

    from cubicweb.common.mttransforms import ENGINE

except ImportError:

    # missing -common

    MI_REL_TRIGGERS = {}

_marker = object()

def greater_card(rschema, subjtypes, objtypes, index):

    for subjtype in subjtypes:

        for objtype in objtypes:

            card = rschema.rproperty(subjtype, objtype, 'cardinality')[index]

            if card in '+*':

                return card

    return '1'

_MODE_TAGS = set(('link', 'create'))

_CATEGORY_TAGS = set(('primary', 'secondary', 'generic', 'generated')) # , 'metadata'))

try:

    from cubicweb.web import formwidgets, uicfg

    def _dispatch_rtags(tags, rtype, role, stype, otype):

        for tag in tags:

            if tag in _MODE_TAGS:

                uicfg.actionbox_appearsin_addmenu.tag_relation(

                    (stype, rtype, otype, role), tag == 'create')

            elif tag in _CATEGORY_TAGS:

                uicfg.autoform_section.tag_relation((stype, rtype, otype, role),

                                                    tag)

            elif tag == 'inlineview':

                uicfg.autoform_is_inlined.tag_relation((stype, rtype, otype, role), True)

            else:

                raise ValueError(tag)

except ImportError:

    _dispatch_rtags = None

def _get_etype(bases, classdict):

    try:

        return classdict['id']

    except KeyError:

        for base in bases:

            etype = getattr(base, 'id', None)

            if etype and etype != 'Any':

                return etype

def _get_defs(attr, name, bases, classdict):

    try:

        yield name, classdict.pop(attr)

    except KeyError:

        for base in bases:

            try:

                value = getattr(base, attr)

                delattr(base, attr)

                yield base.__name__, value

            except AttributeError:

                continue

class _metaentity(type):

    """this metaclass sets the relation tags on the entity class

    and deals with the `widgets` attribute

    """

    def __new__(mcs, name, bases, classdict):

        # collect baseclass' rtags

        etype = _get_etype(bases, classdict)

        if etype and _dispatch_rtags is not None:

            for name, rtags in _get_defs('__rtags__', name, bases, classdict):

                warn('%s: __rtags__ is deprecated' % name, DeprecationWarning)

                for relation, tags in rtags.iteritems():

                    # tags must become an iterable

                    if isinstance(tags, basestring):

                        tags = (tags,)

                    # relation must become a 3-uple (rtype, targettype, role)

                    if isinstance(relation, basestring):

                        _dispatch_rtags(tags, relation, 'subject', etype, '*')

                        _dispatch_rtags(tags, relation, 'object', '*', etype)

                    elif len(relation) == 1: # useful ?

                        _dispatch_rtags(tags, relation[0], 'subject', etype, '*')

                        _dispatch_rtags(tags, relation[0], 'object', '*', etype)

                    elif len(relation) == 2:

                        rtype, ttype = relation

                        ttype = bw_normalize_etype(ttype) # XXX bw compat

                        _dispatch_rtags(tags, rtype, 'subject', etype, ttype)

                        _dispatch_rtags(tags, rtype, 'object', ttype, etype)

                    elif len(relation) == 3:

                        rtype, ttype, role = relation

                        ttype = bw_normalize_etype(ttype)

                        if role == 'subject':

                            _dispatch_rtags(tags, rtype, 'subject', etype, ttype)

                        else:

                            _dispatch_rtags(tags, rtype, 'object', ttype, etype)

                    else:

                        raise ValueError('bad rtag definition (%r)' % (relation,))

            for name, widgets in _get_defs('widgets', name, bases, classdict):

                warn('%s: widgets is deprecated' % name, DeprecationWarning)

                for rtype, wdgname in widgets.iteritems():

                    if wdgname in ('URLWidget', 'EmbededURLWidget', 'RawDynamicComboBoxWidget'):

                        warn('%s widget is deprecated' % wdgname, DeprecationWarning)

                        continue

                    if wdgname == 'StringWidget':

                        wdgname = 'TextInput'

                    widget = getattr(formwidgets, wdgname)

                    assert hasattr(widget, 'render')

                    uicfg.autoform_field_kwargs.tag_subject_of(

                        (etype, rtype, '*'), {'widget': widget})

        return super(_metaentity, mcs).__new__(mcs, name, bases, classdict)

class Entity(AppRsetObject, dict):

    """an entity instance has e_schema automagically set on

    the class and instances has access to their issuing cursor.

    A property is set for each attribute and relation on each entity's type

    class. Becare that among attributes, 'eid' is *NEITHER* stored in the

    dict containment (which acts as a cache for other attributes dynamically

    fetched)

    :type e_schema: `cubicweb.schema.EntitySchema`

    :ivar e_schema: the entity's schema

    :type rest_var: str

    :cvar rest_var: indicates which attribute should be used to build REST urls

                    If None is specified, the first non-meta attribute will

                    be used

    :type skip_copy_for: list

    :cvar skip_copy_for: a list of relations that should be skipped when copying

                         this kind of entity. Note that some relations such

                         as composite relations or relations that have '?1' as object

                         cardinality

    """

    __metaclass__ = _metaentity

    __registry__ = 'etypes'

    __select__ = yes()

    # class attributes that must be set in class definition

    id = None

    rest_attr = None

    fetch_attrs = None

    skip_copy_for = ()

    # class attributes set automatically at registration time

    e_schema = None

    @classmethod

    def registered(cls, registry):

        """build class using descriptor at registration time"""

        assert cls.id is not None

        super(Entity, cls).registered(registry)

        if cls.id != 'Any':

            cls.__initialize__()

        return cls

    MODE_TAGS = set(('link', 'create'))

    CATEGORY_TAGS = set(('primary', 'secondary', 'generic', 'generated')) # , 'metadata'))

    @classmethod

    def __initialize__(cls):

        """initialize a specific entity class by adding descriptors to access

        entity type's attributes and relations

        """

        etype = cls.id

        assert etype != 'Any', etype

        cls.e_schema = eschema = cls.schema.eschema(etype)

        for rschema, _ in eschema.attribute_definitions():

            if rschema.type == 'eid':

                continue

            setattr(cls, rschema.type, Attribute(rschema.type))

        mixins = []

        for rschema, _, x in eschema.relation_definitions():

            if (rschema, x) in MI_REL_TRIGGERS:

                mixin = MI_REL_TRIGGERS[(rschema, x)]

                if not (issubclass(cls, mixin) or mixin in mixins): # already mixed ?

                    mixins.append(mixin)

                for iface in getattr(mixin, '__implements__', ()):

                    if not interface.implements(cls, iface):

                        interface.extend(cls, iface)

            if x == 'subject':

                setattr(cls, rschema.type, SubjectRelation(rschema))

            else:

                attr = 'reverse_%s' % rschema.type

                setattr(cls, attr, ObjectRelation(rschema))

        if mixins:

            cls.__bases__ = tuple(mixins + [p for p in cls.__bases__ if not p is object])

            cls.debug('plugged %s mixins on %s', mixins, etype)

    @classmethod

    def fetch_rql(cls, user, restriction=None, fetchattrs=None, mainvar='X',

                  settype=True, ordermethod='fetch_order'):

        """return a rql to fetch all entities of the class type"""

        restrictions = restriction or []

        if settype:

            restrictions.append('%s is %s' % (mainvar, cls.id))

        if fetchattrs is None:

            fetchattrs = cls.fetch_attrs

        selection = [mainvar]

        orderby = []

        # start from 26 to avoid possible conflicts with X

        varmaker = rqlvar_maker(index=26)

        cls._fetch_restrictions(mainvar, varmaker, fetchattrs, selection,

                                orderby, restrictions, user, ordermethod)

        rql = 'Any %s' % ','.join(selection)

        if orderby:

            rql +=  ' ORDERBY %s' % ','.join(orderby)

        rql += ' WHERE %s' % ', '.join(restrictions)

        return rql

    @classmethod

    def _fetch_restrictions(cls, mainvar, varmaker, fetchattrs,

                            selection, orderby, restrictions, user,

                            ordermethod='fetch_order', visited=None):

        eschema = cls.e_schema

        if visited is None:

            visited = set((eschema.type,))

        elif eschema.type in visited:

            # avoid infinite recursion

            return

        else:

            visited.add(eschema.type)

        _fetchattrs = []

        for attr in fetchattrs:

            try:

                rschema = eschema.subject_relation(attr)

            except KeyError:

                cls.warning('skipping fetch_attr %s defined in %s (not found in schema)',

                            attr, cls.id)

                continue

            if not user.matching_groups(rschema.get_groups('read')):

                continue

            var = varmaker.next()

            selection.append(var)

            restriction = '%s %s %s' % (mainvar, attr, var)

            restrictions.append(restriction)

            if not rschema.is_final():

                # XXX this does not handle several destination types

                desttype = rschema.objects(eschema.type)[0]

                card = rschema.rproperty(eschema, desttype, 'cardinality')[0]

                if card not in '?1':

                    selection.pop()

                    restrictions.pop()

                    continue

                if card == '?':

                    restrictions[-1] += '?' # left outer join if not mandatory

                destcls = cls.vreg.etype_class(desttype)

                destcls._fetch_restrictions(var, varmaker, destcls.fetch_attrs,

                                            selection, orderby, restrictions,

                                            user, ordermethod, visited=visited)

            orderterm = getattr(cls, ordermethod)(attr, var)

            if orderterm:

                orderby.append(orderterm)

        return selection, orderby, restrictions

    @classmethod

    @cached

    def parent_classes(cls):

        parents = [cls.vreg.etype_class(e.type) for e in cls.e_schema.ancestors()]

        parents.append(cls.vreg.etype_class('Any'))

        return parents

    def __init__(self, req, rset=None, row=None, col=0):

        AppRsetObject.__init__(self, req, rset, row, col)

        dict.__init__(self)

        self._related_cache = {}

        if rset is not None:

            self.eid = rset[row][col]

        else:

            self.eid = None

        self._is_saved = True

    def __repr__(self):

        return '<Entity %s %s %s at %s>' % (

            self.e_schema, self.eid, self.keys(), id(self))

    def __nonzero__(self):

        return True

    def __hash__(self):

        return id(self)

    def pre_add_hook(self):

        """hook called by the repository before doing anything to add the entity

        (before_add entity hooks have not been called yet). This give the

        occasion to do weird stuff such as autocast (File -> Image for instance).

        This method must return the actual entity to be added.

        """

        return self

    def set_eid(self, eid):

        self.eid = self['eid'] = eid

    def has_eid(self):

        """return True if the entity has an attributed eid (False

        meaning that the entity has to be created

        """

        try:

            int(self.eid)

            return True

        except (ValueError, TypeError):

            return False

    def is_saved(self):

        """during entity creation, there is some time during which the entity

        has an eid attributed though it's not saved (eg during before_add_entity

        hooks). You can use this method to ensure the entity has an eid *and* is

        saved in its source.

        """

        return self.has_eid() and self._is_saved

    @cached

    def metainformation(self):

        res = dict(zip(('type', 'source', 'extid'), self.req.describe(self.eid)))

        res['source'] = self.req.source_defs()[res['source']]

        return res

    def clear_local_perm_cache(self, action):

        for rqlexpr in self.e_schema.get_rqlexprs(action):

            self.req.local_perm_cache.pop((rqlexpr.eid, (('x', self.eid),)), None)

    def check_perm(self, action):

        self.e_schema.check_perm(self.req, action, self.eid)

    def has_perm(self, action):

        return self.e_schema.has_perm(self.req, action, self.eid)

    def view(self, vid, __registry='views', **kwargs):

        """shortcut to apply a view on this entity"""

        return self.vreg.render(__registry, vid, self.req, rset=self.rset,

                                row=self.row, col=self.col, **kwargs)

    def absolute_url(self, method=None, **kwargs):

        """return an absolute url to view this entity"""

        # in linksearch mode, we don't want external urls else selecting

        # the object for use in the relation is tricky

        # XXX search_state is web specific

        if getattr(self.req, 'search_state', ('normal',))[0] == 'normal':

            kwargs['base_url'] = self.metainformation()['source'].get('base-url')

        if method is None or method == 'view':

            kwargs['_restpath'] = self.rest_path()

        else:

            kwargs['rql'] = 'Any X WHERE X eid %s' % self.eid

        return self.build_url(method, **kwargs)

    def rest_path(self):

        """returns a REST-like (relative) path for this entity"""

        mainattr, needcheck = self._rest_attr_info()

        etype = str(self.e_schema)

        if mainattr == 'eid':

            value = self.eid

        else: