"""Best-so-far convergence of Branin under two seeds against the hosted TauOpt
service with no package installed, saved as a PNG with matplotlib on the Agg
backend (no display; runs on a headless box).

The package-free twin of ``convergence_plot.py``: one experiment per seed over
the REST routes (matplotlib installed, nothing else); --seed sets the first
run's seed and the second run uses seed + 1. The seed rides every ask as an
explicit ``config`` with ``timebox_mode: "caps"`` (deterministic work ceilings,
so the same seeds replay the same curves on the service; the service refuses
``"off"`` for a non-exempt user). Both experiments are archived at the end unless
``--keep``. Needs ``TAUOPT_BASE_URL`` and ``TAUOPT_TOKEN`` (the API https://api.tauopt.com; a token minted on the web app's tokens page);
without them it prints one line and exits 0.

    python convergence_plot_rest.py --out /tmp/tauopt-convergence-rest.png
"""

from __future__ import annotations

import argparse
import json
import math
import os
import sys
import time
import urllib.error
import urllib.request


# --- rest helper (identical in every *_rest.py example; tests/test_rest_examples.py pins it) ---
class ApiError(RuntimeError):
    """A non-2xx answer: the service's one error shape,
    {"error": {"type", "message", "details"}}."""

    def __init__(self, status: int, body: dict, headers) -> None:
        err = body.get("error") or {}
        self.status = status
        self.error_type = err.get("type", "http_error")
        self.details = err.get("details")
        ra = headers.get("Retry-After")
        self.retry_after = float(ra) if ra and ra.replace(".", "", 1).isdigit() else None
        super().__init__(f"[{status}] {self.error_type}: {err.get('message', '')}")


class _NoRedirect(urllib.request.HTTPRedirectHandler):
    """Never follow a redirect: a 301 from http:// to https:// would turn a POST into a GET."""

    def redirect_request(self, *args, **kwargs):
        return None


class Api:
    """The hosted REST API over the standard library: a bearer token, JSON in and out."""

    def __init__(
        self, base_url: str, token: str, timeout_s: float = 120.0, wait_s: float = 600.0
    ) -> None:
        self._base = base_url.rstrip("/")
        self._token = token
        self._timeout = timeout_s
        self._wait = wait_s  # the budget per call for the waits a 429 or a 503 names
        self._opener = urllib.request.build_opener(_NoRedirect)
        self.last_exhaustion: dict | None = None  # the 409 space_exhausted details ask() last saw

    def call(
        self, method: str, path: str, body: dict | None = None, wait_s: float | None = None
    ) -> dict | None:
        """One request. A non-2xx answer raises ApiError (a 429 carries retry_after); 204
        returns None; a body that is not JSON raises ApiError whatever the status (the
        service answers JSON or 204; anything else is a proxy's page).

        A 429 that names a wait in Retry-After (``bandwidth_full``, a quota, the rate limit)
        and a 503 ``experiment_busy`` are waited out, the named interval (at least 1 s) in
        sleeps of at most 30 s, and re-sent, within a budget per call: the constructor's
        ``wait_s`` unless the call passes its own (a script with a deadline passes what is
        left of it). A wait that would end past the budget raises the answer instead, with
        no further request. ``experiment_quota_exceeded`` carries no Retry-After and raises
        at once. A failure before the answer is retried twice (see ``_send``); a timeout
        after the request was sent is raised as is.
        """
        budget = self._wait if wait_s is None else wait_s
        started = time.monotonic()
        while True:
            try:
                return self._send(method, path, body)
            except ApiError as e:
                busy = e.status == 503 and e.error_type == "experiment_busy"
                if e.retry_after is None or not (e.status == 429 or busy):
                    raise
                left = max(e.retry_after, 1.0)  # a Retry-After of 0 is never a tight loop
                if time.monotonic() - started + left > budget:
                    raise
                while left > 0:
                    time.sleep(min(left, 30.0))
                    left -= 30.0

    def _send(self, method: str, path: str, body: dict | None) -> dict | None:
        req = urllib.request.Request(
            self._base + path,
            data=None if body is None else json.dumps(body).encode(),
            method=method,
            headers={
                "Authorization": f"Bearer {self._token}",
                "Content-Type": "application/json",
                "Accept": "application/json",
            },
        )
        for attempt in range(3):
            try:
                with self._opener.open(req, timeout=self._timeout) as r:
                    status, raw, headers = r.status, r.read(), r.headers
                break
            except urllib.error.HTTPError as e:  # every non-2xx answer, the 3xx included
                status, raw, headers = e.code, e.read(), e.headers
                break
            except urllib.error.URLError:
                # a failure before the answer: DNS, connect, the TLS handshake, or the send
                # itself (urllib wraps all of them in URLError; whether any byte reached the
                # service is unknowable here, so a resend of a landed POST is possible in
                # principle) -- retried twice; a timeout while WAITING for the answer is a
                # bare TimeoutError, not caught here, because the request landed: list the
                # open suggestions first
                if attempt == 2:
                    raise
                time.sleep(1.0 + attempt)
        if status == 204:
            return None
        try:
            data = json.loads(raw)
        except ValueError:
            data = {"error": {"type": "http_error", "message": raw[:200].decode(errors="replace")}}
            raise ApiError(status, data, headers) from None  # a 2xx that is not JSON too
        if status >= 300:
            raise ApiError(status, data, headers)
        return data


