"""Health-check background task.

Registers an APScheduler job that probes the fail2ban socket every 30 seconds
and stores the result on ``app.state.server_status``.  The dashboard endpoint
reads from this cache, keeping HTTP responses fast and the daemon connection
decoupled from user-facing requests.

Crash detection (Task 3)
------------------------
When a jail activation is performed, the router stores a timestamp on
``app.state.last_activation`` (a ``dict`` with ``jail_name`` and ``at``
keys).  If the health probe subsequently detects an online→offline transition
within 60 seconds of that activation, a
:class:`~app.models.config.PendingRecovery` record is written to
``app.state.pending_recovery`` so the UI can offer a one-click rollback.

Correlation IDs are propagated through the task using :mod:`app.utils.correlation`
so that task logs can be correlated across runs.
"""

from __future__ import annotations

import asyncio
import datetime
import uuid
from contextvars import copy_context
from typing import TYPE_CHECKING

from app.utils.logging_compat import get_logger

from app.models.server import ServerStatus
from app.services import health_service
from app.tasks.timeout_utils import run_with_timeout
from app.utils.correlation import reset_correlation_id, set_correlation_id
from app.utils.runtime_state import (
    RuntimeState,
    get_effective_settings,
    get_runtime_state,
    process_health_probe_result,
)

if TYPE_CHECKING:  # pragma: no cover
    from fastapi import FastAPI

    from app.config import Settings

log = get_logger(__name__)


#: How often the probe fires (seconds).
HEALTH_CHECK_INTERVAL: int = 30

#: Maximum seconds to allow for health probe to complete.
HEALTH_PROBE_TIMEOUT_SECONDS: int = 10


async def _run_probe_with_resources(
    settings: Settings,
    runtime_state: RuntimeState,
    correlation_id: str | None = None,
) -> None:
    """Probe fail2ban and cache the result on the runtime state.

    Args:
        settings: The resolved application settings used for the probe.
        runtime_state: The mutable runtime state manager.
        correlation_id: Optional correlation ID for log correlation.
    """
    if correlation_id is None:
        correlation_id = str(uuid.uuid4())

    token = set_correlation_id(correlation_id)
    try:
        # Use copy_context() so ContextVar values (e.g. correlation_id)
        # propagate to any child asyncio tasks spawned inside the coroutine.
        probe_task = asyncio.create_task(
            _do_probe_with_resources(settings, runtime_state),
            context=copy_context(),
        )
        await run_with_timeout("health_check", probe_task, HEALTH_PROBE_TIMEOUT_SECONDS)
    finally:
        # Reset AFTER run_with_timeout completes, so child tasks still
        # have the correlation ID in their context while they log.
        reset_correlation_id(token)


async def _do_probe_with_resources(settings: Settings, runtime_state: RuntimeState) -> None:
    """Inner probe logic that runs with correlation context set."""
    socket_path: str = settings.fail2ban_socket
    status: ServerStatus = await health_service.probe(socket_path)
    process_health_probe_result(runtime_state, status)


async def _run_probe(app: FastAPI) -> None:
    await _run_probe_with_resources(
        get_effective_settings(app),
        get_runtime_state(app),
    )


async def run_probe(app: FastAPI) -> None:
    """Run a single health probe outside the scheduled job context."""
    await _run_probe(app)


def register(app: FastAPI) -> None:
    """Add the health-check job to the application scheduler.

    Must be called after the scheduler has been started (i.e., inside the
    lifespan handler, after ``scheduler.start()``).

    Args:
        app: The :class:`fastapi.FastAPI` application instance whose
            ``app.state.scheduler`` will receive the job.
    """
    # Initialise the cache with an offline placeholder so the dashboard
    # endpoint is always able to return a valid response even before the
    # first probe fires.
    settings = get_effective_settings(app)
    runtime_state = get_runtime_state(app)

    runtime_state.server_status = ServerStatus(online=False)

    # Initialise activation tracking state.
    runtime_state.last_activation = None
    runtime_state.pending_recovery = None

    app.state.scheduler.add_job(
        _run_probe_with_resources,
        trigger="interval",
        seconds=HEALTH_CHECK_INTERVAL,
        kwargs={"settings": settings, "runtime_state": runtime_state},
        id="health_check",
        replace_existing=True,
        # Fire immediately on startup too, so the UI isn't dark for 30 s.
        next_run_time=datetime.datetime.now(tz=datetime.UTC),
    )
    log.info(
        "health_check_scheduled",
        interval_seconds=HEALTH_CHECK_INTERVAL,
    )
