# copyright 2003-2013 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/>.

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

cubicweb's cubes development

"""

__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, path as osp

from warnings import warn

from logilab.common import STD_BLACKLIST

from cubicweb.__pkginfo__ import version as cubicwebversion

from cubicweb import CW_SOFTWARE_ROOT as BASEDIR, BadCommandUsage, ExecutionError

from cubicweb.cwctl import CWCTL

from cubicweb.cwconfig import CubicWebNoAppConfiguration

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_unused_appobjects = 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 available_languages(self):

        return self.cw_languages()

    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

        if mod.__file__ is None:

            # odd/rare but real

            continue

        for path in config.appobjects_path():

            if mod.__file__.startswith(path):

                del sys.modules[name]

                break

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 CWRegistryStore

    if cubedir:

        cube = osp.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 = CWRegistryStore(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 cubicweb.i18n import add_msg

    from cubicweb.schema import NO_I18NCONTEXT, CONSTRAINTS

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

    afss = vreg['uicfg']['autoform_section']

    aiams = vreg['uicfg']['actionbox_appearsin_addmenu']

    if libconfig is not None:

        # processing a cube, libconfig being a config with all its dependencies

        # (cubicweb incl.)

        from cubicweb.cwvreg import CWRegistryStore

        libschema = libconfig.load_schema(remove_unused_rtypes=False)

        cleanup_sys_modules(libconfig)

        libvreg = CWRegistryStore(libconfig)

        libvreg.set_schema(libschema) # trigger objects registration

        libafss = libvreg['uicfg']['autoform_section']

        libaiams = libvreg['uicfg']['actionbox_appearsin_addmenu']

        # prefill vregdone set

        list(_iter_vreg_objids(libvreg, vregdone))

        def is_in_lib(rtags, eschema, rschema, role, tschema, predicate=bool):

            return any(predicate(rtag.etype_get(eschema, rschema, role, tschema))

                       for rtag in rtags)

    else:

        # processing cubicweb itself

        libschema = {}

        for cstrtype in CONSTRAINTS:

            add_msg(w, cstrtype)

        libafss = libaiams = None

        is_in_lib = lambda *args: False

    done = set()

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

        if eschema.type in libschema:

            done.add(eschema.description)

    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:

                for afs in afss:

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

                    if 'main_inlined' in fsections and not \

                            is_in_lib(libafss, eschema, rschema, role, tschema,

                                      lambda x: 'main_inlined' in x):

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

                        break

                for aiam in aiams:

                    if aiam.etype_get(eschema, rschema, role, tschema) and not \

                            is_in_lib(libaiams, eschema, rschema, role, tschema):

                        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)

                        break

            # 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()):

        if rschema.type in libschema:

            done.add(rschema.type)

            done.add(rschema.description)

    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)

            done.add(rtype)

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

                add_msg(w, rschema.description)

            done.add(rschema.description)

            librschema = None

        else:

            librschema = libschema.rschema(rtype)

        # add context information only for non-metadata rtypes

        if rschema not in NO_I18NCONTEXT:

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

            for subjschema in rschema.subjects():

                if not subjschema in libsubjects:

                    add_msg(w, rtype, subjschema.type)

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

            if rschema not in NO_I18NCONTEXT:

                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 rdef in rschema.rdefs.itervalues():

            if not rdef.description or rdef.description in done:

                continue

            if (librschema is None or

                (rdef.subject, rdef.object) not in librschema.rdefs or

                librschema.rdefs[(rdef.subject, rdef.object)].description != rdef.description):

                add_msg(w, rdef.description)

            done.add(rdef.description)

    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():

        if reg in ('boxes', 'contentnavigation'):

            continue

        for objects in objdict.itervalues():

            for obj in objects:

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

                if objid in done:

                    break

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

                if pdefs:

                    yield objid

                    done.add(objid)

                    break

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'

    min_args = max_args = 0

    def run(self, args):

        """run the command with its specific 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, execute2

        tempdir = tempfile.mkdtemp(prefix='cw-')

        cwi18ndir = WebConfiguration.i18n_lib_dir()

        print '-> extract messages:',

        print 'schema',

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

        potfiles = [schemapot]

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

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

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

                         tali18nfile)

        print '-> generate .pot files.'

        pyfiles = get_module_files(BASEDIR)

        pyfiles += globfind(osp.join(BASEDIR, 'misc', 'migration'), '*.py')

        schemafiles = globfind(osp.join(BASEDIR, 'schemas'), '*.py')

        jsfiles = globfind(osp.join(BASEDIR, 'web'), 'cub*.js')

        for id, files, lang in [('pycubicweb', pyfiles, None),

                                ('schemadescr', schemafiles, None),

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

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

                                ('js', jsfiles, 'java'),

                                ]:

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

            cmd = ['xgettext', '--no-location', '--omit-header', '-k_']

            if lang is not None:

                cmd.extend(['-L', lang])

            cmd.extend(['-o', potfile])

            cmd.extend(files)

            execute2(cmd)

            if osp.exists(potfile):

                potfiles.append(potfile)

            else:

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

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

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

        cmd = ['msgcat', '-o', cubicwebpot] + potfiles

        execute2(cmd)

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

        chdir(cwi18ndir)

        toedit = []

        for lang in CubicWebNoAppConfiguration.cw_languages():

            target = '%s.po' % lang

            cmd = ['msgmerge', '-N', '--sort-output', '-o',

                   target+'new', target, cubicwebpot]

            execute2(cmd)

            ensure_fs_mode(target)

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

            toedit.append(osp.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 UpdateCubeCatalogCommand(Command):