def ask(
    api: Api, exp_id, body: dict | None = None, wait_s: float | None = None
) -> dict | None:
    """One suggestion, or None on proven exhaustion (a completion, not an error;
    the 409's details stay on ``api.last_exhaustion``).

    ``body`` is the optional SuggestionIn (a ``config``, ``max_wait_s``). A 429 that
    names a wait and a 503 ``experiment_busy`` are waited out by ``Api.call`` (``wait_s``
    is this call's budget); ``experiment_quota_exceeded`` carries no wait: archive an
    experiment first.
    """
    try:
        return api.call(
            "POST", f"/v1/experiments/{exp_id}/suggestions", body or {}, wait_s=wait_s
        )
    except ApiError as e:
        if e.status == 409 and e.error_type == "space_exhausted":
            api.last_exhaustion = e.details
            return None
        raise


def archive(api: Api, exp_id, wait_s: float | None = None) -> None:
    """DELETE the experiment; a 404 means it is already archived (the call is idempotent).
    ``wait_s`` is this call's budget for a wait the answer names."""
    try:
        api.call("DELETE", f"/v1/experiments/{exp_id}", wait_s=wait_s)
    except ApiError as e:
        if e.error_type != "not_found":
            raise


# --- end rest helper ---


BRANIN_MIN = 0.397887  # the known global minimum, drawn as a reference line
SERIES_COLORS = ("#2a78d6", "#eb6834")  # blue, orange: a colorblind-safe pair
SURFACE, INK, INK_SOFT, GRID = "#fcfcfb", "#0b0b0b", "#52514e", "#e6e6e2"


def branin(x1: float, x2: float) -> float:
    a, b, c = 1.0, 5.1 / (4 * math.pi**2), 5 / math.pi
    r, s, t = 6.0, 10.0, 1 / (8 * math.pi)
    return a * (x2 - b * x1**2 + c * x1 - r) ** 2 + s * (1 - t) * math.cos(x1) + s


