from __future__ import annotations

import argparse
import json
import os
import subprocess
from typing import TYPE_CHECKING, Any

from cli.administration.inventory.provision.services_disabler import (
    find_provider_roles,
    parse_services_disabled,
)

from . import PROJECT_ROOT
from .common import (
    make_compose,
    resolve_container,
)
from .inventory import plan_dev_inventory_matrix
from .variant_select import add_variant_args, apply_variant_filter

if TYPE_CHECKING:
    from collections.abc import Mapping


def _env_full_cycle() -> bool:
    return os.environ.get("full_cycle", "").strip().lower() == "true"


def _run_deploy(
    compose,
    *,
    deploy_ids: list[str],
    debug: bool,
    passthrough: list[str],
    inventory_dir: str,
    container_name: str,
    extra_ansible_vars: Mapping[str, Any] | None = None,
) -> int:
    inv_root = str(inventory_dir).rstrip("/")
    inv_file = f"{inv_root}/devices.yml"
    pw_file = f"{inv_root}/.password"

    cmd = [
        "python3",
        "-m",
        "cli.administration.deploy.dedicated",
        inv_file,
        "-p",
        pw_file,
        "-vv",
        "--assert",
        "true",
        "--diff",
        "--id",
        *deploy_ids,
    ]
    if debug:
        cmd.insert(cmd.index("--diff") + 1, "--debug")

    if extra_ansible_vars:
        for key, value in extra_ansible_vars.items():
            cmd.extend(["-e", f"{key}={json.dumps(value)}"])

    if passthrough:
        cmd.extend(passthrough)

    extra_env: dict[str, str] = {
        "ANSIBLE_FORCE_COLOR": "1",
        "PY_COLORS": "1",
        "TERM": "xterm-256color",
    }
    services_disabled = os.environ.get("disable", "")
    if services_disabled:
        extra_env["disable"] = services_disabled

    ansible_log_path = (
        os.environ.get("ANSIBLE_LOG_PATH") or "/tmp/infinito-deploy.log"  # noqa: S108
    )
    extra_env["ANSIBLE_LOG_PATH"] = ansible_log_path

    for key in (
        "GH_TOKEN",
        "GITHUB_TOKEN",
        "GITHUB_REPOSITORY_OWNER",
        "GITHUB_REPOSITORY",
        "INFINITO_IMAGE_TAG",
        "INFINITO_GHCR_MIRROR_PREFIX",
    ):
        val = os.environ.get(key)
        if val:
            extra_env[key] = val

    r = compose.exec(
        cmd,
        check=False,
        live=True,
        extra_env=extra_env,
    )

    return int(r.returncode)


def _maybe_recover_drill(compose, plan_index: int) -> None:
    """Verify recovery between PASS 1 and PASS 2 of the first round: seed a
    backup tree and `recover full` it back on this single host. Gated by
    INFINITO_RECOVER_DRILL (off by default); raises on drill failure so the
    deploy fails fast before the async pass."""
    if plan_index != 0:
        return
    if (os.environ.get("INFINITO_RECOVER_DRILL") or "").strip().lower() != "true":
        return
    print("=== recover drill (backup/recover verification between passes) ===")
    compose.exec(
        ["bash", "/opt/src/infinito/scripts/tests/deploy/ci/recover_drill.sh"],
        extra_env={"INFINITO_REPO_ROOT": "/opt/src/infinito"},
        live=True,
    )


def _purge_app_entities(*, container: str, app_ids: list[str]) -> None:
    """Run the per-app cleanup script for every app from the previous
    matrix-deploy round before the next round starts.

    `scripts/tests/deploy/local/purge/entity.sh` removes the
    application's containers, networks, and Ansible-managed state on
    the host so the next round boots from a clean slate. Failures are
    surfaced (the matrix MUST NOT silently mix variant state across
    rounds).
    """
    if not app_ids:
        return
    repo_root = PROJECT_ROOT
    purge_script = (
        repo_root / "scripts" / "tests" / "deploy" / "local" / "purge" / "entity.sh"
    )
    env = os.environ.copy()
    env["apps"] = ",".join(app_ids)
    env["INFINITO_CONTAINER"] = container
    print(
        "=== matrix-deploy: purging entities between rounds for "
        f"{', '.join(app_ids)} ==="
    )
    subprocess.run(
        ["bash", str(purge_script)],
        cwd=str(repo_root),
        env=env,
        check=True,
    )


