"""

* the vregistry handle various type of objects interacting

  together. The vregistry handle registration of dynamically loaded

  objects and provide a convenient api access to those objects

  according to a context

* to interact with the vregistry, object should inherit from the

  VObject abstract class

* the selection procedure has been generalized by delegating to a

  selector, which is responsible to score the vobject according to the

  current state (req, rset, row, col). At the end of the selection, if

  a vobject class has been found, an instance of this class is

  returned. The selector is instantiated at vobject registration

:organization: Logilab

:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.

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

:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses

"""

__docformat__ = "restructuredtext en"

import sys

from os import listdir, stat

from os.path import dirname, join, realpath, split, isdir, exists

from logging import getLogger

import types

from cubicweb import CW_SOFTWARE_ROOT, set_log_methods

from cubicweb import RegistryNotFound, ObjectNotFound, NoSelectableObject

    """return a dictionary of <modname>: <modpath> and an ordered list of

    (file, module name) to load

    """

    from logilab.common.modutils import modpath_from_file

    if _toload is None:

        _toload = {}, []

    for fileordir in path:

        if isdir(fileordir) and exists(join(fileordir, '__init__.py')):

            subfiles = [join(fileordir, fname) for fname in listdir(fileordir)]

        elif fileordir[-3:] == '.py':

            _toload[0][modname] = fileordir

            _toload[1].append((fileordir, modname))

    return _toload

class VObject(object):

    """visual object, use to be handled somehow by the visual components

    registry.

    The following attributes should be set on concret vobject subclasses:

    :__registry__:

      name of the registry for this object (string like 'views',

      'templates'...)

    :id:

      object's identifier in the registry (string like 'main',

      'primary', 'folder_box')

    :__select__:

      class'selector

    Moreover, the `__abstract__` attribute may be set to True to indicate

    that a vobject is abstract and should not be registered

    """

    # necessary attributes to interact with the registry

    id = None

    __registry__ = None

    __select__ = None

    @classmethod

    def registered(cls, registry):

        """called by the registry when the vobject has been registered.

        It must return the  object that will be actually registered (this

        may be the right hook to create an instance for example). By

        default the vobject is returned without any transformation.

        """

        cls.build___select__()

        return cls

    @classmethod

    def selected(cls, *args, **kwargs):

        """called by the registry when the vobject has been selected.

        It must return the  object that will be actually returned by the

        .select method (this may be the right hook to create an

        instance for example). By default the selected object is

        returned without any transformation.

        """

        return cls

    @classmethod

    def classid(cls):

        """returns a unique identifier for the vobject"""

        return '%s.%s' % (cls.__module__, cls.__name__)

    # XXX bw compat code

    @classmethod

    def build___select__(cls):

        for klass in cls.mro():

            if klass.__name__ == 'AppRsetObject':

                continue # the bw compat __selector__ is there

            klassdict = klass.__dict__

            if ('__select__' in klassdict and '__selectors__' in klassdict

                and '__selgenerated__' not in klassdict):

                raise TypeError("__select__ and __selectors__ can't be used together on class %s" % cls)

            if '__selectors__' in klassdict and '__selgenerated__' not in klassdict:

                cls.__selgenerated__ = True

                # case where __selectors__ is defined locally (but __select__

                # is in a parent class)

                selectors = klassdict['__selectors__']

                if len(selectors) == 1:

                    # micro optimization: don't bother with AndSelector if there's

                    # only one selector

                    select = _instantiate_selector(selectors[0])

                else:

                    select = AndSelector(*selectors)

                cls.__select__ = select

class VRegistry(object):

    """class responsible to register, propose and select the various

    elements used to build the web interface. Currently, we have templates,

    views, actions and components.

    """

    def __init__(self, config):#, cache_size=1000):

        self.config = config

        # dictionnary of registry (themself dictionnary) by name

        self._registries = {}

        self._lastmodifs = {}

    def reset(self):

        self._registries = {}

        self._lastmodifs = {}

    def __getitem__(self, key):

        return self._registries[key]

    def get(self, key, default=None):

        return self._registries.get(key, default)

    def items(self):

        return self._registries.items()

    def values(self):

        return self._registries.values()

    def __contains__(self, key):

        return key in self._registries

    def registry(self, name):

        """return the registry (dictionary of class objects) associated to

        this name

        """

        try:

            return self._registries[name]

        except KeyError:

            raise RegistryNotFound(name), None, sys.exc_info()[-1]

    def registry_objects(self, name, oid=None):

        """returns objects registered with the given oid in the given registry.

        If no oid is given, return all objects in this registry

        """

        registry = self.registry(name)

        if oid:

            try:

                return registry[oid]

            except KeyError:

                raise ObjectNotFound(oid), None, sys.exc_info()[-1]

        else:

            result = []

            for objs in registry.values():

                result += objs

            return result

    def object_by_id(self, registry, cid, *args, **kwargs):

        """return the most specific component according to the resultset"""

        objects = self[registry][cid]

        assert len(objects) == 1, objects

        return objects[0].selected(*args, **kwargs)

    # methods for explicit (un)registration ###################################

#     def clear(self, key):

#         regname, oid = key.split('.')

