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

"""common configuration utilities for cubicweb

:organization: Logilab

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

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

.. envvar:: CW_CUBES_PATH

   Augments the default search path for cubes

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

"""

__docformat__ = "restructuredtext en"

_ = unicode

import sys

import os

import logging

from smtplib import SMTP

from threading import Lock

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

import tempfile

from logilab.common.decorators import cached

from logilab.common.deprecation import deprecated

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 = []

SMTP_LOCK = Lock()

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

    }

_forced_mode = os.environ.get('CW_MODE')

assert _forced_mode in (None, 'system', 'user')

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 appobjects 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')) and _forced_mode != 'system') or _forced_mode == 'user':

        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. It may contains port information using <host>:<port> notation.',

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

          }),

        ('allow-email-login',

         {'type' : 'yn',

          'default': False,

          'help': 'allow users to login with their primary email if set',

          'group': 'main', 'inputlevel': 2,

          }),

        ('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 instance 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 instance'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, with_recommends=False):

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

            if with_recommends:

                for depcube in cls.cube_recommends(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)):

                try:

                    load_module_from_file(join(CW_SOFTWARE_ROOT, ctlfile))

                except ImportError, err:

                    cls.critical('could not import the command provider %s (cause : %s)' %