#! /usr/bin/env python3

"""pygettext -- Python equivalent of xgettext(1)

Many systems (Solaris, Linux, Gnu) provide extensive tools that ease the
internationalization of C programs. Most of these tools are independent of
the programming language and can be used from within Python programs.
Martin von Loewis' work[1] helps considerably in this regard.

pygettext uses Python's standard tokenize module to scan Python source
code, generating .pot files identical to what GNU xgettext[2] generates
for C and C++ code. From there, the standard GNU tools can be used.

A word about marking Python strings as candidates for translation. GNU
xgettext recognizes the following keywords: gettext, dgettext, dcgettext,
and gettext_noop. But those can be a lot of text to include all over your
code. C and C++ have a trick: they use the C preprocessor. Most
internationalized C source includes a #define for gettext() to _() so that
what has to be written in the source is much less. Thus these are both
translatable strings:

    gettext("Translatable String")
    _("Translatable String")

Python of course has no preprocessor so this doesn't work so well.  Thus,
pygettext searches only for _() by default, but see the -k/--keyword flag
below for how to augment this.

 [1] https://www.python.org/workshops/1997-10/proceedings/loewis.html
 [2] https://www.gnu.org/software/gettext/gettext.html

NOTE: pygettext attempts to be option and feature compatible with GNU
xgettext where ever possible. However some options are still missing or are
not fully implemented. Also, xgettext's use of command line switches with
option arguments is broken, and in these cases, pygettext just defines
additional switches.

NOTE: The public interface of pygettext is limited to the command-line
interface only. The internal API is subject to change without notice.

Usage: pygettext [options] inputfile ...

Options:

    -a
    --extract-all
        Deprecated: Not implemented and will be removed in a future version.

    -cTAG
    --add-comments=TAG
        Extract translator comments.  Comments must start with TAG and
        must precede the gettext call.  Multiple -cTAG options are allowed.
        In that case, any comment matching any of the TAGs will be extracted.

    -d name
    --default-domain=name
        Rename the default output file from messages.pot to name.pot.

    -E
    --escape
        Replace non-ASCII characters with octal escape sequences.

    -D
    --docstrings
        Extract module, class, method, and function docstrings.  These do
        not need to be wrapped in _() markers, and in fact cannot be for
        Python to consider them docstrings. (See also the -X option).

    -h
    --help
        Print this help message and exit.

    -k word
    --keyword=word
        Keywords to look for in addition to the default set, which are:
        _, gettext, ngettext, pgettext, npgettext, dgettext, dngettext,
        dpgettext, and dnpgettext.

        You can have multiple -k flags on the command line.

    -K
    --no-default-keywords
        Disable the default set of keywords (see above).  Any keywords
        explicitly added with the -k/--keyword option are still recognized.

    --no-location
        Do not write filename/lineno location comments.

    -n
    --add-location
        Write filename/lineno location comments indicating where each
        extracted string is found in the source.  These lines appear before
        each msgid.  The style of comments is controlled by the -S/--style
        option.  This is the default.

    -o filename
    --output=filename
        Rename the default output file from messages.pot to filename.  If
        filename is `-' then the output is sent to standard out.

    -p dir
    --output-dir=dir
        Output files will be placed in directory dir.

    -S stylename
    --style stylename
        Specify which style to use for location comments.  Two styles are
        supported:

        Solaris  # File: filename, line: line-number
        GNU      #: filename:line

        The style name is case insensitive.  GNU style is the default.

    -v
    --verbose
        Print the names of the files being processed.

    -V
    --version
        Print the version of pygettext and exit.

    -w columns
    --width=columns
        Set width of output to columns.

    -x filename
    --exclude-file=filename
        Specify a file that contains a list of strings that are not be
        extracted from the input files.  Each string to be excluded must
        appear on a line by itself in the file.

    -X filename
    --no-docstrings=filename
        Specify a file that contains a list of files (one per line) that
        should not have their docstrings extracted.  This is only useful in
        conjunction with the -D option above.

If `inputfile' is -, standard input is read.
"""

import ast
import getopt
import glob
import importlib.machinery
import importlib.util
import os
import sys
import time
import tokenize
from dataclasses import dataclass, field
from io import BytesIO
from operator import itemgetter