def run(api: Api, seed: int, budget: int, keep: bool) -> list[float]:
    """One optimization run; returns the best value seen after each observation."""
    exp = api.call(
        "POST",
        "/v1/experiments",
        {
            "name": f"branin-convergence-rest-seed{seed}",
            "parameters": [
                {"name": "x1", "type": "double", "bounds": [-5.0, 10.0]},
                {"name": "x2", "type": "double", "bounds": [0.0, 15.0]},
            ],
            "metric": {"name": "branin", "objective": "minimize"},
            "observation_budget": budget,
        },
    )
    exp_id = exp["id"]
    try:
        # caps: deterministic work ceilings, so same-seed runs match on the service
        config = {"strategy": "auto", "seed": seed, "timebox_mode": "caps"}
        best_so_far: list[float] = []
        for _ in range(budget):
            sug = ask(api, exp_id, body={"config": config})
            if sug is None:
                break
            value = branin(sug["assignments"]["x1"], sug["assignments"]["x2"])
            api.call(
                "POST",
                f"/v1/experiments/{exp_id}/observations",
                {"suggestion_id": sug["id"], "value": value},
            )
            best_so_far.append(min(value, best_so_far[-1]) if best_so_far else value)
    finally:
        if not keep:
            failing = sys.exc_info()[1]  # the error above, if any, stays the one reported
            try:
                archive(api, exp_id)
                print(f"experiment {exp_id} archived")
            except Exception as e:  # noqa: BLE001 -- never hide the error above
                if failing is None:
                    raise
                print(f"experiment {exp_id} not archived: {e}", file=sys.stderr)
    return best_so_far


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__.strip().split("\n\n")[0])
    ap.add_argument(
        "--seed", type=int, default=7,
        help="the seed every ask's config carries, so a rerun replays the same points"
             " (default %(default)s)",
    )
    ap.add_argument(
        "--budget", type=int, default=30,
        help="ask/observe rounds before the result is read (default %(default)s)",
    )
    ap.add_argument(
        "--out", default="/tmp/tauopt-convergence-rest.png",
        help="where the PNG is written (default %(default)s)",
    )
    ap.add_argument("--keep", action="store_true", help="leave both experiments active")
    args = ap.parse_args()
    base_url, token = os.environ.get("TAUOPT_BASE_URL"), os.environ.get("TAUOPT_TOKEN")
    if not base_url or not token:
        pair = (("TAUOPT_BASE_URL", base_url), ("TAUOPT_TOKEN", token))
        missing = "/".join(name for name, value in pair if not value)
        print(f"{missing} not set; skipping"
              " (export TAUOPT_BASE_URL=https://api.tauopt.com and a TAUOPT_TOKEN minted at app.tauopt.com/settings/tokens)")
        return 0

    try:
        import matplotlib

        # Agg renders to a file only; selected before pyplot binds a backend
        matplotlib.use("Agg")
        import matplotlib.pyplot as plt
    except ImportError as e:
        raise ImportError("this example needs matplotlib: pip install matplotlib") from e

    api = Api(base_url, token)
    curves = {seed: run(api, seed, args.budget, args.keep) for seed in (args.seed, args.seed + 1)}

    fig, ax = plt.subplots(figsize=(7.0, 4.0), dpi=150)
    fig.patch.set_facecolor(SURFACE)
    ax.set_facecolor(SURFACE)
    for color, (seed, curve) in zip(SERIES_COLORS, curves.items()):
        xs = range(1, len(curve) + 1)
        # best-so-far is a step function: it holds until the next improvement.
        # The final value rides the legend: end-of-line labels collide when
        # two runs finish close together
        ax.step(xs, curve, where="post", color=color, linewidth=2,
                label=f"seed {seed} (final {curve[-1]:.3f})")
    ax.axhline(BRANIN_MIN, color=INK_SOFT, linewidth=1, linestyle="--",
               label=f"global minimum {BRANIN_MIN:.3f}")
    ax.set_yscale("log")
    ax.set_xlabel("observations", color=INK)
    ax.set_ylabel("best value so far (log scale)", color=INK)
    ax.set_title("Branin: best-so-far per observation", color=INK)
    ax.grid(True, color=GRID, linewidth=0.6)
    ax.set_axisbelow(True)
    for side in ("top", "right"):
        ax.spines[side].set_visible(False)
    ax.legend(frameon=False)
    fig.tight_layout()
    fig.savefig(args.out, facecolor=SURFACE)

    print(f"saved {args.out}")
    for seed, curve in curves.items():
        print(json.dumps({"seed": seed, "observations": len(curve),
                          "final_best": round(curve[-1], 6)}, sort_keys=True))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())