# 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/>.

"""

__docformat__ = "restructuredtext en"

_ = unicode

import sys

from os.path import join, dirname, realpath

from warnings import warn

from datetime import datetime, date, time, timedelta

from functools import reduce

from logilab.common.decorators import cached, clear_cache

from logilab.common.deprecation import deprecated, class_deprecated

from logilab.common.modutils import cleanup_sys_modules

from logilab.common.registry import (

    RegistryStore, Registry, obj_registries,

    ObjectNotFound, RegistryNotFound)

from rql import RQLHelper

from yams.constraints import BASE_CONVERTERS

from cubicweb import (CW_SOFTWARE_ROOT, ETYPE_NAME_MAP, CW_EVENT_MANAGER,

                      onevent, Binary, UnknownProperty, UnknownEid)

from cubicweb.predicates import appobject_selectable, _reset_is_instance_cache

@onevent('before-registry-reload')

def cleanup_uicfg_compat():

    """ backward compat: those modules are now refering to app objects in

    cw.web.views.uicfg and import * from backward compat. On registry reload, we

    should pop those modules from the cache so references are properly updated on

    subsequent reload

    """

    if 'cubicweb.web' in sys.modules:

        if getattr(sys.modules['cubicweb.web'], 'uicfg', None):

            del sys.modules['cubicweb.web'].uicfg

        if getattr(sys.modules['cubicweb.web'], 'uihelper', None):

            del sys.modules['cubicweb.web'].uihelper

    sys.modules.pop('cubicweb.web.uicfg', None)

    sys.modules.pop('cubicweb.web.uihelper', None)

def require_appobject(obj):

    """return appobjects required by the given object by searching for

    `appobject_selectable` predicate

    """

    impl = obj.__select__.search_selector(appobject_selectable)

    if impl:

        return (impl.registry, impl.regids)

    return None

class CWRegistry(Registry):

    def __init__(self, vreg):

        super(CWRegistry, self).__init__(True)

        self.vreg = vreg

    @property

    def schema(self):

        return self.vreg.schema

    def poss_visible_objects(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.cw_propval('visible')],

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

def related_appobject(obj, appobjectattr='__appobject__'):

    """ adapts any object to a potential appobject bound to it

    through the __appobject__ attribute

    """

    return getattr(obj, appobjectattr, obj)

class InstancesRegistry(CWRegistry):

    def selected(self, winner, args, kwargs):

        """overriden to avoid the default 'instanciation' behaviour, ie

        `winner(*args, **kwargs)`

        """

        return winner

class ETypeRegistry(CWRegistry):

    def clear_caches(self):

        clear_cache(self, 'etype_class')

        clear_cache(self, 'parent_classes')

        _reset_is_instance_cache(self.vreg)

    def initialization_completed(self):

        """on registration completed, clear etype_class internal cache

        """

        super(ETypeRegistry, self).initialization_completed()

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

        self.clear_caches()

        # rebuild all classes to avoid potential memory fragmentation

        # (see #2719113)

        for eschema in self.vreg.schema.entities():

            self.etype_class(eschema)

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

        obj = related_appobject(obj)

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

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

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

                       'schema', obj, oid)

            return

        kwargs['clear'] = True

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

    def iter_classes(self):

        for etype in self.vreg.schema.entities():

            yield self.etype_class(etype)

    @cached

    def parent_classes(self, etype):

        if etype == 'Any':

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

        parents = tuple(self.etype_class(e.type)

                        for e in self.schema.eschema(etype).ancestors())

        return parents, self.etype_class('Any')

    @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 nearest parent class (in yams inheritance) registered.

        Fall back to 'Any' if not yams parent class found.

        """

        etype = str(etype)

        if etype == 'Any':

            objects = self['Any']

            assert len(objects) == 1, objects

            return objects[0]

        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:

                objects = self[btype]

                assert len(objects) == 1, objects

                if btype == etype:

                    cls = objects[0]

                else:

                    # recurse to ensure issubclass(etype_class('Child'),

                    #                              etype_class('Parent'))

                    cls = self.etype_class(btype)

                break

            except ObjectNotFound:

                pass

        else:

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

            # one

            objects = self['Any']

            assert len(objects) == 1, objects

            cls = objects[0]

        # make a copy event if cls.__regid__ == etype, else we may have pb for

        # client application using multiple connections to different

        # repositories (eg shingouz)

        # __autogenerated__ attribute is just a marker

        cls = type(str(etype), (cls,), {'__autogenerated__': True,

                                        '__doc__': cls.__doc__,

                                        '__module__': cls.__module__})

        cls.__regid__ = etype

        cls.__initialize__(self.schema)

        return cls

    def fetch_attrs(self, targettypes):

        """return intersection of fetch_attrs of each entity type in

        `targettypes`

        """

        fetchattrs_list = []

        for ttype in targettypes:

            etypecls = self.etype_class(ttype)

            fetchattrs_list.append(set(etypecls.fetch_attrs))

        return reduce(set.intersection, fetchattrs_list)