__version__ = "1.5"


# The normal pot-file header. msgmerge and Emacs's po-mode work better if it's
# there.
pot_header = """\
# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR ORGANIZATION
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\\n"
"POT-Creation-Date: %(time)s\\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
"Language-Team: LANGUAGE <LL@li.org>\\n"
"MIME-Version: 1.0\\n"
"Content-Type: text/plain; charset=%(charset)s\\n"
"Content-Transfer-Encoding: %(encoding)s\\n"
"Generated-By: pygettext.py %(version)s\\n"

"""


def usage(code, msg=""):
    print(__doc__, file=sys.stderr)
    if msg:
        print(msg, file=sys.stderr)
    sys.exit(code)


def make_escapes(pass_nonascii):
    global escapes, escape
    if pass_nonascii:
        # Allow non-ascii characters to pass through so that e.g. 'msgid
        # "Höhe"' would not result in 'msgid "H\366he"'.  Otherwise we
        # escape any character outside the 32..126 range.
        escape = escape_ascii
    else:
        escape = escape_nonascii
    escapes = [rf"\{i:03o}" for i in range(256)]
    for i in range(32, 127):
        escapes[i] = chr(i)
    escapes[ord("\\")] = r"\\"
    escapes[ord("\t")] = r"\t"
    escapes[ord("\r")] = r"\r"
    escapes[ord("\n")] = r"\n"
    escapes[ord('"')] = r"\""


def escape_ascii(s, encoding):
    return "".join(
        escapes[ord(c)] if ord(c) < 128 else c if c.isprintable() else escape_nonascii(c, encoding) for c in s
    )


def escape_nonascii(s, encoding):
    return "".join(escapes[b] for b in s.encode(encoding))


def normalize(s, encoding):
    # This converts the various Python string types into a format that is
    # appropriate for .po files, namely much closer to C style.
    lines = s.split("\n")
    if len(lines) == 1:
        s = '"' + escape(s, encoding) + '"'
    else:
        if not lines[-1]:
            del lines[-1]
            lines[-1] = lines[-1] + "\n"
        for i in range(len(lines)):
            lines[i] = escape(lines[i], encoding)
        lineterm = '\\n"\n"'
        s = '""\n"' + lineterm.join(lines) + '"'
    return s


def containsAny(str, set):
    """Check whether 'str' contains ANY of the chars in 'set'"""
    return 1 in [c in str for c in set]


def getFilesForName(name):
    """Get a list of module files for a filename, a module or package name,
    or a directory.
    """
    if not os.path.exists(name):
        # check for glob chars
        if containsAny(name, "*?[]"):
            files = glob.glob(name)
            list = []
            for file in files:
                list.extend(getFilesForName(file))
            return list

        # try to find module or package
        try:
            spec = importlib.util.find_spec(name)
            name = spec.origin
        except ImportError:
            name = None
        if not name:
            return []

    if os.path.isdir(name):
        # find all python files in directory
        list = []
        # get extension for python source files
        _py_ext = importlib.machinery.SOURCE_SUFFIXES[0]
        for root, dirs, files in os.walk(name):
            # don't recurse into CVS directories
            if "CVS" in dirs:
                dirs.remove("CVS")
            # add all *.py files to list
            list.extend([os.path.join(root, file) for file in files if os.path.splitext(file)[1] == _py_ext])
        return list
    elif os.path.exists(name):
        # a single file
        return [name]

    return []


# Key is the function name, value is a dictionary mapping argument positions to the
# type of the argument. The type is one of 'msgid', 'msgid_plural', or 'msgctxt'.
DEFAULTKEYWORDS = {
    "_": {"msgid": 0},
    "gettext": {"msgid": 0},
    "ngettext": {"msgid": 0, "msgid_plural": 1},
    "pgettext": {"msgctxt": 0, "msgid": 1},
    "npgettext": {"msgctxt": 0, "msgid": 1, "msgid_plural": 2},
    "dgettext": {"msgid": 1},
    "dngettext": {"msgid": 1, "msgid_plural": 2},
    "dpgettext": {"msgctxt": 1, "msgid": 2},
    "dnpgettext": {"msgctxt": 1, "msgid": 2, "msgid_plural": 3},
}


