# 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

"""

from __future__ import print_function

__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, date

from os import mkdir, chdir, path as osp

from warnings import warn

from six.moves import input

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

STD_BLACKLIST = set(STD_BLACKLIST)

STD_BLACKLIST.add('.tox')

STD_BLACKLIST.add('test')

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

        pass

    def default_log_file(self):

        return None

    def default_stats_file(self):

        return None

def cleanup_sys_modules(config):

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

    for name, mod in list(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.utcnow().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)

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

                if libconfig is not None:  # processing a cube

                    # As of 3.20.3 we no longer use it, but keeping this string

                    # allows developers to run i18ncube with new cubicweb and still

                    # have the right translations at runtime for older versions

                    add_msg(w, 'This %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.values():

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

            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:', end=' ')

        print('schema', end=' ')

        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 = open(schemapot, 'w')

        generate_schema_pot(schemapotstream.write, cubedir=None)

        schemapotstream.close()

        print('TAL', end=' ')

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