# -*- coding: utf-8 -*-

"""common configuration utilities for cubicweb

:organization: Logilab

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

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

.. envvar:: CW_CUBES_PATH

   Augments the default search path for cubes

"""

__docformat__ = "restructuredtext en"

_ = unicode

import sys

import os

import logging

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

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, create_dir

CONFIGURATIONS = []

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]

# 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

        # create __init__ file

        file(join(CUBES_DIR, '__init__.py'), 'w').close()

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

        mode = 'dev'

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

    else:

        mode = 'installed'

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

    options = (

       ('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',

          'default': '',

          '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,

          }),

        ('use-request-subdomain',

         {'type' : 'yn',

          'default': None,

          'help': ('if set, base-url subdomain is replaced by the request\'s '

                   'host, to help managing sites with several subdomains in a '

                   'single cubicweb instance'),

          '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,

          }),

        ('disable-appobjects',

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

          'help': 'comma separated list of identifiers of application objects (<registry>.<oid>) to disable',

          'group': 'appobjects', '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 cls.cube_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 = set()

        for directory in cls.cubes_search_path():

            for cube in os.listdir(directory):

                if isdir(join(directory, cube)) and not cube in ('CVS', '.svn', 'shared', '.hg'):

                    cubes.add(cube)

        return sorted(cubes)

    @classmethod

    def cubes_search_path(cls):

        """return the path of directories where cubes should be searched"""

        path = []

        try:

            for directory in os.environ['CW_CUBES_PATH'].split(os.pathsep):

                directory = abspath(normpath(directory))

                if exists(directory) and not directory in path:

                    path.append(directory)

        except KeyError:

            pass

        if not cls.CUBES_DIR in path:

            path.append(cls.CUBES_DIR)

        return path

    @classmethod

    def cube_dir(cls, cube):

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

        raise ConfigurationError if it doesn't exists

        """

        for directory in cls.cubes_search_path():

            cubedir = join(directory, cube)

            if exists(cubedir):

                return cubedir

        raise ConfigurationError('no cube %s in %s' % (cube, cls.cubes_search_path()))

    @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"""

        cubes_parent_dir = normpath(join(cls.CUBES_DIR, '..'))

        if not cubes_parent_dir in sys.path:

            sys.path.insert(0, cubes_parent_dir)

        try:

            import cubes

            cubes.__path__ = cls.cubes_search_path()

        except ImportError:

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

        for cube in cls.available_cubes():

            pluginfile = join(cls.cube_dir(cube), 'ecplugin.py')

            initfile = join(cls.cube_dir(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):