def parse_spec(spec):
    """Parse a keyword spec string into a dictionary.

    The keyword spec format defines the name of the gettext function and the
    positions of the arguments that correspond to msgid, msgid_plural, and
    msgctxt. The format is as follows:

        name - the name of the gettext function, assumed to
               have a single argument that is the msgid.
        name:pos1 - the name of the gettext function and the position
                    of the msgid argument.
        name:pos1,pos2 - the name of the gettext function and the positions
                         of the msgid and msgid_plural arguments.
        name:pos1,pos2c - the name of the gettext function and the positions
                          of the msgid and msgctxt arguments.
        name:pos1,pos2,pos3c - the name of the gettext function and the
                               positions of the msgid, msgid_plural, and
                               msgctxt arguments.

    As an example, the spec 'foo:1,2,3c' means that the function foo has three
    arguments, the first one is the msgid, the second one is the msgid_plural,
    and the third one is the msgctxt. The positions are 1-based.

    The msgctxt argument can appear in any position, but it can only appear
    once. For example, the keyword specs 'foo:3c,1,2' and 'foo:1,2,3c' are
    equivalent.

    See https://www.gnu.org/software/gettext/manual/gettext.html
    for more information.
    """
    parts = spec.strip().split(":", 1)
    if len(parts) == 1:
        name = parts[0]
        return name, {"msgid": 0}

    name, args = parts
    if not args:
        raise ValueError(f"Invalid keyword spec {spec!r}: " "missing argument positions")

    result = {}
    for arg in args.split(","):
        arg = arg.strip()
        is_context = False
        if arg.endswith("c"):
            is_context = True
            arg = arg[:-1]

        try:
            pos = int(arg) - 1
        except ValueError as e:
            raise ValueError(f"Invalid keyword spec {spec!r}: " "position is not an integer") from e

        if pos < 0:
            raise ValueError(f"Invalid keyword spec {spec!r}: " "argument positions must be strictly positive")

        if pos in result.values():
            raise ValueError(f"Invalid keyword spec {spec!r}: " "duplicate positions")

        if is_context:
            if "msgctxt" in result:
                raise ValueError(f"Invalid keyword spec {spec!r}: " "msgctxt can only appear once")
            result["msgctxt"] = pos
        elif "msgid" not in result:
            result["msgid"] = pos
        elif "msgid_plural" not in result:
            result["msgid_plural"] = pos
        else:
            raise ValueError(f"Invalid keyword spec {spec!r}: " "too many positions")

    if "msgid" not in result and "msgctxt" in result:
        raise ValueError(f"Invalid keyword spec {spec!r}: " "msgctxt cannot appear without msgid")

    return name, result


def unparse_spec(name, spec):
    """Unparse a keyword spec dictionary into a string."""
    if spec == {"msgid": 0}:
        return name

    parts = []
    for arg, pos in sorted(spec.items(), key=lambda x: x[1]):
        if arg == "msgctxt":
            parts.append(f"{pos + 1}c")
        else:
            parts.append(str(pos + 1))
    return f"{name}:{','.join(parts)}"


def process_keywords(keywords, *, no_default_keywords):
    custom_keywords = {}
    for spec in dict.fromkeys(keywords):
        name, spec = parse_spec(spec)
        if name not in custom_keywords:
            custom_keywords[name] = []
        custom_keywords[name].append(spec)

    if no_default_keywords:
        return custom_keywords

    # custom keywords override default keywords
    for name, spec in DEFAULTKEYWORDS.items():
        if name not in custom_keywords:
            custom_keywords[name] = []
        if spec not in custom_keywords[name]:
            custom_keywords[name].append(spec)
    return custom_keywords


@dataclass(frozen=True)
class Location:
    filename: str
    lineno: int

    def __lt__(self, other):
        return (self.filename, self.lineno) < (other.filename, other.lineno)


