#
# Copyright 2004-2010 Zuza Software Foundation
#
# This file is part of translate.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.

"""
Convert template files (like .pot or template .xlf files) to translation
files, preserving existing translations.

See: http://docs.translatehouse.org/projects/translate-toolkit/en/latest/commands/pot2po.html
for examples and usage instructions.
"""

from translate.convert import convert
from translate.misc.multistring import multistring
from translate.search import match
from translate.storage import catkeys, factory, poheader
from translate.tools import pretranslate


def convertpot(
    input_file,
    output_file,
    template_file,
    tm=None,
    min_similarity=75,
    fuzzymatching=True,
    maxlength=None,
    classes=None,
    classes_str=None,
    **kwargs,
) -> int:
    """Main conversion function."""
    input_store = factory.getobject(
        input_file, classes=classes, classes_str=classes_str
    )
    try:
        temp_store = factory.getobject(input_file, classes_str=classes_str)
    except Exception:
        # StringIO and other file like objects will be closed after parsing
        temp_store = None

    template_store = None
    if template_file is not None:
        template_store = factory.getobject(template_file, classes_str=classes_str)

    output_store = convert_stores(
        input_store,
        template_store,
        temp_store,
        tm,
        min_similarity,
        fuzzymatching,
        **kwargs,
    )
    convert.set_po_max_line_length(output_store, maxlength)
    output_store.serialize(output_file)

    return 1


def convert_stores(
    input_store,
    template_store,
    temp_store=None,
    tm=None,
    min_similarity=75,
    fuzzymatching=True,
    **kwargs,
):
    """
    Actual conversion function, works on stores not files, returns
    a properly initialized pretranslated output store, with structure
    based on input_store, metadata based on template_store, migrates
    old translations from template_store and pretranslating from TM.
    """
    if temp_store is None:
        temp_store = input_store

    # Create fuzzy matchers to be used by pretranslate.pretranslate_unit
    matchers = []

    _prepare_merge(input_store, temp_store, template_store)
    if fuzzymatching:
        if template_store:
            matcher = match.matcher(
                template_store,
                max_candidates=1,
                min_similarity=min_similarity,
                max_length=3000,
                usefuzzy=True,
            )
            matcher.addpercentage = False
            matchers.append(matcher)
        if tm:
            matcher = pretranslate.memory(
                tm, max_candidates=1, min_similarity=min_similarity, max_length=1000
            )
            matcher.addpercentage = False
            matchers.append(matcher)

    # initialize store
    _store_pre_merge(input_store, temp_store, template_store)

    # Do matching
    for input_unit in temp_store.units:
        if input_unit.istranslatable():
            input_unit = pretranslate.pretranslate_unit(
                input_unit,
                template_store,
                matchers,
                mark_reused=True,
                merge_on=input_store.merge_on,
            )
            _unit_post_merge(input_unit, input_store, temp_store, template_store)

    # finalize store
    _store_post_merge(input_store, temp_store, template_store)

    return temp_store


##dispatchers
def _prepare_merge(input_store, output_store, template_store, **kwargs) -> None:
    """Prepare stores & TM matchers before merging."""
    # Dispatch to format specific functions
    prepare_merge_hook = f"_prepare_merge_{input_store.__class__.__name__}"
    if prepare_merge_hook in globals():
        globals()[prepare_merge_hook](
            input_store, output_store, template_store, **kwargs
        )

    # Generate an index so we can search by source string and location later on
    input_store.makeindex()
    if template_store:
        template_store.makeindex()


def _store_pre_merge(input_store, output_store, template_store, **kwargs) -> None:
    """Initialize the new file with things like headers and metadata."""
    # formats that implement poheader interface are a special case
    if isinstance(input_store, poheader.poheader):
        _do_poheaders(input_store, output_store, template_store)
    elif isinstance(input_store, catkeys.CatkeysFile):
        # FIXME: also this should be a format specific hook
        if template_store is not None:
            output_store.header = template_store.header
        else:
            output_store.header = input_store.header

    # Dispatch to format specific functions
    store_pre_merge_hook = f"_store_pre_merge_{input_store.__class__.__name__}"
    if store_pre_merge_hook in globals():
        globals()[store_pre_merge_hook](
            input_store, output_store, template_store, **kwargs
        )


def _store_post_merge(input_store, output_store, template_store, **kwargs) -> None:
    """
    Close file after merging all translations, used for adding statistics,
    obsolete messages and similar wrapup tasks.
    """
    # Dispatch to format specific functions
    store_post_merge_hook = f"_store_post_merge_{input_store.__class__.__name__}"
    if store_post_merge_hook in globals():
        globals()[store_post_merge_hook](
            input_store, output_store, template_store, **kwargs
        )


def _unit_post_merge(
    input_unit, input_store, output_store, template_store, **kwargs
) -> None:
    """
    Handle any unit level cleanup and situations not handled by the merge()
    function.
    """
    # dispatch to format specific functions
    unit_post_merge_hook = f"_unit_post_merge_{input_unit.__class__.__name__}"
    if unit_post_merge_hook in globals():
        globals()[unit_post_merge_hook](
            input_unit, input_store, output_store, template_store, **kwargs
        )


