"""Consolidation evidence for new applications; historical OTA names stay exact."""
import json
import re
import sys

from optional_display_profiles import resolved_defines, spec_for_defines

SPECS = (
    dict(key="combinedCompanion", capability="companion.picow.combined",
         marker="meshcore.capability.companion.picow.combined.v1",
         platform="RP2040_PLATFORM", board="rpipicow", target=r"PicoW_companion_radio",
         defines={"PICOW_COMBINED_COMPANION": "1", "ENABLE_USB_INTERFACE": "1",
                  "ENABLE_WIFI_INTERFACE": "1", "PIO_FRAMEWORK_ARDUINO_ENABLE_BLUETOOTH": "1"}),
    dict(key="oledExpansionCompatible", capability="hardware.heltec_v4.oled_kit",
         marker="meshcore.capability.hardware.heltec_v4.oled_kit.v1",
         platform="ESP32_PLATFORM", board="heltec_v4",
         target=r"heltec_v4_(?:repeater|room_server)(?:_observer_mqtt)?",
         defines={"HELTEC_V4_OLED_KIT_COMPAT": "1", "HELTEC_LORA_V4_OLED": "1",
                  "DISPLAY_CLASS": "SSD1306Display", "ENV_PIN_SDA": "4", "ENV_PIN_SCL": "3"}),
    dict(key="displayRotation", capability="display.rotation.runtime",
         marker="meshcore.capability.display.rotation.heltec_r8.v1",
         platform="ESP32_PLATFORM", board="heltec_v4_r8",
         target=r"heltec_v4_r8_tft_(?:(?:repeater|room_server)(?:_observer_mqtt)?|sensor|companion_radio_full)",
         defines={"HELTEC_TFT_RUNTIME_ROTATION": "1", "HELTEC_V4_R8_TFT": "1",
                  "DISPLAY_CLASS": "ST7789LCDDisplay"}),
    dict(key="tftExpansionCompatible", capability="hardware.heltec_v4.tft_kit",
         marker="meshcore.capability.hardware.heltec_v4.tft_kit.v1",
         platform="ESP32_PLATFORM", board="heltec_v4", target=r"heltec_v4_tft_companion_radio_full_femon",
         defines={"HELTEC_V4_TFT_KIT_COMPAT": "1", "HELTEC_LORA_V4_TFT": "1",
                  "DISPLAY_CLASS": "ST7789LCDDisplay"}),
)


def specs_for_config(target, env):
    defines = resolved_defines(env.get("build_flags", []))
    return [spec for spec in SPECS if env.get("board") == spec["board"]
            and re.fullmatch(spec["target"], target, re.I)
            and all(defines.get(key) == value for key, value in spec["defines"].items())]


def proven(manifest, spec):
    return (manifest.get("verified") is True and manifest.get("platform") == spec["platform"]
            and re.fullmatch(spec["target"], manifest.get("target", ""), re.I)
            and spec["capability"] in manifest.get("capabilities", [])
            and any(row.get("capability") == spec["capability"] and row.get("present") is True
                    and row.get("source") == "packaged application" and row.get("evidence") == spec["marker"]
                    for row in manifest.get("verification", [])))


def runtime_metadata(manifest, env, release_source):
    result = {}
    for spec in SPECS:
        if spec["capability"] not in manifest.get("capabilities", []):
            continue
        if spec not in specs_for_config(manifest["target"], env) or not proven(manifest, spec):
            raise ValueError(manifest["target"] + ": consolidation requires exact configuration and packaged application proof")
        source = manifest.get("source_commit", release_source)
        if not isinstance(source, str) or not re.fullmatch(r"[0-9a-f]{40}", source) or source != release_source:
            raise ValueError("Consolidation metadata requires the exact release source")
        result[spec["key"]] = True
        result[spec["key"] + "Source"] = source
    return result


def replacements(target):
    """Known functionality successors, never aliases for deployed update IDs."""
    if re.fullmatch(r"PicoW_companion_radio_(?:usb|ble|wifi)", target, re.I):
        return [("PicoW_companion_radio", "combinedCompanion")]
    if re.fullmatch(r"heltec_v4(?:_3)?_expansionkit_tft_companion_radio_(?:usb|ble|wifi|full)(?:_ps)?(?:_fem(?:on|off))?", target, re.I):
        return [("heltec_v4_tft_companion_radio_full_femon", "tftExpansionCompatible")]
    match = re.fullmatch(r"muzi_base_(uno|duo)_superio_companion_radio_(?:usb|ble|full)", target, re.I)
    if match:
        return [("muzi_base_" + match[1].lower() + "_companion_radio_full", "muziAccessories")]
    if re.fullmatch(r"LilyGo_T-Echo-Lite_non_shell_companion_radio_(?:usb|ble|full)", target, re.I):
        return [("LilyGo_T-Echo-Lite_companion_radio_full", "techoLiteDisplay")]
    match = re.fullmatch(r"heltec_v4_expansionkit_(repeater|room_server)(_observer_mqtt)?", target, re.I)
    if match:
        base = "heltec_v4_" + match[1].lower()
        return [(base + (match[2] or ""), "oledExpansionCompatible"), (base, "oledExpansionCompatible")]
    match = re.fullmatch(r"heltec_v4_r8_tft_portrait_(repeater|room_server)_observer_mqtt", target, re.I)
    if match:
        base = "heltec_v4_r8_tft_" + match[1].lower()
        return [(base + "_observer_mqtt", "displayRotation"), (base, "displayRotation")]
    match = re.fullmatch(r"heltec_rc32_without_display_(repeater|room_server|sensor|companion_radio_(?:usb|ble|wifi|full))(?:_observer_mqtt)?", target, re.I)
    if match:
        return [(target.lower().replace("_without_display_", "_", 1), "displayAuto")]
    return []