def add_parser(sub: argparse._SubParsersAction) -> None:
    p = sub.add_parser(
        "deploy", help="Run deploy inside the infinito container (requires inventory)."
    )
    p.add_argument(
        "--inventory-dir",
        default=os.environ.get("INFINITO_INVENTORY_DIR"),
        required=os.environ.get("INFINITO_INVENTORY_DIR") is None,
        help=(
            "Inventory directory base (default: $INFINITO_INVENTORY_DIR). When the "
            "primary apps declare more than one matrix-deploy variant, the "
            "wrapper iterates the sibling folders `<dir>-0`, `<dir>-1`, ... "
            "produced by the matching `init` step; otherwise the directory "
            "is used as-is."
        ),
    )

    g = p.add_mutually_exclusive_group(required=True)
    g.add_argument(
        "--apps",
        help="One or more application ids (will include run_after deps automatically).",
    )
    g.add_argument(
        "--id",
        nargs="+",
        default=None,
        help="Explicit application ids (space-separated).",
    )
    p.add_argument(
        "--debug",
        action=argparse.BooleanOptionalAction,
        default=False,
        help="Enable/disable Ansible debug mode (default: disabled).",
    )
    add_variant_args(p, action="deploy")
    p.add_argument(
        "--full-cycle",
        action=argparse.BooleanOptionalAction,
        default=_env_full_cycle(),
        help=(
            "After each round's regular deploy, immediately re-run the "
            "deploy with `-e ASYNC_ENABLED=true` (the async update pass). "
            "Pass 1 + Pass 2 stay co-located on the SAME variant so the "
            "async re-deploy always runs against the host state the "
            "matching sync deploy just produced. Defaults to the "
            "full_cycle environment variable (true|false) when set."
        ),
    )
    p.add_argument(
        "ansible_args",
        nargs=argparse.REMAINDER,
        help="Passthrough args appended to `cli.administration.deploy.dedicated` (use `--` to separate).",
    )
    p.set_defaults(_handler=handler)


def handler(args: argparse.Namespace) -> int:
    compose = make_compose()

    if args.apps:
        primary_app_ids = [
            a.strip() for a in args.apps.replace(",", " ").split() if a.strip()
        ]
    else:
        primary_app_ids = list(args.id or [])

    raw_disabled = os.environ.get("disable", "").strip()
    disabled_app_ids: set[str] = set()
    if raw_disabled:
        services = parse_services_disabled(raw_disabled)
        roles_dir = compose.repo_root / "roles"
        provider_map = find_provider_roles(services, roles_dir)
        disabled_app_ids = set(provider_map.values())
        primary_app_ids = [
            app_id for app_id in primary_app_ids if app_id not in disabled_app_ids
        ]

    if not primary_app_ids:
        raise SystemExit("All primary apps disabled by `disable` — nothing to deploy")

    passthrough = list(args.ansible_args or [])
    if passthrough and passthrough[0] == "--":
        passthrough = passthrough[1:]

    plan = plan_dev_inventory_matrix(
        roles_dir=str(compose.repo_root / "roles"),
        primary_apps=primary_app_ids,
        base_inventory_dir=str(args.inventory_dir),
    )
    try:
        plan = apply_variant_filter(plan, args)
    except ValueError as exc:
        raise SystemExit(f"--variant: {exc}") from exc

    container_name = resolve_container()

    rc = 0
    for plan_index, (
        round_index,
        inv_dir,
        round_variants,
        include_R,
        purge_set_R,
    ) in enumerate(plan):
        round_include = [role for role in include_R if role not in disabled_app_ids]
        round_deploy_ids = round_include

        if plan_index > 0:
            purge_targets = [
                role for role in purge_set_R if role not in disabled_app_ids
            ]
            _purge_app_entities(container=container_name, app_ids=purge_targets)

        pass_label = (
            f"matrix-deploy: round {round_index + 1}/{len(plan)} "
            f"inv={inv_dir} variants={round_variants} apps={round_deploy_ids}"
        )
        print(f"=== {pass_label} PASS 1 (sync) ===")
        rc = _run_deploy(
            compose,
            deploy_ids=round_deploy_ids,
            debug=bool(args.debug),
            passthrough=passthrough,
            inventory_dir=inv_dir,
            container_name=container_name,
            extra_ansible_vars={"VARIANT_INDEX": round_index},
        )
        if rc != 0:
            return rc

        if bool(args.full_cycle):
            _maybe_recover_drill(compose, plan_index)
            print(f"=== {pass_label} PASS 2 (async) ===")
            rc = _run_deploy(
                compose,
                deploy_ids=round_deploy_ids,
                debug=bool(args.debug),
                passthrough=passthrough,
                inventory_dir=inv_dir,
                container_name=container_name,
                extra_ansible_vars={
                    "ASYNC_ENABLED": True,
                    "VARIANT_INDEX": round_index,
                },
            )
            if rc != 0:
                return rc

    return rc