@dataclass
class Message:
    msgid: str
    msgid_plural: str | None
    msgctxt: str | None
    locations: set[Location] = field(default_factory=set)
    is_docstring: bool = False
    comments: list[str] = field(default_factory=list)

    def add_location(self, filename, lineno, msgid_plural=None, *, is_docstring=False, comments=None):
        if self.msgid_plural is None:
            self.msgid_plural = msgid_plural
        self.locations.add(Location(filename, lineno))
        self.is_docstring |= is_docstring
        if comments:
            self.comments.extend(comments)


def get_source_comments(source):
    """
    Return a dictionary mapping line numbers to
    comments in the source code.
    """
    comments = {}
    for token in tokenize.tokenize(BytesIO(source).readline):
        if token.type == tokenize.COMMENT:
            # Remove any leading combination of '#' and whitespace
            comment = token.string.lstrip("# \t")
            comments[token.start[0]] = comment
    return comments


class GettextVisitor(ast.NodeVisitor):
    def __init__(self, options):
        super().__init__()
        self.options = options
        self.filename = None
        self.messages = {}
        self.comments = {}

    def visit_file(self, source, filename):
        try:
            module_tree = ast.parse(source)
        except SyntaxError:
            return

        self.filename = filename
        if self.options.comment_tags:
            self.comments = get_source_comments(source)
        self.visit(module_tree)

    def visit_Module(self, node):
        self._extract_docstring(node)
        self.generic_visit(node)

    visit_ClassDef = visit_FunctionDef = visit_AsyncFunctionDef = visit_Module

    def visit_Call(self, node):
        self._extract_message(node)
        self.generic_visit(node)

    def _extract_docstring(self, node):
        if not self.options.docstrings or self.options.nodocstrings.get(self.filename):
            return

        docstring = ast.get_docstring(node)
        if docstring is not None:
            lineno = node.body[0].lineno  # The first statement is the docstring
            self._add_message(lineno, docstring, is_docstring=True)

    def _extract_message(self, node):
        func_name = self._get_func_name(node)
        errors = []
        specs = self.options.keywords.get(func_name, [])
        for spec in specs:
            err = self._extract_message_with_spec(node, spec)
            if err is None:
                return
            errors.append(err)

        if not errors:
            return
        if len(errors) == 1:
            print(f"*** {self.filename}:{node.lineno}: {errors[0]}", file=sys.stderr)
        else:
            # There are multiple keyword specs for the function name and
            # none of them could be extracted. Print a general error
            # message and list the errors for each keyword spec.
            print(
                f"*** {self.filename}:{node.lineno}: " f'No keywords matched gettext call "{func_name}":',
                file=sys.stderr,
            )
            for spec, err in zip(specs, errors, strict=True):
                unparsed = unparse_spec(func_name, spec)
                print(f'\tkeyword="{unparsed}": {err}', file=sys.stderr)

    def _extract_message_with_spec(self, node, spec):
        """Extract a gettext call with the given spec.

        Return None if the gettext call was successfully extracted,
        otherwise return an error message.
        """
        max_index = max(spec.values())
        has_var_positional = any(isinstance(arg, ast.Starred) for arg in node.args[: max_index + 1])
        if has_var_positional:
            return "Variable positional arguments are not " "allowed in gettext calls"

        if max_index >= len(node.args):
            return f"Expected at least {max_index + 1} positional " f"argument(s) in gettext call, got {len(node.args)}"

        msg_data = {}
        for arg_type, position in spec.items():
            arg = node.args[position]
            if not self._is_string_const(arg):
                return f"Expected a string constant for argument " f"{position + 1}, got {ast.unparse(arg)}"
            msg_data[arg_type] = arg.value

        lineno = node.lineno
        comments = self._extract_comments(node)
        self._add_message(lineno, **msg_data, comments=comments)

    def _extract_comments(self, node):
        """Extract translator comments.

        Translator comments must precede the gettext call and
        start with one of the comment prefixes defined by
        --add-comments=TAG. See the tests for examples.
        """
        if not self.options.comment_tags:
            return []

        comments = []
        lineno = node.lineno - 1
        # Collect an unbroken sequence of comments starting from
        # the line above the gettext call.
        while lineno >= 1:
            comment = self.comments.get(lineno)
            if comment is None:
                break
            comments.append(comment)
            lineno -= 1

        # Find the first translator comment in the sequence and
        # return all comments starting from that comment.
        comments = comments[::-1]
        first_index = next((i for i, comment in enumerate(comments) if self._is_translator_comment(comment)), None)
        if first_index is None:
            return []
        return comments[first_index:]

    def _is_translator_comment(self, comment):
        return comment.startswith(self.options.comment_tags)

    def _add_message(self, lineno, msgid, msgid_plural=None, msgctxt=None, *, is_docstring=False, comments=None):
        if msgid in self.options.toexclude:
            return

        if not comments:
            comments = []

        key = self._key_for(msgid, msgctxt)
        message = self.messages.get(key)
        if message:
            message.add_location(
                self.filename,
                lineno,
                msgid_plural,
                is_docstring=is_docstring,
                comments=comments,
            )
        else:
            self.messages[key] = Message(
                msgid=msgid,
                msgid_plural=msgid_plural,
                msgctxt=msgctxt,
                locations={Location(self.filename, lineno)},
                is_docstring=is_docstring,
                comments=comments,
            )

    @staticmethod
    def _key_for(msgid, msgctxt=None):
        if msgctxt is not None:
            return (msgctxt, msgid)
        return msgid

    def _get_func_name(self, node):
        match node.func:
            case ast.Name(id=id):
                return id
            case ast.Attribute(attr=attr):
                return attr
            case _:
                return None

    def _is_string_const(self, node):
        return isinstance(node, ast.Constant) and isinstance(node.value, str)


