#!/usr/bin/env python3
"""Статика, маршрут checkout/{id} и прокси /v1 на BountyPay API."""
from __future__ import annotations

import json
import os
import sys
from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib import error, request
from urllib.parse import urlparse

API_UPSTREAM = os.environ.get("BOUNTYPAY_API", "http://127.0.0.1:8080").rstrip("/")
PORT = int(os.environ.get("PORT", "8092"))
ROOT = Path(__file__).resolve().parent
ENABLE_LEADS = os.environ.get("BOUNTYPAY_LEADS", "0") == "1"
LEADS_PATH = ROOT / "data" / "leads.json"


class DevServerHandler(SimpleHTTPRequestHandler):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, directory=str(ROOT), **kwargs)

    def log_message(self, format_string, *args):
        if self.path.startswith("/v1/"):
            sys.stderr.write("%s - - [%s] %s\n" % (self.address_string(), self.log_date_time_string(), format_string % args))

    def end_headers(self):
        self.send_header("Access-Control-Allow-Origin", "*")
        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
        self.send_header(
            "Access-Control-Allow-Headers",
            "Content-Type, Idempotency-Key, X-Actor-Role, X-Actor-User-Id, X-Api-Key, X-Signature",
        )
        super().end_headers()

    def do_OPTIONS(self):
        self.send_response(204)
        self.end_headers()

    def do_GET(self):
        parsed = urlparse(self.path)
        checkout_prefix = "/checkout/"
        if parsed.path.startswith(checkout_prefix) and len(parsed.path) > len(checkout_prefix):
            payment_id = parsed.path[len(checkout_prefix) :].strip("/")
            self.path = f"/checkout.html?payment={payment_id}"
            return super().do_GET()
        if ENABLE_LEADS and parsed.path == "/local/leads":
            return self._send_leads_list()
        if parsed.path.startswith("/v1/"):
            return self._proxy("GET")
        return super().do_GET()

    def do_POST(self):
        parsed = urlparse(self.path)
        if ENABLE_LEADS and parsed.path == "/local/leads":
            return self._accept_lead()
        if parsed.path.startswith("/v1/"):
            return self._proxy("POST")
        self.send_error(404, "Not found")

    def _read_body(self) -> bytes:
        length = int(self.headers.get("Content-Length", "0"))
        if length <= 0:
            return b""
        return self.rfile.read(length)

    def _proxy(self, method: str) -> None:
        upstream_url = f"{API_UPSTREAM}{self.path}"
        body = self._read_body() if method == "POST" else None
        proxy_request = request.Request(upstream_url, data=body, method=method)
        for header_name in (
            "Content-Type",
            "Idempotency-Key",
            "X-Actor-Role",
            "X-Actor-User-Id",
            "X-Api-Key",
            "X-Signature",
        ):
            header_value = self.headers.get(header_name)
            if header_value:
                proxy_request.add_header(header_name, header_value)
        try:
            with request.urlopen(proxy_request, timeout=30) as upstream_response:
                payload = upstream_response.read()
                self.send_response(upstream_response.status)
                content_type = upstream_response.headers.get("Content-Type", "application/json")
                self.send_header("Content-Type", content_type)
                self.send_header("Content-Length", str(len(payload)))
                self.end_headers()
                self.wfile.write(payload)
        except error.HTTPError as http_error:
            payload = http_error.read()
            self.send_response(http_error.code)
            self.send_header("Content-Type", http_error.headers.get("Content-Type", "application/json"))
            self.send_header("Content-Length", str(len(payload)))
            self.end_headers()
            self.wfile.write(payload)
        except OSError as os_error:
            message = json.dumps({"error": "api_unreachable", "message": str(os_error)}).encode("utf-8")
            self.send_response(502)
            self.send_header("Content-Type", "application/json")
            self.send_header("Content-Length", str(len(message)))
            self.end_headers()
            self.wfile.write(message)

    def _send_leads_list(self) -> None:
        LEADS_PATH.parent.mkdir(parents=True, exist_ok=True)
        if not LEADS_PATH.is_file():
            payload = json.dumps({"leads": []}).encode("utf-8")
        else:
            payload = LEADS_PATH.read_bytes()
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(payload)))
        self.end_headers()
        self.wfile.write(payload)

    def _accept_lead(self) -> None:
        body = self._read_body()
        try:
            lead = json.loads(body.decode("utf-8"))
        except json.JSONDecodeError:
            self.send_error(400, "Invalid JSON")
            return
        required = ("company", "country", "contact")
        if any(not str(lead.get(field, "")).strip() for field in required):
            self.send_error(400, "Missing required fields")
            return
        LEADS_PATH.parent.mkdir(parents=True, exist_ok=True)
        leads = []
        if LEADS_PATH.is_file():
            leads = json.loads(LEADS_PATH.read_text(encoding="utf-8")).get("leads", [])
        lead_record = {
            "company": str(lead.get("company", "")).strip(),
            "country": str(lead.get("country", "")).strip(),
            "volume": str(lead.get("volume", "")).strip(),
            "contact": str(lead.get("contact", "")).strip(),
            "status": "submitted",
        }
        leads.append(lead_record)
        LEADS_PATH.write_text(json.dumps({"leads": leads}, ensure_ascii=False, indent=2), encoding="utf-8")
        response = json.dumps({"ok": True, "lead": lead_record}).encode("utf-8")
        self.send_response(201)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(response)))
        self.end_headers()
        self.wfile.write(response)


def main() -> None:
    # ponytail: локально 127.0.0.1; в Docker Traefik ходит с другой машины сети — BIND_HOST=0.0.0.0
    bind_host = os.environ.get("BIND_HOST", "127.0.0.1")
    server = ThreadingHTTPServer((bind_host, PORT), DevServerHandler)
    print(f"BountyPay UI on http://{bind_host}:{PORT} (API → {API_UPSTREAM}, leads={ENABLE_LEADS})", flush=True)
    server.serve_forever()


if __name__ == "__main__":
    main()
