import argparse
import logging
import sys
import textwrap
from pathlib import Path

from odoo import SUPERUSER_ID
from odoo.api import Environment
from odoo.cli.command import Command
from odoo.fields import Domain
from odoo.modules import get_module_path
from odoo.modules.registry import Registry
from odoo.tools import OrderedSet, config
from odoo.tools.translate import TranslationImporter, load_language, trans_export

_logger = logging.getLogger(__name__)

EXPORT_EXTENSIONS = ['.po', '.pot', '.tgz', '.csv']
IMPORT_EXTENSIONS = ['.po', '.csv']


class SubcommandHelpFormatter(argparse.RawTextHelpFormatter):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs, max_help_position=80)


class I18n(Command):
    """ Import, export, setup languages and internationalization files """

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        subparsers = self.parser.add_subparsers(
            dest='subcommand', required=True,
            help='Subcommands help')

        self.import_parser = subparsers.add_parser(
            'import',
            help="Import i18n files",
            description="Imports provided translation files",
            formatter_class=SubcommandHelpFormatter,
        )
        self.export_parser = subparsers.add_parser(
            'export',
            help="Export i18n files",
            description="Exports language files into the i18n folder of each module",
            formatter_class=SubcommandHelpFormatter,
        )
        self.loadlang_parser = subparsers.add_parser(
            'loadlang',
            help="Load languages",
            description="Loads languages",
            formatter_class=SubcommandHelpFormatter,
        )

        for parser in (self.import_parser, self.export_parser, self.loadlang_parser):
            parser.add_argument(
                '-c', '--config', dest='config',
                help="use a specific configuration file")
            parser.add_argument(
                '-d', '--database', dest='db_name', default=None,
                help="database name, connection details will be taken from the config file")
            parser.epilog = textwrap.dedent("""\
                Language codes must follow the XPG (POSIX) locale format.
                see: https://www.gnu.org/software/libc/manual/html_node/Locale-Names.html

                To list available codes, you can search them querying the database:
                    $ psql -d <dbname> -c "SELECT iso_code FROM res_lang ORDER BY iso_code"

                Examples:
                    odoo-bin i18n loadlang -l en         # English (U.S.)
                    odoo-bin i18n loadlang -l es es_AR   # Spanish (Spain, Argentina)
                    odoo-bin i18n loadlang -l sr@latin   # Serbian (Latin)
            """)

        self.import_parser.add_argument(
            'files', nargs='+', metavar='FILE', type=Path,
            help=f"files to be imported. Allowed extensions: {', '.join(IMPORT_EXTENSIONS)}\n")
        self.import_parser.add_argument(
            '-w', '--overwrite', action='store_true',
            help="overwrite existing terms")
        self.import_parser.add_argument(
            '-l', '--language', dest='language', metavar='LANG', required=True,
            help="language code")

        self.export_parser.add_argument(
            '-l', '--languages', dest='languages', nargs='+', default=['pot'], metavar='LANG',
            help="list of language codes, 'pot' for template (default)")
        self.export_parser.add_argument(
            'modules', nargs='+', metavar='MODULE',
            help="modules to be exported")
        self.export_parser.add_argument(
            '-o', '--output', metavar="FILE", dest='output',
            help=(
                "output only one file with translations from all provided modules\n"
                f"allowed extensions: {', '.join(EXPORT_EXTENSIONS)},"
                " '-' writes a '.po' file to stdout\n"
                "only one language is allowed when this option is active"
            ),
        )

        self.loadlang_parser.add_argument(
            '-l', '--languages', dest='languages', nargs='+', metavar='LANG',
            help="List of language codes to install")

    def run(self, cmdargs):
        parsed_args = self.parser.parse_args(args=cmdargs)

        config_args = ['--no-http']
        if parsed_args.config:
            config_args += ['-c', parsed_args.config]
        if parsed_args.db_name:
            config_args += ['-d', parsed_args.db_name]

        config.parse_config(config_args, setup_logging=True)

        db_names = config['db_name']
        if not db_names or len(db_names) > 1:
            self.parser.error("Please provide a single database in the config file")
        parsed_args.db_name = db_names[0]

        match parsed_args.subcommand:
            case 'import':
                self._import(parsed_args)
            case 'export':
                self._export(parsed_args)
            case 'loadlang':
                self._loadlang(parsed_args)

    def _get_languages(self, env, language_codes, active_test=True):
        # We want to log invalid parameters
        Lang = env['res.lang'].with_context(active_test=False)
        languages = Lang.search(Domain.OR([Domain('iso_code', 'in', language_codes),
                                           Domain('code', 'in', language_codes)]))
        if not_found_language_codes := set(language_codes) - set(languages.mapped("iso_code")):
            _logger.warning("Ignoring not found languages: %s", ', '.join(not_found_language_codes))
        if active_test:
            if not_installed_languages := languages.filtered(lambda x: not x.active):
                languages -= not_installed_languages
                iso_codes = not_installed_languages.mapped('iso_code')
                _logger.warning(
                    textwrap.dedent("""\
                        Ignoring not installed languages: %s
                        Install them running the below command, then run this command again.

                        $ %s -l %s
                    """),
                    ', '.join(iso_codes),
                    self.loadlang_parser.prog,
                    ' '.join(iso_codes),
                )
        return languages

    def _import(self, parsed_args):
        paths = OrderedSet(parsed_args.files)
        if invalid_paths := [path for path in paths if (
            not path.exists()
            or path.suffix not in IMPORT_EXTENSIONS
        )]:
            _logger.warning("Ignoring invalid paths: %s",
                ', '.join(str(path) for path in invalid_paths))
            paths -= set(invalid_paths)
        if not paths:
            self.import_parser.error("No valid path was provided")

        with Registry(parsed_args.db_name).cursor() as cr:
            env = Environment(cr, SUPERUSER_ID, {})
            translation_importer = TranslationImporter(cr)
            language = self._get_languages(env, [parsed_args.language])
            if not language:
                self.import_parser.error("No valid language has been provided")
            for path in paths:
                with path.open("rb") as infile:
                    translation_importer.load(infile, path.suffix.removeprefix('.'), language.code)
            translation_importer.save(overwrite=parsed_args.overwrite)

    def _export(self, parsed_args):
        export_pot = 'pot' in parsed_args.languages

        if parsed_args.output:
            if len(parsed_args.languages) != 1:
                self.export_parser.error(
                    "When --output is specified, one single --language must be supplied")
            if parsed_args.output != '-':
                parsed_args.output = Path(parsed_args.output)
                if parsed_args.output.suffix not in EXPORT_EXTENSIONS:
                    self.export_parser.error(
                        f"Extensions allowed for --output are {', '.join(EXPORT_EXTENSIONS)}")
                if export_pot and parsed_args.output.suffix == '.csv':
                    self.export_parser.error(
                        "Cannot export template in .csv format, please specify a language.")

        if export_pot:
            parsed_args.languages.remove('pot')

        with Registry(parsed_args.db_name).cursor(readonly=True) as cr:
            env = Environment(cr, SUPERUSER_ID, {})

            # We want to log invalid parameters
            modules = env['ir.module.module'].search_fetch(
                [('name', 'in', parsed_args.modules)], ['name', 'state'])
            if not_found_module_names := set(parsed_args.modules) - set(modules.mapped("name")):
                _logger.warning("Ignoring not found modules: %s",
                    ", ".join(not_found_module_names))
            if not_installed_modules := modules.filtered(lambda x: x.state != 'installed'):
                _logger.warning("Ignoring not installed modules: %s",
                    ", ".join(not_installed_modules.mapped("name")))
                modules -= not_installed_modules
            if len(modules) < 1:
                self.export_parser.error("No valid module has been provided")
            module_names = modules.mapped("name")

            languages = self._get_languages(env, parsed_args.languages)
            languages_count = len(languages) + export_pot
            if languages_count == 0:
                self.export_parser.error("No valid language has been provided")

            if parsed_args.output:
                self._export_file(env, module_names, languages.code, parsed_args.output)
            else:
                # Po(t) files in the modules' i18n folders
                for module_name in module_names:
                    i18n_path = Path(get_module_path(module_name), 'i18n')
                    if export_pot:
                        path = i18n_path / f'{module_name}.pot'
                        self._export_file(env, [module_name], None, path)
                    for language in languages:
                        path = i18n_path / f'{language.iso_code}.po'
                        self._export_file(env, [module_name], language.code, path)

    def _export_file(self, env, module_names, lang_code, path):
        source = module_names[0] if len(module_names) == 1 else 'modules'
        destination = 'stdout' if path == '-' else path
        _logger.info("Exporting %s (%s) to %s", source, lang_code or 'pot', destination)

        if destination == 'stdout':
            if not trans_export(lang_code, module_names, sys.stdout.buffer, 'po', env):
                _logger.warning("No translatable terms were found in %s.", module_names)
            return

        path.parent.mkdir(exist_ok=True)
        export_format = path.suffix.removeprefix('.')
        if export_format == 'pot':
            export_format = 'po'
        with path.open('wb') as outfile:
            if not trans_export(lang_code, module_names, outfile, export_format, env):
                _logger.warning("No translatable terms were found in %s.", module_names)

    def _loadlang(self, parsed_args):
        with Registry(parsed_args.db_name).cursor() as cr:
            env = Environment(cr, SUPERUSER_ID, {})
            for language in self._get_languages(env, parsed_args.languages, active_test=False):
                load_language(env.cr, language.code)