def configuration_replacement(target, envs):
    def environment(name):
        # Full nRF52 targets can be generated by build.sh from their exact
        # USB or BLE base. Never substitute another physical radio variant.
        for choice in (name, name.replace("_companion_radio_full", "_companion_radio_usb"),
                       name.replace("_companion_radio_full", "_companion_radio_ble")):
            if "env:" + choice in envs:
                return envs["env:" + choice]
        return None
    for candidate, key in replacements(target):
        env = environment(candidate)
        source_env = environment(target)
        if not env or not source_env or env.get("board") != source_env.get("board"):
            continue
        if key in ("displayAuto", "muziAccessories", "techoLiteDisplay"):
            spec = spec_for_defines(resolved_defines(env.get("build_flags", [])), env.get("board"))
            expected = {"displayAuto": "rc32", "muziAccessories": "muzi_superio", "techoLiteDisplay": "techo_lite"}[key]
            qualified = spec and spec["marker"] == expected and re.fullmatch(spec["targets"], candidate.lower())
        else:
            qualified = any(spec["key"] == key for spec in specs_for_config(candidate, env))
        if qualified:
            return candidate
    return None


def omit_redundant_records(records):
    """Remove resumed alternatives only with an actual qualified successor."""
    def same_policy(left, right):
        return (left.get("build_profile") == right.get("build_profile")
                and sorted(x for x in left.get("capabilities", []) if x.startswith("sensor.profile."))
                == sorted(x for x in right.get("capabilities", []) if x.startswith("sensor.profile.")))

    def qualified(manifest, key):
        if key in ("displayAuto", "muziAccessories", "techoLiteDisplay"):
            from optional_display_profiles import marker, SPECS as displays
            expected = {"displayAuto": "rc32", "muziAccessories": "muzi_superio", "techoLiteDisplay": "techo_lite"}[key]
            spec = next((s for s in displays if s["marker"] == expected
                         and re.fullmatch(s["targets"], manifest.get("target", "").lower())), None)
            if spec is None:
                return False
            transport = key == "displayAuto" or (
                {"companion.usb", "companion.bluetooth"} <= set(manifest.get("capabilities", []))
                and {"companion.usb", "companion.bluetooth"} <= {
                    row.get("capability") for row in manifest.get("verification", [])
                    if row.get("present") is True and row.get("source") == "linked image" and row.get("evidence")})
            return (transport and manifest.get("verified") is True
                    and manifest.get("platform") == spec.get("platform", "ESP32_PLATFORM")
                    and "display.autodetect" in manifest.get("capabilities", [])
                    and any(row.get("capability") == "display.autodetect" and row.get("present") is True
                            and row.get("source") == "packaged application" and row.get("evidence") == marker(spec)
                            for row in manifest.get("verification", [])))
        return any(s["key"] == key and proven(manifest, s) for s in SPECS)

    result = []
    for record in records:
        manifest = record["manifest"]
        alternatives = replacements(manifest["target"])
        if not any(candidate["manifest"]["target"].lower() == target.lower()
                   and (same_policy(manifest, candidate["manifest"])
                        or key in ("muziAccessories", "techoLiteDisplay")
                        and candidate["manifest"].get("build_profile") == "full"
                        and manifest["target"].lower().endswith(("_usb", "_ble")))
                   and qualified(candidate["manifest"], key)
                   for target, key in alternatives for candidate in records):
            result.append(record)
    return result


if __name__ == "__main__":
    envs = {name: dict(options) for name, options in json.load(sys.stdin)}
    mode, target = sys.argv[1:]
    if mode == "replacement":
        result = configuration_replacement(target, envs)
        if result is None:
            sys.exit(1)
        print(result)
    elif mode == "expectations":
        for spec in specs_for_config(target, envs.get("env:" + target, {})):
            print(spec["capability"] + "=" + spec["marker"])
    else:
        raise SystemExit("Unknown consolidation operation")