"""Typed executable assembly for launch, recovery, and verification."""

from __future__ import annotations

import sys
from dataclasses import dataclass
from enum import StrEnum
from pathlib import Path
from typing import assert_never

from .contract import SOURCE_FILE_DIGEST, SOURCE_ROW_DIGEST
from .controller import ControllerPorts, execute, recover
from .fdio import create_control_root
from .journal import OneUseLedger, PhaseContext, PhaseJournal
from .observer_systemd import SystemdObserverControl
from .permission import PermissionPackage, load_permission
from .production import DurableReceiptWriter, InstalledRowExecutor
from .verifier import ExactInputVerifier


class Command(StrEnum):
    """Closed executable command set."""

    EXECUTE = "execute"
    RECOVER = "recover"
    VERIFY = "verify"


@dataclass(frozen=True, slots=True)
class Arguments:
    """Parsed command-line boundary."""

    command: Command
    permission_root: Path
    approval: str | None


class CliError(RuntimeError):
    """CLI arguments or sealed assembly are invalid."""


def parse_arguments(raw: tuple[str, ...]) -> Arguments:
    """Parse the fixed positional CLI without an untyped argument namespace."""
    if len(raw) not in {2, 3}:
        raise CliError("usage: <execute|recover|verify> <permission-root> [approval]")
    command = Command(raw[0])
    approval = raw[2] if len(raw) == 3 else None
    if (command is Command.EXECUTE) != (approval is not None):
        raise CliError("approval is required only for execute")
    return Arguments(command, Path(raw[1]), approval)


def assemble(package: PermissionPackage) -> ControllerPorts:
    """Instantiate concrete installed-store, receipt, and systemd ports."""
    contract = package.contract
    context = PhaseContext(package.package_digest, SOURCE_ROW_DIGEST, SOURCE_FILE_DIGEST)
    return ControllerPorts(
        ExactInputVerifier(),
        OneUseLedger(contract.authorization_root, package.package_digest),
        PhaseJournal(contract.execution_root, context),
        InstalledRowExecutor(contract, package.runtime.customer_key_file),
        DurableReceiptWriter(contract.execution_root, contract),
        SystemdObserverControl(
            package.runtime.observer_baseline_log,
            package.runtime.observer_output_log,
            package.runtime.observer_timer_unit,
            package.runtime.observer_service_unit,
            package.runtime.observer_timeout_seconds,
        ),
    )


def run(arguments: Arguments) -> str:
    """Run one sealed command and return its machine-consumed result."""
    package = load_permission(arguments.permission_root)
    match arguments.command:
        case Command.VERIFY:
            ExactInputVerifier().verify(package.contract)
            return package.package_digest
        case Command.EXECUTE:
            create_control_root(package.contract.authorization_root)
            create_control_root(package.contract.execution_root)
            if arguments.approval is None:
                raise CliError("approval")
            return execute(
                arguments.approval,
                package.contract,
                assemble(package),
                authorized_digest=package.package_digest,
            )
        case Command.RECOVER:
            return recover(package.contract, assemble(package))
        case unreachable:
            assert_never(unreachable)


def main() -> int:
    """Execute the typed boundary and print only the terminal digest."""
    result = run(parse_arguments(tuple(sys.argv[1:])))
    _ = sys.stdout.write(result + "\n")
    return 0