def write_pot_file(messages, options, fp):
    timestamp = time.strftime("%Y-%m-%d %H:%M%z")
    encoding = fp.encoding if fp.encoding else "UTF-8"
    print(pot_header % {"time": timestamp, "version": __version__, "charset": encoding, "encoding": "8bit"}, file=fp)

    # Sort locations within each message by filename and lineno
    sorted_keys = [(key, sorted(msg.locations)) for key, msg in messages.items()]
    # Sort messages by locations
    # For example, a message with locations [('test.py', 1), ('test.py', 2)] will
    # appear before a message with locations [('test.py', 1), ('test.py', 3)]
    sorted_keys.sort(key=itemgetter(1))

    for key, locations in sorted_keys:
        msg = messages[key]

        for comment in msg.comments:
            print(f"#. {comment}", file=fp)

        if options.writelocations:
            # location comments are different b/w Solaris and GNU:
            if options.locationstyle == options.SOLARIS:
                for location in locations:
                    print(f"# File: {location.filename}, line: {location.lineno}", file=fp)
            elif options.locationstyle == options.GNU:
                # fit as many locations on one line, as long as the
                # resulting line length doesn't exceed 'options.width'
                locline = "#:"
                for location in locations:
                    s = f" {location.filename}:{location.lineno}"
                    if len(locline) + len(s) <= options.width:
                        locline = locline + s
                    else:
                        print(locline, file=fp)
                        locline = f"#:{s}"
                if len(locline) > 2:
                    print(locline, file=fp)
        if msg.is_docstring:
            # If the entry was gleaned out of a docstring, then add a
            # comment stating so.  This is to aid translators who may wish
            # to skip translating some unimportant docstrings.
            print("#, docstring", file=fp)
        if msg.msgctxt is not None:
            print("msgctxt", normalize(msg.msgctxt, encoding), file=fp)
        print("msgid", normalize(msg.msgid, encoding), file=fp)
        if msg.msgid_plural is not None:
            print("msgid_plural", normalize(msg.msgid_plural, encoding), file=fp)
            print('msgstr[0] ""', file=fp)
            print('msgstr[1] ""\n', file=fp)
        else:
            print('msgstr ""\n', file=fp)


