"""Hosted-merge invariants requested by the merge owner (o-8f): SPEC, runnable later.

These need a server that implements ``oak merge`` (hosted squash-merge onto

main). Loopback ``oak serve`` 0.105.0 answers merge publication with 404, so

today every case is an ``unsupported`` row. When a LOCAL oakspace is available,

set ``OAK_BENCH_ROBUSTNESS_OAKSPACE_URL=http://127.0.0.1:<port>`` (loopback

only; the harness refuses any other host and never targets oak.space).

Invariants (base: o-8f's M0a stress harness):

H1 ``acked_merge_on_main``      every ``oak merge --json`` that reports success

    (exit 0, merged commit C) leaves C reachable from main, read back by an

    independent reader of the server store (not the merging client).

H2 ``main_never_loses_landed``  main's history is append-only across the run:

    every commit ever observed as main's head stays an ancestor of the final

    main head (checked with the lincheck register model, reads = observed heads).

H3 ``push_during_merge_not_dropped`` (M0b) a push to branch B acknowledged

    while a merge of B is in flight is either included in the merged result or

    remains on B as unmerged work (B not closed over it); never silently dropped.

H4 ``concurrent_merges_serialize`` (M0a) K concurrent merges of distinct

    branches all land (or fail actionably), main's head sequence is

    linearizable, and each landed change's files are in main's final tree.

H5 ``ambiguous_merge_not_success`` a merge whose reply is lost (fault proxy

    drop_after_send on the merge publication) is never reported as success

    without reconciliation, and a retry never double-applies.

"""

from __future__ import annotations

import ipaddress

import os

from urllib.parse import urlparse

ENV = "OAK_BENCH_ROBUSTNESS_OAKSPACE_URL"

CASES = (

    ("acked_merge_on_main", "merge_hosted"),

    ("main_never_loses_landed", "merge_hosted"),

    ("push_during_merge_not_dropped", "merge_hosted"),

    ("concurrent_merges_serialize", "merge_hosted"),

    ("ambiguous_merge_not_success", "merge_hosted"),

)

def configured_url() -> tuple[str | None, str]:

    url = os.environ.get(ENV)

    if not url:

        return None, (f"hosted merge invariants are spec-only: set {ENV} to a LOOPBACK oakspace "

                      "(loopback oak serve 0.105.0 returns 404 for merge publication)")

    host = urlparse(url).hostname or ""

    try:

        loopback = ipaddress.ip_address(host).is_loopback

    except ValueError:

        loopback = host == "localhost"

    if not loopback:

        return None, f"refusing non-loopback hosted target {host!r}: fault/stress cases run against local oakspace only"

    return url, ""

def rows_spec() -> list[dict]:

    """One unsupported row per hosted invariant until a local oakspace driver exists."""

    url, reason = configured_url()

    if url is not None:

        reason = ("local oakspace configured, but the hosted driver is not implemented in suite v1; "

                  "see suites/robustness/robustness/hosted.py for the invariant contract")

    return [{"invariant_id": name, "operation": op, "skip_reason": reason} for name, op in CASES]