#         self[regname].pop(oid, None)

    def register_all(self, objects, modname, butclasses=()):

        for obj in objects:

            try:

                if obj.__module__ != modname or obj in butclasses:

                    continue

                oid = obj.id

            except AttributeError:

                continue

            if oid:

                self.register(obj)

    def register(self, obj, registryname=None, oid=None, clear=False):

        """base method to add an object in the registry"""

        assert not '__abstract__' in obj.__dict__

        registryname = registryname or obj.__registry__

        oid = oid or obj.id

        assert oid

        registry = self._registries.setdefault(registryname, {})

        if clear:

            vobjects = registry[oid] =  []

        else:

            vobjects = registry.setdefault(oid, [])

        # registered() is technically a classmethod but is not declared

        # as such because we need to compose registered in some cases

        vobject = obj.registered.im_func(obj, self)

        assert not vobject in vobjects, vobject

        assert callable(vobject.__select__), vobject

        vobjects.append(vobject)

        try:

            vname = vobject.__name__

        except AttributeError:

            vname = vobject.__class__.__name__

        self.debug('registered vobject %s in registry %s with id %s',

                   vname, registryname, oid)

        # automatic reloading management

        self._loadedmods[obj.__module__]['%s.%s' % (obj.__module__, oid)] = obj

    def unregister(self, obj, registryname=None):

        registryname = registryname or obj.__registry__

        registry = self.registry(registryname)

        removed_id = obj.classid()

        for registered in registry[obj.id]:

            # use classid() to compare classes because vreg will probably

            # have its own version of the class, loaded through execfile

            if registered.classid() == removed_id:

                # XXX automatic reloading management

                try:

                    registry[obj.id].remove(registered)

                except KeyError:

                    self.warning('can\'t remove %s, no id %s in the %s registry',

                                 removed_id, obj.id, registryname)

                except ValueError:

                    self.warning('can\'t remove %s, not in the %s registry with id %s',

                                 removed_id, registryname, obj.id)

#                 else:

#                     # if objects is empty, remove oid from registry

#                     if not registry[obj.id]:

#                         del regcontent[oid]

                break

    def register_and_replace(self, obj, replaced, registryname=None):

        if hasattr(replaced, 'classid'):

            replaced = replaced.classid()

        registryname = registryname or obj.__registry__

        registry = self.registry(registryname)

        registered_objs = registry.get(obj.id, ())

        for index, registered in enumerate(registered_objs):

            if registered.classid() == replaced:

                del registry[obj.id][index]

                break

        else:

            self.warning('trying to replace an unregistered view %s by %s',

                         replaced, obj)

        self.register(obj, registryname=registryname)

    # dynamic selection methods ###############################################

    def select(self, vobjects, *args, **kwargs):

        """return an instance of the most specific object according

        to parameters

        raise NoSelectableObject if not object apply

        """

        score, winners = 0, []

        for vobject in vobjects:

            vobjectscore = vobject.__select__(vobject, *args, **kwargs)

            if vobjectscore > score:

                score, winners = vobjectscore, [vobject]

            elif vobjectscore > 0 and vobjectscore == score:

                winners.append(vobject)

        if not winners:

            raise NoSelectableObject('args: %s\nkwargs: %s %s'

                                     % (args, kwargs.keys(),

                                        [repr(v) for v in vobjects]))

        if len(winners) > 1:

            if self.config.mode == 'installed':

                self.error('select ambiguity, args: %s\nkwargs: %s %s',

                           args, kwargs.keys(), [repr(v) for v in winners])

            else:

                raise Exception('select ambiguity, args: %s\nkwargs: %s %s'

                                % (args, kwargs.keys(),

                                   [repr(v) for v in winners]))

        winner = winners[0]

        # return the result of the .selected method of the vobject

        return winner.selected(*args, **kwargs)

    def possible_objects(self, registry, *args, **kwargs):

        """return an iterator on possible objects in a registry for this result set

        actions returned are classes, not instances

        """

        for vobjects in self.registry(registry).values():

            try:

                yield self.select(vobjects, *args, **kwargs)

            except NoSelectableObject:

                continue

    def select_object(self, registry, cid, *args, **kwargs):

        """return the most specific component according to the resultset"""

        return self.select(self.registry_objects(registry, cid), *args, **kwargs)

    # intialization methods ###################################################

        # compute list of all modules that have to be loaded

        self._loadedmods = {}

        return filemods

        if force_reload is None:

            force_reload = self.config.mode == 'dev'

        elif not force_reload:

            # force_reload == False usually mean modules have been reloaded

            # by another connection, so we want to update the registry

            # content even if there has been no module content modification

            self.reset()

        # 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)

        # load views from each directory in the application's path

        change = False

        for filepath, modname in filemods:

            if self.load_file(filepath, modname, force_reload):

                change = True

        return change

    def load_file(self, filepath, modname, force_reload=False):

        """load visual objects from a python file"""

        from logilab.common.modutils import load_module_from_name

        if modname in self._loadedmods:

            return

        self._loadedmods[modname] = {}

        try:

            modified_on = stat(filepath)[-2]

        except OSError:

            # this typically happens on emacs backup files (.#foo.py)

            self.warning('Unable to load %s. It is likely to be a backup file',

                         filepath)

            return False

        if filepath in self._lastmodifs:

            # only load file if it was modified

            if modified_on <= self._lastmodifs[filepath]:

                return

            # if it was modified, unregister all exisiting objects

            # from this module, and keep track of what was unregistered

            unregistered = self.unregister_module_vobjects(modname)

        else:

            unregistered = None

        # load the module

        module = load_module_from_name(modname, use_sys=not force_reload)

        self.load_module(module)

        # if something was unregistered, we need to update places where it was

        # referenced

        if unregistered:

            # oldnew_mapping = {}

            registered = self._loadedmods[modname]

            oldnew_mapping = dict((unregistered[name], registered[name])

                                  for name in unregistered if name in registered)

            self.update_registered_subclasses(oldnew_mapping)

        self._lastmodifs[filepath] = modified_on

        return True

    def load_module(self, module):

        self.info('loading %s', module)

        if hasattr(module, 'registration_callback'):

            module.registration_callback(self)

        else: