from logilab.common.decorators import cached, clear_cache, monkeypatch

from cubicweb import (ETYPE_NAME_MAP, Binary, UnknownProperty, UnknownEid,

                      ObjectNotFound, NoSelectableObject, RegistryNotFound)

from cubicweb.vregistry import VRegistry, Registry

class CWRegistry(Registry):

    def __init__(self, vreg):

        super(CWRegistry, self).__init__(vreg.config)

        self.vreg = vreg

        self.schema = vreg.schema

    def initialization_completed(self):

        # call vreg_initialization_completed on appobjects and print

        # registry content

        for appobjects in self.itervalues():

            for appobject in appobjects:

                appobject.vreg_initialization_completed()

    def render(self, __oid, req, __fallback_oid=None, rset=None, **kwargs):

        """select object, or fallback object if specified and the first one

        isn't selectable, then render it

        """

        try:

            obj = self.select(__oid, req, rset=rset, **kwargs)

        except NoSelectableObject:

            if __fallback_oid is None:

                raise

            obj = self.select(__fallback_oid, req, **kwargs)

        return obj.render(**kwargs)

    def select_vobject(self, oid, *args, **kwargs):

        selected = self.select_object(oid, *args, **kwargs)

        if selected and selected.propval('visible'):

            return selected

        return None

    def possible_vobjects(self, *args, **kwargs):

        """return an ordered list of possible app objects in a given registry,

        supposing they support the 'visible' and 'order' properties (as most

        visualizable objects)

        """

        return sorted([x for x in self.possible_objects(*args, **kwargs)

                       if x.propval('visible')],

                      key=lambda x: x.propval('order'))

VRegistry.REGISTRY_FACTORY[None] = CWRegistry

class ETypeRegistry(CWRegistry):

    def initialization_completed(self):

        super(ETypeRegistry, self).initialization_completed()

        # clear etype cache if you don't want to run into deep weirdness

        clear_cache(self, 'etype_class')

    def register(self, obj, **kwargs):

        oid = kwargs.get('oid') or obj.id

        if oid != 'Any' and not oid in self.schema:

            self.error('don\'t register %s, %s type not defined in the '

                       'schema', obj, obj.id)

            return

        kwargs['clear'] = True

        super(ETypeRegistry, self).register(obj, **kwargs)

    @cached

    def etype_class(self, etype):

        """return an entity class for the given entity type.

        Try to find out a specific class for this kind of entity or

        default to a dump of the class registered for 'Any'

        """

        etype = str(etype)

        if etype == 'Any':

            return self.select('Any', 'Any')

        eschema = self.schema.eschema(etype)

        baseschemas = [eschema] + eschema.ancestors()

        # browse ancestors from most specific to most generic and

        # try to find an associated custom entity class

        for baseschema in baseschemas:

            try:

                btype = ETYPE_NAME_MAP[baseschema]

            except KeyError:

                btype = str(baseschema)

            try:

                cls = self.select(btype, etype)

                break

            except ObjectNotFound:

                pass

        else:

            # no entity class for any of the ancestors, fallback to the default

            # one

            cls = self.select('Any', etype)

        return cls

VRegistry.REGISTRY_FACTORY['etypes'] = ETypeRegistry

class ViewsRegistry(CWRegistry):

    def main_template(self, req, oid='main-template', **kwargs):

        """display query by calling the given template (default to main),

        and returning the output as a string instead of requiring the [w]rite

        method as argument

        """

        res = self.render(oid, req, **kwargs)

        if isinstance(res, unicode):

            return res.encode(req.encoding)

        assert isinstance(res, str)

        return res

    def possible_views(self, req, rset=None, **kwargs):

        """return an iterator on possible views for this result set

        views returned are classes, not instances

        """

        for vid, views in self.items():

            if vid[0] == '_':

                continue

            try:

                view = self.select_best(views, req, rset=rset, **kwargs)

                if view.linkable():

                    yield view

            except NoSelectableObject:

                continue

            except Exception:

                self.exception('error while trying to select %s view for %s',

                               vid, rset)

VRegistry.REGISTRY_FACTORY['views'] = ViewsRegistry

class ActionsRegistry(CWRegistry):

    def possible_actions(self, req, rset=None, **kwargs):

        if rset is None:

            actions = self.possible_vobjects(req, rset=rset, **kwargs)

        else:

            actions = rset.possible_actions(**kwargs) # cached implementation

        result = {}

        for action in actions:

            result.setdefault(action.category, []).append(action)

        return result

VRegistry.REGISTRY_FACTORY['actions'] = ActionsRegistry

class CubicWebVRegistry(VRegistry):

        super(CubicWebVRegistry, self).__init__(config)

    def setdefault(self, regid):

        try:

            return self[regid]

        except RegistryNotFound:

            self[regid] = self.registry_class(regid)(self)

            return self[regid]

        return [item for item in super(CubicWebVRegistry, self).items()

        return [value for key, value in self.items()]

        super(CubicWebVRegistry, self).reset()

        self['propertydefs'] = {}

        self['propertyvalues'] = self.eprop_values = {}

        for registry, regcontent in self.items():

        super(CubicWebVRegistry, self).register(obj, **kwargs)

        if super(CubicWebVRegistry, self).register_objects(path, force_reload,

        for regname, reg in self.items():

            self.debug('available in registry %s: %s', regname, sorted(reg))

            reg.initialization_completed()

                    cls = self['etypes'].etype_class(etype)

                                   and self['etypes'].etype_class(iface)

    def parse(self, session, rql, args=None):

        rqlst = self.rqlhelper.parse(rql)

        def type_from_eid(eid, session=session):

            return session.describe(eid)[0]

        try:

            self.rqlhelper.compute_solutions(rqlst, {'eid': type_from_eid}, args)

        except UnknownEid:

            for select in rqlst.children:

                select.solutions = []

        return rqlst

    @property

    def rqlhelper(self):

        return RQLHelper(self.schema,

                         special_relations={'eid': 'uid', 'has_text': 'fti'})

    @deprecated('use vreg["etypes"].etype_class(etype)')

        return self["etypes"].etype_class(etype)

    @deprecated('use vreg["views"].main_template(*args, **kwargs)')

        return self["views"].main_template(req, oid, **context)

    @deprecated('use vreg[registry].possible_vobjects(*args, **kwargs)')

        return self[registry].possible_vobjects(*args, **kwargs)

    @deprecated('use vreg["actions"].possible_actions(*args, **kwargs)')

        return self["actions"].possible_actions(req, rest=rset, **kwargs)

        return self['boxes'].select_object(oid, *args, **kwargs)

        return self['components'].select_object(cid, *args, **kwargs)

        return self['actions'].select_object(oid, *args, **kwargs)

        return self['views'].select(__vid, req, rset=rset, **kwargs)