"""LibreTranslate-compatible translation server using deep_translator."""
import sys
import io
import json
import concurrent.futures
from socketserver import ThreadingMixIn
from http.server import HTTPServer, BaseHTTPRequestHandler


class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
    daemon_threads = True

sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8')

print("Loading translation engine...", flush=True)

from deep_translator import MyMemoryTranslator

LANG_MAP = {
    "ta": "ta-IN",
    "hi": "hi-IN",
    "en": "en-GB",
}

print("Translation engine ready. Starting server on port 5000...", flush=True)

_executor = concurrent.futures.ThreadPoolExecutor(max_workers=10)


def translate_text(text, source, target):
    src_code = LANG_MAP.get(source, source)
    tgt_code = LANG_MAP.get(target, target)
    translator = MyMemoryTranslator(source=src_code, target=tgt_code)
    return translator.translate(text)


class TranslateHandler(BaseHTTPRequestHandler):
    def _send_json(self, status, data):
        body = json.dumps(data).encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.end_headers()
        self.wfile.write(body)

    def do_POST(self):
        try:
            length = int(self.headers.get("Content-Length", 0))
            body = json.loads(self.rfile.read(length))

            if self.path == "/translate":
                result = translate_text(body.get("q", ""), body.get("source", "en"), body.get("target", "ta"))
                self._send_json(200, {"translatedText": result})

            elif self.path == "/batch":
                texts = body.get("texts", [])
                targets = body.get("targets", [body.get("target", "ta")])
                source = body.get("source", "en")

                # Build all (text, target) pairs and translate concurrently
                futures = {}
                for target in targets:
                    for text in texts:
                        key = (text, target)
                        futures[key] = _executor.submit(translate_text, text, source, target)

                # Collect results grouped by target
                results = {}
                for target in targets:
                    results[target] = []
                    for text in texts:
                        try:
                            tr = futures[(text, target)].result(timeout=60)
                            results[target].append(tr)
                        except Exception:
                            results[target].append(text)

                self._send_json(200, {"translations": results})

            else:
                self._send_json(404, {"error": "not found"})
        except Exception as e:
            self._send_json(500, {"error": str(e)})

    def do_GET(self):
        if self.path == "/languages":
            langs = [
                {"code": "en", "name": "English"},
                {"code": "ta", "name": "Tamil"},
                {"code": "hi", "name": "Hindi"},
            ]
            self._send_json(200, langs)
        elif self.path == "/":
            self._send_json(200, {"status": "ok"})
        else:
            self.send_response(404)
            self.end_headers()

    def log_message(self, format, *args):
        print(f"[{self.log_date_time_string()}] {format % args}", flush=True)


server = ThreadedHTTPServer(("0.0.0.0", 5000), TranslateHandler)
print("Server running on http://localhost:5000", flush=True)
server.serve_forever()