def main():
    try:
        opts, args = getopt.getopt(
            sys.argv[1:],
            "ac::d:DEhk:Kno:p:S:Vvw:x:X:",
            [
                "extract-all",
                "add-comments=?",
                "default-domain=",
                "escape",
                "help",
                "keyword=",
                "no-default-keywords",
                "add-location",
                "no-location",
                "output=",
                "output-dir=",
                "style=",
                "verbose",
                "version",
                "width=",
                "exclude-file=",
                "docstrings",
                "no-docstrings",
            ],
        )
    except getopt.error as msg:
        usage(1, msg)

    # for holding option values
    class Options:
        # constants
        GNU = 1
        SOLARIS = 2
        # defaults
        extractall = 0  # FIXME: currently this option has no effect at all.
        escape = 0
        keywords = []
        outpath = ""
        outfile = "messages.pot"
        writelocations = 1
        locationstyle = GNU
        verbose = 0
        width = 78
        excludefilename = ""
        docstrings = 0
        nodocstrings = {}
        comment_tags = set()

    options = Options()
    locations = {
        "gnu": options.GNU,
        "solaris": options.SOLARIS,
    }
    no_default_keywords = False
    # parse options
    for opt, arg in opts:
        if opt in ("-h", "--help"):
            usage(0)
        elif opt in ("-a", "--extract-all"):
            print(
                "DeprecationWarning: -a/--extract-all is not implemented and will be removed in a future version",
                file=sys.stderr,
            )
            options.extractall = 1
        elif opt in ("-c", "--add-comments"):
            options.comment_tags.add(arg)
        elif opt in ("-d", "--default-domain"):
            options.outfile = arg + ".pot"
        elif opt in ("-E", "--escape"):
            options.escape = 1
        elif opt in ("-D", "--docstrings"):
            options.docstrings = 1
        elif opt in ("-k", "--keyword"):
            options.keywords.append(arg)
        elif opt in ("-K", "--no-default-keywords"):
            no_default_keywords = True
        elif opt in ("-n", "--add-location"):
            options.writelocations = 1
        elif opt in ("--no-location",):
            options.writelocations = 0
        elif opt in ("-S", "--style"):
            options.locationstyle = locations.get(arg.lower())
            if options.locationstyle is None:
                usage(1, f"Invalid value for --style: {arg}")
        elif opt in ("-o", "--output"):
            options.outfile = arg
        elif opt in ("-p", "--output-dir"):
            options.outpath = arg
        elif opt in ("-v", "--verbose"):
            options.verbose = 1
        elif opt in ("-V", "--version"):
            print(f"pygettext.py (xgettext for Python) {__version__}")
            sys.exit(0)
        elif opt in ("-w", "--width"):
            try:
                options.width = int(arg)
            except ValueError:
                usage(1, f"--width argument must be an integer: {arg}")
        elif opt in ("-x", "--exclude-file"):
            options.excludefilename = arg
        elif opt in ("-X", "--no-docstrings"):
            fp = open(arg)
            try:
                while 1:
                    line = fp.readline()
                    if not line:
                        break
                    options.nodocstrings[line[:-1]] = 1
            finally:
                fp.close()

    options.comment_tags = tuple(options.comment_tags)

    # calculate escapes
    make_escapes(not options.escape)

    # calculate all keywords
    try:
        options.keywords = process_keywords(options.keywords, no_default_keywords=no_default_keywords)
    except ValueError as e:
        print(e, file=sys.stderr)
        sys.exit(1)

    # initialize list of strings to exclude
    if options.excludefilename:
        try:
            with open(options.excludefilename) as fp:
                options.toexclude = fp.readlines()
        except OSError:
            print(f"Can't read --exclude-file: {options.excludefilename}", file=sys.stderr)
            sys.exit(1)
    else:
        options.toexclude = []

    # resolve args to module lists
    expanded = []
    for arg in args:
        if arg == "-":
            expanded.append(arg)
        else:
            expanded.extend(getFilesForName(arg))
    args = expanded

    # slurp through all the files
    visitor = GettextVisitor(options)
    for filename in args:
        if filename == "-":
            if options.verbose:
                print("Reading standard input")
            source = sys.stdin.buffer.read()
        else:
            if options.verbose:
                print(f"Working on {filename}")
            with open(filename, "rb") as fp:
                source = fp.read()

        visitor.visit_file(source, filename)

    # write the output
    if options.outfile == "-":
        fp = sys.stdout
        closep = 0
    else:
        if options.outpath:
            options.outfile = os.path.join(options.outpath, options.outfile)
        fp = open(options.outfile, "w")
        closep = 1
    try:
        write_pot_file(visitor.messages, options, fp)
    finally:
        if closep:
            fp.close()


if __name__ == "__main__":
    main()
