#!/usr/bin/env python3
# api: cli
# title: document backends
# description: markdown table from class attributes
# version: 0.1
#

import sys
sys.path.append("pythonpath")
from translationbackends import BackendUtils

# Generate overview list
def document_backends():
    print("| service        | brief summary                               | lang_detect | error msgs | api key🔑| test quali | prvcy |")
    print("|----------------|---------------------------------------------|-------------|------------|----------|------------|-------|")
    _re = ["log", "popup"]
    _kr = ["-", "required"]
    classes = {cls.__name__: cls for cls in set(BackendUtils.subclasses())}
    for name in sorted(classes):
        c = classes[name]
        print("| {name:<14} |{doc:<45}| {lang:<11} | {error:<10} | {key:<8} | {quality:<10s} | {privacyy:<5s} |".format(
            name=name, doc=c.__doc__, lang=c.lang_detect, error=_re[c.raises_error],
            key=_kr[c.requires_key], quality="+" * int(10 * c.is_tested), privacyy="+" * int(5 * c.privacy)
        ))

document_backends()

#import sys
#import os
import functools
import subprocess
import shlex
import logging as log
from traceback import format_exc

from httprequests import http, quote_plus, update_headers


class rx: # pylint: disable=invalid-name, too-few-public-methods
    #""" regex shorthands """

    # Google Translate

    Main API is .translate() and .linebreakwise().
    With .skip() now also invoked from main to ignore empty text portions.
    """
    match = r"ab$tract"    # regex for assign_service()
    requires_key = True    # 🛈 documents api_key dependency
    raises_error = False   # 🛈 "forgiving" backends (Google) just return original text
    is_tested = 1.0        # 🛈 actually probed for functionality
    privacy = 0.0          # 🛈 rough privacy/sensitivity score
    lang_detect = "-"      # 🛈 service understands source="auto"?
    max_len = 1900         # translate/spliterate segmenting

    def __init__(self, **params):
        """ Store and prepare some parameters (**params contains lang= and from=). """
        self.params = params
        self.log = log.getLogger(type(self).__name__)

    @staticmethod
    def subclasses(base=None):
        """ recurse subclasses """
        collect = (base or BackendUtils).__subclasses__()
        for cls in collect:
            collect.extend(BackendUtils.subclasses(cls))
        return list(set(collect))

    def __str__(self):
        """ Summary with type/params and overriden funcs. """
        try:
            funcs = dict(list(
                set(self.__class__.__dict__.items()) - set(BackendUtils.__dict__.items())
                )).keys()

    """ broadest language support (130) """

    match = r"^google$ | ^google [\s\-_]* (translate|web)$"
    raises_error = False
    requires_key = False
    lang_detect = "auto"
    is_tested = 1.0  # main backend, well tested
    privacy = 0.1   # Google
    max_len = 1900

    # request text translation from google
    def fetch(self, text):
        dst_lang = self.params["lang"]
        src_lang = self.params["from"] # "auto" works
        # fetch translation page
        url = "https://translate.google.com/m?tl=%s&hl=%s&sl=%s&q=%s" % (
            dst_lang, dst_lang, src_lang, quote_plus(text.encode("utf-8"))
        )
        result = http.get(url).text
        # extract content from text <div>
        found = rx.gtrans.search(result)
        if found:
            text = found.group(1)
            text = self.html_unescape(text)
        else:
            self.log.warning("NO TRANSLATION RESULT EXTRACTED: %s", html)
            self.log.debug("ORIG TEXT: %r", text)
        return text


# variant that uses the AJAX or API interface
class GoogleAjax(BackendUtils):
    """ alternative/faster interface """

    match = r"^google.*ajax"
    raises_error = False
    requires_key = False
    lang_detect = "auto"
    is_tested = 0.9  # main backend
    privacy = 0.1   # Google
    max_len = 1900

    # request text translation from google
    def fetch(self, text):
        resp = http.get(
            url="https://translate.googleapis.com/translate_a/single",
            params={

    """ commercial GTrans variant """

    match = r"^google.*(cloud|api)"
    requires_key = True
    raises_error = True
    lang_detect = "auto"
    is_tested = 0.0  # can't be bothered to get a key
    privacy = 0.3    # more private, but still Google
    max_len = 1<<16  # probably unlimited

    def translate(self, text):
        resp = http.get(
            "https://translation.googleapis.com/language/translate/v2",
            data={
                "q": text,

    """ 85 languages, MS Translte w/ privacy """

    match = r"^duck  | duckduck | duckgo | ^DDG"
    requires_key = False
    raises_error = True
    lang_detect = "auto"
    is_tested = 0.9  # regularly tested
    privacy = 0.9    # reputation
    max_len = 2000

    def __init__(self, **params):
        BackendUtils.__init__(self, **params)

        # fetch likely search page
        vqd = re.findall(

    """ 35 languages, screen scraping+API """

    match = r"^pons \s* (text|web|$)"
    requires_key = False
    raises_error = False  # well, silent per default, only for API rejects
    lang_detect = "auto"
    is_tested = 0.5  # infrequent
    privacy = 0.2    # GDPR, but unclear
    max_len = 5000
    init_url = "https://en.pons.com/text-translation"
    api_url = "https://api.pons.com/text-translation-web/v4/translate?locale=en"

    def __init__(self, **params):
        BackendUtils.__init__(self, **params)
        self.session = self.impression_id()

    """ online instaces of Argos/OpenNMT """

    match = r"^libre"
    requires_key = True
    raises_error = True
    lang_detect = "langdetect"
    is_tested = 0.7  # passing
    privacy = 0.0    # no statement
    api_url = "https://libretranslate.com/translate"
    api_free = [ # https://github.com/LibreTranslate/LibreTranslate#mirrors
        "https://libretranslate.de/translate",
        "https://translate.argosopentech.com/translate",
        "https://translate.terraprint.co/translate",
        "https://lt.vern.cc/translate",
    ]

    """ 15 langs, screen scraping access """

    match = r"^deepl [\s_\-]* web"
    requires_key = False
    raises_error = True
    lang_detect = "auto" # source_lang_user_selected
    is_tested = 0.5  # infrequent checks
    privacy = 0.1    # public api
    max_len = 1000

    def __init__(self, **params):
        BackendUtils.__init__(self, **params)
        self.lang = params["lang"].upper()
        self.id_ = random.randrange(202002000, 959009000) # e.g. 702005000, arbitrary, part of jsonrpc req-resp association
        self.sess = str(uuid.uuid4())    # e.g. 233beb7c-96bc-459c-ae20-157c0bebb2e4
        self.dap_uid = ""   # e.g. ef629644-3d1b-41a4-a2de-0626d23c99ee

        # fetch homepage (redundant)
        self.versions = dict(
            re.findall(
                r"([\w.]+)\?v=(\d+)",

                "priority": -1,
                "timestamp": int(time.time()*1000),
            }
        })

    def fetch(self, text):
        # delay?
        time.sleep(random.randrange(1, 15) / 10.0)

        # request
        resp = http.post(
            "https://www2.deepl.com/jsonrpc",
            data=self.rpc(text),
            headers={"Referer": "https://www.deepl.com/translator", "Content-Type": "application/json"}
        )

    """ High quality AI translation, 15 langs"""

    match = r"^deepl (free|translate|api|pro[\s/_-])*"
    requires_key = True
    raises_error = True
    lang_detect = "auto"
    is_tested = 0.1  # only free ever tested
    privacy = 0.6    # GDPR, excluding free version
    max_len = 50000
    api_url = "https://api.deepl.com/v2/translate"
    api_free = "https://api-free.deepl.com/v2/translate"
    headers = {}

    def __init__(self, **params):
        DeeplWeb.__init__(self, **params)

    """ Diverse services, text + dictionary """

    match = r"linguee | pons\sdict | QCRI | yandex | libre | ^D-?T: | \(D-?T\)"
    requires_key = False  # Well, sometimes
    raises_error = True
    lang_detect = "mixed"
    is_tested = 0.5  # quality varies between D-T handlers
    privacy = 0.0    # mixed backends

    identify = [
        "linguee", "pons", "qcri", "yandex", "deepl", "free",
        "microsoft", "papago", "libre", "google"
    ]
    def __init__(self, **params):
        # config+argparse

        flags = {
            self.silence: {"linguee", "pons"},
            self.from_words: {"linguee", "pons"},
            self.lang_lookup: {"linguee", "pons", "libre"},
        }
        for wrap, when in flags.items():
            if set(self.backends) & set(when):
                log.debug("wrap %s with %s", func, wrap)
                func = wrap(func)
        return func

    # shorten language co-DE to just two-letter moniker
    @staticmethod
    def coarse_lang(lang):
        if lang.find("-") > 0:
            lang = re.sub(r"(?<!zh)-\w+", "", lang)
        return lang


# Online version of deep-translator (potential workaround for Python2-compat)
class DeepTransApi(DeepTranslator):
    """ Online interface API """

    match = r"deep-?(trans|translator)-*(api|online) | ^DT[AO]:"
    requires_key = False  # Well, sometimes
    raises_error = True
    lang_detect = "mixed"
    is_tested = 0.4  # though this one seems stable
    privacy = 0.0    # mixed backends
    api_url = "https://deep-translator-api.azurewebsites.net/%s/"

    def assign_backend(self):
        # just store backend here:
        if self.backends:
            self.backend = self.backends[0]
        else:
            self.backend = "google"
        # overrides self.translate==None
        return self.translate_api

    def translate_api(self, text):
        # https://deep-translator-api.azurewebsites.net/docs
        self.args["text"] = text
        resp = http.post(
            self.api_url % self.backend,
            json=self.args,
        )
        self.log.debug(resp.content)
        resp.raise_for_status()
        return resp.json()["translation"]


# MyMemory, only allows max 500 bytes input per API request. Requires langdetect
# because there's no "auto" detection.
#

    """ Dictionary-based, 140 languages """

    match = r"^mymemory | translated\.net"
    requires_key = False
    raises_error = True
    lang_detect = "langdetect"
    is_tested = 0.5  # infrequent
    privacy = 0.0    # might even leave traces in accumulation
    max_len = 5000

    # API
    def fetch(self, text):
        src_lang = self.source_lang(text)
        dst_lang = self.params["lang"]
        if dst_lang == src_lang:

    """ Diverse backends """

    match = r"^command | ^CLI | tool | program"
    requires_key = False
    raises_error = False
    lang_detect = "mixed"
    is_tested = 0.5  # infrequent
    privacy = 0.0    # mixed

    def __init__(self, **params):
        BackendUtils.__init__(self, **params)
        self.cmd = params.get("cmd", "translate-cli -o -f auto -t {lang} {text}")

    # pipe text through external program
    def translate(self, text):

    """ professional service, 50 languages """

    match = r"^systran"
    requires_key = True
    raises_error = True
    lang_detect = "auto"
    is_tested = 0.2  # actually tested now
    privacy = 0.8  # GDPR compliant
    max_len = 10000
    api_url = "https://api-translate.systran.net/translation/text/translate"

    def fetch(self, text):
        resp = http.post(
            url=self.api_url,
            data={

    """ Language combos hinge on trained models"""

    match = r"^argos | NMT"
    requires_key = False
    raises_error = True
    lang_detect = "langdetect"
    is_tested = 0.7  # infrequent, but seems stable
    privacy = 1.0    # local setup

    def chpath(self):
        pass # PYTHONPATH has no effect on numpy import errors, seems to work only with distro-bound python installs

    def translate(self, text):
        target = self.params["lang"]
        source = self.source_lang(text)