"""additional cubicweb-ctl commands and command handlers for cubicweb and cubicweb's

cubes development

: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 datetime import datetime

from os import mkdir, chdir

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

from warnings import warn

from logilab.common import STD_BLACKLIST

from logilab.common.modutils import get_module_files

from logilab.common.textutils import splitstrip

from logilab.common.shellutils import ASK

from logilab.common.clcommands import register_commands

from cubicweb import CW_SOFTWARE_ROOT as BASEDIR, BadCommandUsage, underline_title

from cubicweb.__pkginfo__ import version as cubicwebversion

from cubicweb.toolsutils import Command, copy_skeleton

from cubicweb.web.webconfig import WebConfiguration

from cubicweb.server.serverconfig import ServerConfiguration

class DevCubeConfiguration(ServerConfiguration, WebConfiguration):

    """dummy config to get full library schema and entities"""

    creating = True

    cubicweb_appobject_path = ServerConfiguration.cubicweb_appobject_path | WebConfiguration.cubicweb_appobject_path

    cube_appobject_path = ServerConfiguration.cube_appobject_path | WebConfiguration.cube_appobject_path

    def __init__(self, cube):

        super(DevCubeConfiguration, self).__init__(cube)

        if cube is None:

            self._cubes = ()

        else:

            self._cubes = self.reorder_cubes(self.expand_cubes(self.my_cubes(cube)))

    def my_cubes(self, cube):

        return (cube,) + self.cube_dependencies(cube) + self.cube_recommends(cube)

    @property

    def apphome(self):

        return None

    def main_config_file(self):

        return None

    def init_log(self, debug=None):

        pass

    def load_configuration(self):

        pass

class DevDepConfiguration(DevCubeConfiguration):

    """configuration to use to generate cubicweb po files or to use as "library" configuration

    to filter out message ids from cubicweb and dependencies of a cube

    """

    def my_cubes(self, cube):

        return self.cube_dependencies(cube) + self.cube_recommends(cube)

    def default_log_file(self):

        return None

def cleanup_sys_modules(config):

    # cleanup sys.modules, required when we're updating multiple cubes

    for name, mod in sys.modules.items():

        if mod is None:

            # duh ? logilab.common.os for instance

            del sys.modules[name]

            continue

        if not hasattr(mod, '__file__'):

            continue

        for path in config.vregistry_path():

            if mod.__file__.startswith(path):

                del sys.modules[name]

                break

    # fresh rtags

    from cubicweb import rtags

    from cubicweb.web import uicfg

    rtags.RTAGS[:] = []

    reload(uicfg)

def generate_schema_pot(w, cubedir=None):

    """generate a pot file with schema specific i18n messages

    notice that relation definitions description and static vocabulary

    should be marked using '_' and extracted using xgettext

    """

    from cubicweb.cwvreg import CubicWebVRegistry

    cube = cubedir and split(cubedir)[-1]

    libconfig = DevDepConfiguration(cube)

    libconfig.cleanup_interface_sobjects = False

    cleanup_sys_modules(libconfig)

    if cubedir:

        config = DevCubeConfiguration(cube)

        config.cleanup_interface_sobjects = False

    else:

        config = libconfig

        libconfig = None

    schema = config.load_schema(remove_unused_rtypes=False)

    vreg = CubicWebVRegistry(config)

    # set_schema triggers objects registrations

    vreg.set_schema(schema)

    w(DEFAULT_POT_HEAD)

    _generate_schema_pot(w, vreg, schema, libconfig=libconfig, cube=cube)

def _generate_schema_pot(w, vreg, schema, libconfig=None, cube=None):

    from cubicweb.common.i18n import add_msg

    w('# schema pot file, generated on %s\n' % datetime.now().strftime('%Y-%m-%d %H:%M:%S'))

    w('# \n')

    w('# singular and plural forms for each entity type\n')

    w('\n')

    if libconfig is not None:

        libschema = libconfig.load_schema(remove_unused_rtypes=False)

        entities = [e for e in schema.entities() if not e in libschema]

    else:

        entities = schema.entities()

    done = set()

    for eschema in sorted(entities):

        etype = eschema.type

        add_msg(w, etype)

        add_msg(w, '%s_plural' % etype)

        if not eschema.is_final():

            add_msg(w, 'This %s' % etype)

            add_msg(w, 'New %s' % etype)

            add_msg(w, 'add a %s' % etype)

            add_msg(w, 'remove this %s' % etype)

        if eschema.description and not eschema.description in done:

            done.add(eschema.description)

            add_msg(w, eschema.description)

    w('# subject and object forms for each relation type\n')

    w('# (no object form for final relation types)\n')

    w('\n')

    if libconfig is not None:

        relations = [r for r in schema.relations() if not r in libschema]

    else:

        relations = schema.relations()

    for rschema in sorted(set(relations)):

        rtype = rschema.type

        add_msg(w, rtype)

        done.add(rtype)

        if not (schema.rschema(rtype).is_final() or rschema.symetric):

            add_msg(w, '%s_object' % rtype)

        if rschema.description and rschema.description not in done:

            done.add(rschema.description)

            add_msg(w, rschema.description)

    w('# add related box generated message\n')

    w('\n')

    actionbox = vreg['boxes']['edit_box'][0]

    for eschema in schema.entities():

        if eschema.is_final():

            continue

        for role, rschemas in (('subject', eschema.subject_relations()),

                            ('object', eschema.object_relations())):

            for rschema in rschemas:

                if rschema.is_final():

                    continue

                if libconfig is not None:

                    librschema = libschema.get(rschema)

                for teschema in rschema.targets(eschema, role):

                    if libconfig is not None and librschema is not None:

                        if role == 'subject':

                            subjtype, objtype = eschema, teschema

                        else:

                            subjtype, objtype = teschema, eschema

                        if librschema.has_rdef(subjtype, objtype):

                            continue

                    if actionbox.appearsin_addmenu.etype_get(eschema, rschema,

                                                             role, teschema):

                        if role == 'subject':

                            label = 'add %s %s %s %s' % (eschema, rschema,

                                                         teschema, role)

                            label2 = "creating %s (%s %%(linkto)s %s %s)" % (

                                teschema, eschema, rschema, teschema)

                        else:

                            label = 'add %s %s %s %s' % (teschema, rschema,

                                                         eschema, role)

                            label2 = "creating %s (%s %s %s %%(linkto)s)" % (

                                teschema, teschema, rschema, eschema)

                        add_msg(w, label)

                        add_msg(w, label2)

    #cube = (cube and 'cubes.%s.' % cube or 'cubicweb.')

    done = set()

    if libconfig is not None:

        from cubicweb.cwvreg import CubicWebVRegistry

        libvreg = CubicWebVRegistry(libconfig)

        libvreg.set_schema(libschema) # trigger objects registration

        # prefill done set

        list(_iter_vreg_objids(libvreg, done))

    for objid in _iter_vreg_objids(vreg, done):

        add_msg(w, '%s_description' % objid)

        add_msg(w, objid)

def _iter_vreg_objids(vreg, done, prefix=None):

    for reg, objdict in vreg.items():

        for objects in objdict.values():

            for obj in objects:

                objid = '%s_%s' % (reg, obj.id)

                if objid in done:

                    break

                if obj.property_defs:

                    yield objid

                    done.add(objid)

                    break

def defined_in_library(etype, rtype, tetype, role):

    """return true if the given relation definition exists in cubicweb's library

    """

    if libschema is None:

        return False

    if role == 'subject':

        subjtype, objtype = etype, tetype

    else:

        subjtype, objtype = tetype, etype

    try:

        return libschema.rschema(rtype).has_rdef(subjtype, objtype)

    except KeyError:

        return False

LANGS = ('en', 'fr', 'es')

I18NDIR = join(BASEDIR, 'i18n')

DEFAULT_POT_HEAD = r'''msgid ""

msgstr ""

"Project-Id-Version: cubicweb %s\n"

"PO-Revision-Date: 2008-03-28 18:14+0100\n"

"Last-Translator: Logilab Team <contact@logilab.fr>\n"

"Language-Team: fr <contact@logilab.fr>\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Generated-By: cubicweb-devtools\n"

"Plural-Forms: nplurals=2; plural=(n > 1);\n"

''' % cubicwebversion

class UpdateCubicWebCatalogCommand(Command):

    """Update i18n catalogs for cubicweb library.

    It will regenerate cubicweb/i18n/xx.po files. You'll have then to edit those

    files to add translations of newly added messages.

    """

    name = 'i18ncubicweb'

    def run(self, args):

        """run the command with its specific arguments"""

        if args:

            raise BadCommandUsage('Too much arguments')

        import shutil

        import tempfile

        import yams

        from logilab.common.fileutils import ensure_fs_mode

        from logilab.common.shellutils import globfind, find, rm

        from cubicweb.common.i18n import extract_from_tal, execute

        tempdir = tempfile.mkdtemp()

        potfiles = [join(I18NDIR, 'static-messages.pot')]

        print '-> extract schema messages.'

        schemapot = join(tempdir, 'schema.pot')

        potfiles.append(schemapot)

        # explicit close necessary else the file may not be yet flushed when

        # we'll using it below

        schemapotstream = file(schemapot, 'w')

        generate_schema_pot(schemapotstream.write, cubedir=None)

        schemapotstream.close()

        print '-> extract TAL messages.'

        tali18nfile = join(tempdir, 'tali18n.py')

        extract_from_tal(find(join(BASEDIR, 'web'), ('.py', '.pt')), tali18nfile)

        print '-> generate .pot files.'

        for id, files, lang in [('pycubicweb', get_module_files(BASEDIR) + list(globfind(join(BASEDIR, 'misc', 'migration'), '*.py')), None),

                                ('schemadescr', globfind(join(BASEDIR, 'schemas'), '*.py'), None),

                                ('yams', get_module_files(yams.__path__[0]), None),

                                ('tal', [tali18nfile], None),

                                ('js', globfind(join(BASEDIR, 'web'), 'cub*.js'), 'java'),

                                ]:

            cmd = 'xgettext --no-location --omit-header -k_ -o %s %s'

            if lang is not None:

                cmd += ' -L %s' % lang

            potfile = join(tempdir, '%s.pot' % id)

            execute(cmd % (potfile, ' '.join(files)))

            if exists(potfile):

                potfiles.append(potfile)

            else:

                print '-> WARNING: %s file was not generated' % potfile

        print '-> merging %i .pot files' % len(potfiles)

        cubicwebpot = join(tempdir, 'cubicweb.pot')

        execute('msgcat %s > %s' % (' '.join(potfiles), cubicwebpot))

        print '-> merging main pot file with existing translations.'

        chdir(I18NDIR)

        toedit = []

        for lang in LANGS:

            target = '%s.po' % lang

            execute('msgmerge -N --sort-output  %s %s > %snew' % (target, cubicwebpot, target))

            ensure_fs_mode(target)

            shutil.move('%snew' % target, target)

            toedit.append(abspath(target))

        # cleanup

        rm(tempdir)

        # instructions pour la suite

        print '-> regenerated CubicWeb\'s .po catalogs.'

        print '\nYou can now edit the following files:'

        print '* ' + '\n* '.join(toedit)

        print 'when you are done, run "cubicweb-ctl i18ncube yourcube".'

class UpdateTemplateCatalogCommand(Command):

    """Update i18n catalogs for cubes. If no cube is specified, update

    catalogs of all registered cubes.

    """

    name = 'i18ncube'

    arguments = '[<cube>...]'

    def run(self, args):

        """run the command with its specific arguments"""

        if args:

            cubes = [DevCubeConfiguration.cube_dir(cube) for cube in args]

        else:

            cubes = [DevCubeConfiguration.cube_dir(cube) for cube in DevCubeConfiguration.available_cubes()]

            cubes = [cubepath for cubepath in cubes if exists(join(cubepath, 'i18n'))]

        update_cubes_catalogs(cubes)

def update_cubes_catalogs(cubes):

    for cubedir in cubes:

        toedit = []

        if not isdir(cubedir):

            print '-> ignoring %s that is not a directory.' % cubedir

            continue

        try:

            toedit += update_cube_catalogs(cubedir)

        except Exception:

            import traceback

            traceback.print_exc()

            print '-> error while updating catalogs for cube', cubedir

        else:

            # instructions pour la suite

            print '-> regenerated .po catalogs for cube %s.' % cubedir

            print '\nYou can now edit the following files:'

            print '* ' + '\n* '.join(toedit)

            print ('When you are done, run "cubicweb-ctl i18ninstance '

                   '<yourinstance>" to see changes in your instances.')

def update_cube_catalogs(cubedir):

    import shutil

    import tempfile

    from logilab.common.fileutils import ensure_fs_mode

    from logilab.common.shellutils import find, rm

    from cubicweb.common.i18n import extract_from_tal, execute

    toedit = []

    cube = basename(normpath(cubedir))

    tempdir = tempfile.mkdtemp()

    print underline_title('Updating i18n catalogs for cube %s' % cube)

    chdir(cubedir)

    if exists(join('i18n', 'entities.pot')):

        warn('entities.pot is deprecated, rename file to static-messages.pot (%s)'

             % join('i18n', 'entities.pot'), DeprecationWarning)

        potfiles = [join('i18n', 'entities.pot')]

    elif exists(join('i18n', 'static-messages.pot')):

        potfiles = [join('i18n', 'static-messages.pot')]

    else:

        potfiles = []

    print '-> extract schema messages'

    schemapot = join(tempdir, 'schema.pot')

    potfiles.append(schemapot)

    # explicit close necessary else the file may not be yet flushed when

    # we'll using it below

    schemapotstream = file(schemapot, 'w')