class ViewsRegistry(CWRegistry):

    def main_template(self, req, oid='main-template', rset=None, **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

        """

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

        res = obj.render(**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

            views = [view for view in views

                     if not isinstance(view, class_deprecated)]

            try:

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

                if view is not None and view.linkable():

                    yield view

            except Exception:

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

                               vid, rset)

class ActionsRegistry(CWRegistry):

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

        """return an ordered list of possible actions"""

        return sorted(self.possible_objects(*args, **kwargs),

                      key=lambda x: x.order)

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

        if rset is None:

            actions = self.poss_visible_objects(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

class CtxComponentsRegistry(CWRegistry):

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

        """return an ordered list of possible components"""

        context = kwargs.pop('context')

        if '__cache' in kwargs:

            cache = kwargs.pop('__cache')

        elif kwargs.get('rset') is None:

            cache = args[0]

        else:

            cache = kwargs['rset']

        try:

            cached = cache.__components_cache

        except AttributeError:

            ctxcomps = super(CtxComponentsRegistry, self).poss_visible_objects(

                *args, **kwargs)

            if cache is None:

                components = []

                for component in ctxcomps:

                    cctx = component.cw_propval('context')

                    if cctx == context:

                        component.cw_extra_kwargs['context'] = cctx

                        components.append(component)

                return components

            cached = cache.__components_cache = {}

            for component in ctxcomps:

                cctx = component.cw_propval('context')

                component.cw_extra_kwargs['context'] = cctx

                cached.setdefault(cctx, []).append(component)

        thisctxcomps = cached.get(context, ())

        # XXX set context for bw compat (should now be taken by comp.render())

        for component in thisctxcomps:

            component.cw_extra_kwargs['context'] = context

        return thisctxcomps

class BwCompatCWRegistry(object):

    def __init__(self, vreg, oldreg, redirecttoreg):

        self.vreg = vreg

        self.oldreg = oldreg

        self.redirecto = redirecttoreg

    def __getattr__(self, attr):

        warn('[3.10] you should now use the %s registry instead of the %s registry'

             % (self.redirecto, self.oldreg), DeprecationWarning, stacklevel=2)

        return getattr(self.vreg[self.redirecto], attr)

    def clear(self): pass

    def initialization_completed(self): pass

class CWRegistryStore(RegistryStore):

    """Central registry for the cubicweb instance, extending the generic

    RegistryStore with some cubicweb specific stuff.

    This is one of the central object in cubicweb instance, coupling

    dynamically loaded objects with the schema and the configuration objects.

    It specializes the RegistryStore by adding some convenience methods to access to

    stored objects. Currently we have the following registries of objects known

    by the web instance (library may use some others additional registries):

    * 'etypes', entity type classes

    * 'views', views and templates (e.g. layout views)

    * 'components', non contextual components, like magic search, url evaluators

    * 'ctxcomponents', contextual components like boxes and dynamic section

    * 'actions', contextual actions, eg links to display in predefined places in

      the ui

    * 'forms', describing logic of HTML form

    * 'formrenderers', rendering forms to html

    * 'controllers', primary objects to handle request publishing, directly

      plugged into the application

    """

    REGISTRY_FACTORY = {None: CWRegistry,

                        'etypes': ETypeRegistry,

                        'views': ViewsRegistry,

                        'actions': ActionsRegistry,

                        'ctxcomponents': CtxComponentsRegistry,

                        'uicfg': InstancesRegistry,

                        }

    def __init__(self, config, initlog=True):

        if initlog:

            # first init log service

            config.init_log()

        super(CWRegistryStore, self).__init__(config.debugmode)

        self.config = config

        # need to clean sys.path this to avoid import confusion pb (i.e.  having

        # the same module loaded as 'cubicweb.web.views' subpackage and as

        # views' or 'web.views' subpackage. This is mainly for testing purpose,

        # we should'nt need this in production environment

        for webdir in (join(dirname(realpath(__file__)), 'web'),

                       join(dirname(__file__), 'web')):

            if webdir in sys.path:

                sys.path.remove(webdir)

        if CW_SOFTWARE_ROOT in sys.path:

            sys.path.remove(CW_SOFTWARE_ROOT)

        self.schema = None

        self.initialized = False

        self['boxes'] = BwCompatCWRegistry(self, 'boxes', 'ctxcomponents')

        self['contentnavigation'] = BwCompatCWRegistry(self, 'contentnavigation', 'ctxcomponents')

    def setdefault(self, regid):

        try:

            return self[regid]

        except RegistryNotFound:

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

            return self[regid]

    def items(self):

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

                if not item[0] in ('propertydefs', 'propertyvalues')]