"""common configuration utilities for cubicweb

:organization: Logilab

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

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

"""

__docformat__ = "restructuredtext en"

import sys

import os

import logging

from os.path import exists, join, expanduser, abspath, basename

from logilab.common.decorators import cached

from logilab.common.logging_ext import set_log_methods, init_log

from logilab.common.configuration import (Configuration, Method,

                                          ConfigurationMixIn, merge_options)

from cubicweb import CW_SOFTWARE_ROOT, CW_MIGRATION_MAP, ConfigurationError

from cubicweb.toolsutils import env_path, read_config, create_dir

CONFIGURATIONS = []

_ = unicode

class metaconfiguration(type):

    """metaclass to automaticaly register configuration"""

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

        cls = super(metaconfiguration, mcs).__new__(mcs, name, bases, classdict)

        if classdict.get('name'):

            CONFIGURATIONS.append(cls)

        return cls

def configuration_cls(name):

    """return the configuration class registered with the given name"""

    try:

        return [c for c in CONFIGURATIONS if c.name == name][0]

    except IndexError:

        raise ConfigurationError('no such config %r (check it exists with "cubicweb-ctl list")' % name)

def possible_configurations(directory):

    """return a list of installed configurations in a directory

    according to *-ctl files

    """

    return [name for name in ('repository', 'twisted', 'all-in-one')

            if exists(join(directory, '%s.conf' % name))]

def guess_configuration(directory):

    """try to guess the configuration to use for a directory. If multiple

    configurations are found, ConfigurationError is raised

    """

    modes = possible_configurations(directory)

    if len(modes) != 1:

        raise ConfigurationError('unable to guess configuration from %r %s'

                                 % (directory, modes))

    return modes[0]

# XXX generate this according to the configuration (repository/all-in-one/web)

VREGOPTIONS = []

for registry in ('etypes', 'hooks', 'controllers', 'actions', 'components',

                 'views', 'templates', 'boxes', 'contentnavigation', 'urlrewriting',

                 'facets'):

    VREGOPTIONS.append(('disable-%s'%registry,

                        {'type' : 'csv', 'default': (),

                         'help': 'list of identifier of application objects from the %s registry to disable'%registry,

                         'group': 'appobjects', 'inputlevel': 2,

                         }))

VREGOPTIONS = tuple(VREGOPTIONS)

# persistent options definition

PERSISTENT_OPTIONS = (

    ('encoding',

     {'type' : 'string',

      'default': 'UTF-8',

      'help': _('user interface encoding'),

      'group': 'ui', 'sitewide': True,

      }),    

    ('language',

     {'type' : 'string',

      'default': 'en',

      'vocabulary': Method('available_languages'),

      'help': _('language of the user interface'),

      'group': 'ui', 

      }),

    ('date-format',

     {'type' : 'string',

      'default': '%Y/%m/%d',

      'help': _('how to format date in the ui ("man strftime" for format description)'),

      'group': 'ui', 

      }),

    ('datetime-format',

     {'type' : 'string',

      'default': '%Y/%m/%d %H:%M',

      'help': _('how to format date and time in the ui ("man strftime" for format description)'),

      'group': 'ui', 

      }),

    ('time-format',

     {'type' : 'string',

      'default': '%H:%M',

      'help': _('how to format time in the ui ("man strftime" for format description)'),

      'group': 'ui', 

      }),

    ('float-format',

     {'type' : 'string',

      'default': '%.3f',

      'help': _('how to format float numbers in the ui'),

      'group': 'ui', 

      }),

    ('default-text-format',

     {'type' : 'choice',

      'choices': ('text/plain', 'text/rest', 'text/html'),

      'default': 'text/html', # use fckeditor in the web ui

      'help': _('default text format for rich text fields.'),

      'group': 'ui', 

      }),

    ('short-line-size',

     {'type' : 'int',

      'default': 40,

      'help': _('maximum number of characters in short description'),

      'group': 'navigation',

      }),

    )

def register_persistent_options(options):

    global PERSISTENT_OPTIONS

    PERSISTENT_OPTIONS = merge_options(PERSISTENT_OPTIONS + options)

CFGTYPE2ETYPE_MAP = {

    'string': 'String',

    'choice': 'String',

    'yn':     'Boolean',

    'int':    'Int',

    'float' : 'Float',

    }

class CubicWebNoAppConfiguration(ConfigurationMixIn):

    """base class for cubicweb configuration without a specific instance directory

    """

    __metaclass__ = metaconfiguration

    # to set in concrete configuration

    name = None

    # log messages format (see logging module documentation for available keys)

    log_format = '%(asctime)s - (%(name)s) %(levelname)s: %(message)s'

    # nor remove vobjects based on unused interface

    cleanup_interface_sobjects = True

    if os.environ.get('APYCOT_ROOT'):

        mode = 'test'

        CUBES_DIR = '%(APYCOT_ROOT)s/local/share/cubicweb/cubes/' % os.environ

    elif exists(join(CW_SOFTWARE_ROOT, '.hg')):

        mode = 'dev'

        CUBES_DIR = join(CW_SOFTWARE_ROOT, '../cubes')

    else:

        mode = 'installed'

        CUBES_DIR = '/usr/share/cubicweb/cubes/'

    options = VREGOPTIONS + (

       ('log-threshold',

         {'type' : 'string', # XXX use a dedicated type?

          'default': 'ERROR',

          'help': 'server\'s log level',

          'group': 'main', 'inputlevel': 1,

          }),

        # pyro name server

        ('pyro-ns-host',

         {'type' : 'string',

          'help': 'Pyro name server\'s host. If not set, will be detected by a \

broadcast query',

          'group': 'pyro-name-server', 'inputlevel': 1,

          }),

        ('pyro-ns-port',

         {'type' : 'int',

          'default': None,

          'help': 'Pyro name server\'s listening port. If not set, default \

port will be used.',

          'group': 'pyro-name-server', 'inputlevel': 1,

          }),

        ('pyro-ns-group',

         {'type' : 'string',

          'default': 'cubicweb',

          'help': 'Pyro name server\'s group where the repository will be \

registered.',

          'group': 'pyro-name-server', 'inputlevel': 1,

          }),

        # common configuration options which are potentially required as soon as

        # you're using "base" application objects (ie to really server/web

        # specific)

        ('base-url',

         {'type' : 'string',

          'default': None,

          'help': 'web server root url',

          'group': 'main', 'inputlevel': 1,

          }),

        ('mangle-emails',

         {'type' : 'yn',

          'default': False,

          'help': "don't display actual email addresses but mangle them if \

this option is set to yes",

          'group': 'email', 'inputlevel': 2,

          }),

        )

    # static and class methods used to get application independant resources ##

    @staticmethod

    def cubicweb_version():

        """return installed cubicweb version"""

        from logilab.common.changelog import Version

        from cubicweb import __pkginfo__

        version = __pkginfo__.numversion

        assert len(version) == 3, version

        return Version(version)

    @staticmethod

    def persistent_options_configuration():

        return Configuration(options=PERSISTENT_OPTIONS)

    @classmethod

    def shared_dir(cls):

        """return the shared data directory (i.e. directory where standard

        library views and data may be found)

        """

        if cls.mode in ('dev', 'test') and not os.environ.get('APYCOT_ROOT'):

            return join(CW_SOFTWARE_ROOT, 'web')

        return join(cls.cubes_dir(), 'shared')

    @classmethod

    def i18n_lib_dir(cls):

        """return application's i18n directory"""

        if cls.mode in ('dev', 'test') and not os.environ.get('APYCOT_ROOT'):

            return join(CW_SOFTWARE_ROOT, 'i18n')

        return join(cls.shared_dir(), 'i18n')

    @classmethod

    def available_cubes(cls):

        cubes_dir = cls.cubes_dir()

        return sorted(cube for cube in os.listdir(cubes_dir)

                      if os.path.isdir(os.path.join(cubes_dir, cube))

                      and not cube in ('CVS', '.svn', 'shared', '.hg'))

    @classmethod

    def cubes_dir(cls):

        """return the application cubes directory"""

        return env_path('CW_CUBES', cls.CUBES_DIR, 'cubes')

    @classmethod

    def cube_dir(cls, cube):

        """return the cube directory for the given cube id,

        raise ConfigurationError if it doesn't exists

        """

        cube_dir = join(cls.cubes_dir(), cube)

        if not exists(cube_dir):

            raise ConfigurationError('no cube %s in %s' % (

                cube, cls.cubes_dir()))

        return cube_dir

    @classmethod

    def cube_migration_scripts_dir(cls, cube):

        """cube migration scripts directory"""

        return join(cls.cube_dir(cube), 'migration')

    @classmethod

    def cube_pkginfo(cls, cube):

        """return the information module for the given cube"""

        cube = CW_MIGRATION_MAP.get(cube, cube)

        try:

            return getattr(__import__('cubes.%s.__pkginfo__' % cube), cube).__pkginfo__

        except Exception, ex:

            raise ConfigurationError('unable to find packaging information for '

                                     'cube %s (%s: %s)' % (cube, ex.__class__.__name__, ex))

    @classmethod

    def cube_version(cls, cube):

        """return the version of the cube located in the given directory        

        """

        from logilab.common.changelog import Version

        version = cls.cube_pkginfo(cube).numversion

        assert len(version) == 3, version

        return Version(version)

    @classmethod

    def cube_dependencies(cls, cube):

        """return cubicweb cubes used by the given cube"""

        return getattr(cls.cube_pkginfo(cube), '__use__', ())

    @classmethod

    def cube_recommends(cls, cube):

        """return cubicweb cubes recommended by the given cube"""

        return getattr(cls.cube_pkginfo(cube), '__recommend__', ())

    @classmethod

    def expand_cubes(cls, cubes):

        """expand the given list of top level cubes used by adding recursivly

        each cube dependencies

        """

        cubes = list(cubes)

        todo = cubes[:]

        while todo:

            cube = todo.pop(0)

            for depcube in cls.cube_dependencies(cube):

                if depcube not in cubes:

                    depcube = CW_MIGRATION_MAP.get(depcube, depcube)

                    cubes.append(depcube)

                    todo.append(depcube)

        return cubes

    @classmethod

    def reorder_cubes(cls, cubes):

        """reorder cubes from the top level cubes to inner dependencies

        cubes

        """

        from logilab.common.graph import get_cycles

        graph = {}

        for cube in cubes:

            cube = CW_MIGRATION_MAP.get(cube, cube)

            deps = cls.cube_dependencies(cube) + \

                   cls.cube_recommends(cube)

            graph[cube] = set(dep for dep in deps if dep in cubes)

        cycles = get_cycles(graph)

        if cycles:

            cycles = '\n'.join(' -> '.join(cycle) for cycle in cycles)

            raise ConfigurationError('cycles in cubes dependencies: %s'

                                     % cycles)

        cubes = []

        while graph:

            # sorted to get predictable results

            for cube, deps in sorted(graph.items()):

                if not deps:

                    cubes.append(cube)

                    del graph[cube]

                    for deps in graph.itervalues():

                        try:

                            deps.remove(cube)

                        except KeyError:

                            continue

        return tuple(reversed(cubes))

    @classmethod

    def cls_adjust_sys_path(cls):

        """update python path if necessary"""

        try:

            templdir = abspath(join(cls.cubes_dir(), '..'))

            if not templdir in sys.path:

                sys.path.insert(0, templdir)

        except ConfigurationError:

            return # cube dir doesn't exists

    @classmethod

    def load_cwctl_plugins(cls):

        from logilab.common.modutils import load_module_from_file

        cls.cls_adjust_sys_path()

        for ctlfile in ('web/webctl.py',  'etwist/twctl.py',

                        'server/serverctl.py', 'hercule.py',

                        'devtools/devctl.py', 'goa/goactl.py'):

            if exists(join(CW_SOFTWARE_ROOT, ctlfile)):

                load_module_from_file(join(CW_SOFTWARE_ROOT, ctlfile))

                cls.info('loaded cubicweb-ctl plugin %s', ctlfile)

        templdir = cls.cubes_dir()

        for cube in cls.available_cubes():

            pluginfile = join(templdir, cube, 'ecplugin.py')

            initfile = join(templdir, cube, '__init__.py')

            if exists(pluginfile):

                try:

                    __import__('cubes.%s.ecplugin' % cube)

                    cls.info('loaded cubicweb-ctl plugin from %s', cube)

                except:

                    cls.exception('while loading plugin %s', pluginfile)

            elif exists(initfile):

                try:

                    __import__('cubes.%s' % cube)

                except:

                    cls.exception('while loading cube %s', cube)

            else:

                cls.warning('no __init__ file in cube %s', cube) 

    @classmethod

    def init_available_cubes(cls):

        """cubes may register some sources (svnfile for instance) in their

        __init__ file, so they should be loaded early in the startup process

        """

        for cube in cls.available_cubes():

            try:

                __import__('cubes.%s' % cube)

            except Exception, ex:

                cls.warning("can't init cube %s: %s", cube, ex)

    cubicweb_vobject_path = set(['entities'])

    cube_vobject_path = set(['entities'])

    @classmethod

    def build_vregistry_path(cls, templpath, evobjpath=None, tvobjpath=None):

        """given a list of directories, return a list of sub files and

        directories that should be loaded by the application objects registry.

        :param evobjpath:

          optional list of sub-directories (or files without the .py ext) of

          the cubicweb library that should be tested and added to the output list

          if they exists. If not give, default to `cubicweb_vobject_path` class

          attribute.

        :param tvobjpath:

          optional list of sub-directories (or files without the .py ext) of

          directories given in `templpath` that should be tested and added to

          the output list if they exists. If not give, default to

          `cube_vobject_path` class attribute.

        """

        vregpath = cls.build_vregistry_cubicweb_path(evobjpath)

        vregpath += cls.build_vregistry_cube_path(templpath, tvobjpath)