## Format specific functions
def _unit_post_merge_pounit(
    input_unit, input_store, output_store, template_store
) -> None:
    """PO format specific plural string initialization logic."""
    # FIXME: do we want to do that for poxliff also?
    if input_unit.hasplural() and len(input_unit.target) == 0:
        # untranslated plural unit; Let's ensure that we have the correct
        # number of plural forms:
        nplurals, _plural = output_store.getheaderplural()
        if nplurals and nplurals.isdigit() and nplurals != "2":
            input_unit.target = multistring([""] * int(nplurals))


def _store_post_merge_pofile(input_store, output_store, template_store) -> None:
    """PO format specific: adds newly obsoleted messages to end of store."""
    # Let's take care of obsoleted messages
    if template_store:
        newlyobsoleted = []
        for unit in template_store.units:
            if unit.isheader() or unit.isblank():
                continue
            if unit.target and not (
                input_store.findid(unit.getid()) or hasattr(unit, "reused")
            ):
                # Not in .pot, make it obsolete
                unit.makeobsolete()
                newlyobsoleted.append(unit)
        for unit in newlyobsoleted:
            output_store.addunit(unit)


def _do_poheaders(input_store, output_store, template_store) -> None:
    """Adds initialized PO headers to output store."""
    # header values
    charset = "UTF-8"
    encoding = "8bit"
    project_id_version = None
    pot_creation_date = None
    po_revision_date = None
    last_translator = None
    language_team = None
    mime_version = None
    plural_forms = None
    kwargs = {}

    if template_store is not None and isinstance(template_store, poheader.poheader):
        templateheadervalues = template_store.parseheader()
        for key, value in templateheadervalues.items():
            if key == "Project-Id-Version":
                project_id_version = value
            elif key == "Last-Translator":
                last_translator = value
            elif key == "Language-Team":
                language_team = value
            elif key == "PO-Revision-Date":
                po_revision_date = value
            elif key in {"POT-Creation-Date", "MIME-Version"}:
                # don't know how to handle these keys, or ignoring them
                pass
            elif key == "Content-Type":
                kwargs[key] = value
            elif key == "Content-Transfer-Encoding":
                encoding = value
            elif key == "Plural-Forms":
                plural_forms = value
            else:
                kwargs[key] = value

    inputheadervalues = input_store.parseheader()
    for key, value in inputheadervalues.items():
        if key in {
            "Project-Id-Version",
            "Last-Translator",
            "Language-Team",
            "PO-Revision-Date",
            "Content-Type",
            "Content-Transfer-Encoding",
            "Plural-Forms",
        }:
            # want to carry these from the template so we ignore them
            pass
        elif key == "POT-Creation-Date":
            pot_creation_date = value
        elif key == "MIME-Version":
            mime_version = value
        else:
            kwargs[key] = value

    output_header = output_store.init_headers(
        charset=charset,
        encoding=encoding,
        project_id_version=project_id_version,
        pot_creation_date=pot_creation_date,
        po_revision_date=po_revision_date,
        last_translator=last_translator,
        language_team=language_team,
        mime_version=mime_version,
        plural_forms=plural_forms,
        **kwargs,
    )

    # Get the header comments and fuzziness state
    # override some values from input file
    if template_store is not None:
        template_header = template_store.header()
        if template_header is not None:
            if template_header.getnotes("translator"):
                output_header.addnote(
                    template_header.getnotes("translator"),
                    "translator",
                    position="replace",
                )
            output_header.markfuzzy(template_header.isfuzzy())


def main(argv=None) -> None:
    formats = {
        "pot": ("po", convertpot),
        ("pot", "po"): ("po", convertpot),
        "xlf": ("xlf", convertpot),
        ("xlf", "xlf"): ("xlf", convertpot),
        "xliff": ("xliff", convertpot),
        ("xliff", "xliff"): ("xliff", convertpot),
        "ts": ("ts", convertpot),
        "lang": ("lang", convertpot),
        ("lang", "lang"): ("lang", convertpot),
        ("ts", "ts"): ("ts", convertpot),
        "catkeys": ("catkeys", convertpot),
        ("catkeys", "catkeys"): ("catkeys", convertpot),
    }
    parser = convert.ConvertOptionParser(
        formats,
        usepots=True,
        usetemplates=True,
        allowmissingtemplate=True,
        description=__doc__,
    )

    parser.add_option(
        "",
        "--tm",
        dest="tm",
        default=None,
        help="The file to use as translation memory when fuzzy matching",
    )
    parser.passthrough.append("tm")

    defaultsimilarity = 75
    parser.add_option(
        "-s",
        "--similarity",
        dest="min_similarity",
        default=defaultsimilarity,
        type="float",
        help=f"The minimum similarity for inclusion (default: {defaultsimilarity}%)",
    )
    parser.passthrough.append("min_similarity")

    parser.add_option(
        "--nofuzzymatching",
        dest="fuzzymatching",
        action="store_false",
        default=True,
        help="Disable fuzzy matching",
    )
    parser.passthrough.append("fuzzymatching")

    parser.add_po_max_line_length_option()

    parser.run(argv)


if __name__ == "__main__":
    main()
