# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

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

#

# This file is part of CubicWeb.

#

# CubicWeb is free software: you can redistribute it and/or modify it under the

# terms of the GNU Lesser General Public License as published by the Free

# Software Foundation, either version 2.1 of the License, or (at your option)

# any later version.

#

# CubicWeb is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more

# details.

#

# You should have received a copy of the GNU Lesser General Public License along

# with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

__docformat__ = "restructuredtext en"

# *ctl module should limit the number of import to be imported as quickly as

# possible (for cubicweb-ctl reactivity, necessary for instance for usable bash

# completion). So import locally in command helpers.

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.clcommands import register_commands, pop_arg

from cubicweb.__pkginfo__ import version as cubicwebversion

from cubicweb import CW_SOFTWARE_ROOT as BASEDIR, BadCommandUsage

from cubicweb.toolsutils import (SKEL_EXCLUDE, Command,

                                 copy_skeleton, underline_title)

from cubicweb.web.webconfig import WebConfiguration

from cubicweb.server.serverconfig import ServerConfiguration

class DevConfiguration(ServerConfiguration, WebConfiguration):

    """dummy config to get full library schema and appobjects for

    a cube or for cubicweb (without a home)

    """

    creating = True

    cleanup_interface_sobjects = False

    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, *cubes):

        super(DevConfiguration, self).__init__(cubes and cubes[0] or None)

        if cubes:

            self._cubes = self.reorder_cubes(

                self.expand_cubes(cubes, with_recommends=True))

            self.load_site_cubicweb()

        else:

            self._cubes = ()

    @property

    def apphome(self):

        return None

    def main_config_file(self):

        return None

    def init_log(self):

        pass

    def load_configuration(self):

        pass

    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

    if cubedir:

        cube = split(cubedir)[-1]

        config = DevConfiguration(cube)

        depcubes = list(config._cubes)

        depcubes.remove(cube)

        libconfig = DevConfiguration(*depcubes)

    else:

        config = DevConfiguration()

        cube = libconfig = None

    cleanup_sys_modules(config)

    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)

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

    from copy import deepcopy

    from cubicweb.i18n import add_msg

    from cubicweb.web import uicfg

    from cubicweb.schema import META_RTYPES, SYSTEM_RTYPES, CONSTRAINTS

    no_context_rtypes = META_RTYPES | SYSTEM_RTYPES

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

    vregdone = set()

    if libconfig is not None:

        from cubicweb.cwvreg import CubicWebVRegistry, clear_rtag_objects

        libschema = libconfig.load_schema(remove_unused_rtypes=False)

        afs = deepcopy(uicfg.autoform_section)

        appearsin_addmenu = deepcopy(uicfg.actionbox_appearsin_addmenu)

        clear_rtag_objects()

        cleanup_sys_modules(libconfig)

        libvreg = CubicWebVRegistry(libconfig)

        libvreg.set_schema(libschema) # trigger objects registration

        libafs = uicfg.autoform_section

        libappearsin_addmenu = uicfg.actionbox_appearsin_addmenu

        # prefill vregdone set

        list(_iter_vreg_objids(libvreg, vregdone))

    else:

        libschema = {}

        afs = uicfg.autoform_section

        appearsin_addmenu = uicfg.actionbox_appearsin_addmenu

        for cstrtype in CONSTRAINTS:

            add_msg(w, cstrtype)

    done = set()

    for eschema in sorted(schema.entities()):

        etype = eschema.type

        if etype not in libschema:

            add_msg(w, etype)

            add_msg(w, '%s_plural' % etype)

            if not eschema.final:

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

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

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

                done.add(eschema.description)

                add_msg(w, eschema.description)

        if eschema.final:

            continue

        for rschema, targetschemas, role in eschema.relation_definitions(True):

            if rschema.final:

                continue

            for tschema in targetschemas:

                fsections = afs.etype_get(eschema, rschema, role, tschema)

                if 'main_inlined' in fsections and \

                       (libconfig is None or not

                        'main_inlined' in libafs.etype_get(

                            eschema, rschema, role, tschema)):

                    add_msg(w, 'add a %s' % tschema,

                            'inlined:%s.%s.%s' % (etype, rschema, role))

                    add_msg(w, str(tschema),

                            'inlined:%s.%s.%s' % (etype, rschema, role))

                if appearsin_addmenu.etype_get(eschema, rschema, role, tschema):

                    if libconfig is not None and libappearsin_addmenu.etype_get(eschema, rschema, role, tschema):

                        if eschema in libschema and tschema in libschema:

                            continue

                    if role == 'subject':

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

                                                     tschema, role)

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

                            tschema, eschema, rschema, tschema)

                    else:

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

                                                     eschema, role)

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

                            tschema, tschema, rschema, eschema)

                    add_msg(w, label)

                    add_msg(w, label2)

            # XXX also generate "creating ...' messages for actions in the

            # addrelated submenu

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

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

    w('\n')

    for rschema in sorted(schema.relations()):

        rtype = rschema.type

        if rtype not in libschema:

            # bw compat, necessary until all translation of relation are done properly...

            add_msg(w, rtype)

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

                done.add(rschema.description)

                add_msg(w, rschema.description)

            done.add(rtype)

            librschema = None

        else:

            librschema = libschema.rschema(rtype)

        # add context information only for non-metadata rtypes

        if rschema not in no_context_rtypes:

            libsubjects = librschema and librschema.subjects() or ()

            for subjschema in rschema.subjects():

                if not subjschema in libsubjects:

                    add_msg(w, rtype, subjschema.type)

        if not (schema.rschema(rtype).final or rschema.symmetric):

            if rschema not in no_context_rtypes:

                libobjects = librschema and librschema.objects() or ()

                for objschema in rschema.objects():

                    if not objschema in libobjects:

                        add_msg(w, '%s_object' % rtype, objschema.type)

            if rtype not in libschema:

                # bw compat, necessary until all translation of relation are done properly...

                add_msg(w, '%s_object' % rtype)

    for objid in _iter_vreg_objids(vreg, vregdone):

        add_msg(w, '%s_description' % objid)

        add_msg(w, objid)

def _iter_vreg_objids(vreg, done):

    for reg, objdict in vreg.items():

        for objects in objdict.values():

            for obj in objects:

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

                if objid in done:

                    break

                try: # XXX < 3.6 bw compat

                    pdefs = obj.property_defs

                except AttributeError:

                    pdefs = getattr(obj, 'cw_property_defs', {})

                if pdefs:

                    yield objid

                    done.add(objid)

                    break

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 logilab.common.modutils import get_module_files

        from cubicweb.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('"%s"' % f for f in 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 -o %s %s' % (cubicwebpot, ' '.join('"%s"' % f for f in potfiles)))

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

        chdir(I18NDIR)

        toedit = []

        for lang in LANGS:

            target = '%s.po' % lang

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

            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 = [DevConfiguration.cube_dir(cube) for cube in args]

        else:

            cubes = [DevConfiguration.cube_dir(cube)

                     for cube in DevConfiguration.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:

        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

            if toedit:

                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.')