"""Read-only CLI status command: the CLI twin of the TUI (spec §8.8, LC-9, CI-2).

Composes from the observation store (read-only) and allow-listed systemctl
properties: projection facts, four separate service facts (boot enablement,
runtime activity, last collect outcome, freshness), and a journalctl hint on
failure or staleness.  Never auto-samples, never prompts.

Freshness constants are defined once here and shared with the TUI (§8.9):
  fresh   — newest sample within 2 × cadence + AccuracySec + 60 s
  missed  — between fresh and 48 h
  stale   — ≥ 48 h
  empty   — no observations yet

Criteria: LC-9, CI-2, CI-4, FL-4, FL-5, FL-7.
"""
import sqlite3
import subprocess
import sys
from datetime import datetime, timedelta, timezone
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple

from .projection import compute_projection, ConfidenceState, DISCLOSURES
from .store import SCHEMA_VERSION


# ---------------------------------------------------------------------------
# Freshness constants (§8.9, §8.2)
# ---------------------------------------------------------------------------

CADENCE_DEFAULT_S = 300           # 5 min
ACCURACY_SEC = 30
FRESH_THRESHOLD_S = 2 * CADENCE_DEFAULT_S + ACCURACY_SEC + 60  # 690 s
STALENESS_THRESHOLD_S = 48 * 3600  # 48 h


# ---------------------------------------------------------------------------
# Configuration reading (§8.3)
# ---------------------------------------------------------------------------

CONFIG_PATH = Path("/etc/fenris/fenris.conf")


def read_config() -> Dict[str, Any]:
    """Read the world-readable configuration file.

    Returns a dict with at least 'device'.
    Raises ConfigError with a reason string on any failure.
    """
    if not CONFIG_PATH.exists():
        raise ConfigError("configuration file not found at %s" % CONFIG_PATH)

    try:
        text = CONFIG_PATH.read_text()
    except OSError as e:
        raise ConfigError("cannot read %s: %s" % (CONFIG_PATH, e))

    device = None
    for line in text.splitlines():
        line = line.strip()
        if not line or line.startswith("#"):
            continue
        if "=" in line:
            key, _, value = line.partition("=")
            key = key.strip()
            value = value.strip().strip('"').strip("'")
            if key == "device":
                device = value
                break

    if not device:
        raise ConfigError("no device selector in %s" % CONFIG_PATH)

    return {"device": device}


class ConfigError(Exception):
    """Configuration is invalid — surfaced in status as a fact (§8.3)."""
    pass


# ---------------------------------------------------------------------------
# Store opening (read-only, §3, §9.4, §9.5)
# ---------------------------------------------------------------------------

def open_store_readonly(store_path: Path) -> sqlite3.Connection:
    """Open the observation store read-only.

    Raises StoreFault if unreadable, NewerSchema if user_version > SCHEMA_VERSION.
    """
    try:
        exists = store_path.exists()
    except OSError as e:
        # A non-group user stat()ing a 2750 store directory gets
        # PermissionError before any StoreFault can be raised (issue #54).
        raise StoreFault("observation store not readable: %s" % e)
    if not exists:
        raise StoreFault("observation store not found at %s" % store_path)

    try:
        conn = sqlite3.connect("file:%s?mode=ro" % store_path, uri=True)
        conn.row_factory = sqlite3.Row
    except sqlite3.Error as e:
        raise StoreFault("observation store unreadable: %s" % e)

    try:
        cursor = conn.execute("PRAGMA user_version")
        version = cursor.fetchone()[0]
    except sqlite3.Error as e:
        conn.close()
        raise StoreFault("observation store unreadable: %s" % e)

    if version > SCHEMA_VERSION:
        conn.close()
        raise NewerSchema(version)

    return conn


class StoreFault(Exception):
    """Store is present but unreadable or corrupt (§9.4)."""
    pass


class NewerSchema(Exception):
    """Store has a newer user_version (§9.5)."""
    def __init__(self, version: int):
        self.version = version
        super().__init__("schema version %d" % version)


# ---------------------------------------------------------------------------
# Service state queries (§8.8 — allow-listed systemctl properties)
# ---------------------------------------------------------------------------

def _systemctl_show(unit: str, *properties: str) -> Dict[str, str]:
    """Query systemctl show for specific properties.  Returns empty dict on failure."""
    try:
        result = subprocess.run(
            ["systemctl", "show", unit, "--property=" + ",".join(properties)],
            capture_output=True, text=True, timeout=5,
        )
        if result.returncode != 0:
            return {}
        out = {}
        for line in result.stdout.splitlines():
            if "=" in line:
                key, _, value = line.partition("=")
                out[key.strip()] = value.strip()
        return out
    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
        return {}


def _journalctl_hint(unit: str, lines: int = 5) -> Optional[str]:
    """Get the last N journal lines for a unit.  Returns None on failure."""
    try:
        result = subprocess.run(
            ["journalctl", "-u", unit, "--no-pager", "-n", str(lines), "--output=short-iso"],
            capture_output=True, text=True, timeout=5,
        )
        if result.returncode != 0 or not result.stdout.strip():
            return None
        return result.stdout.strip()
    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
        return None


def query_service_state() -> Dict[str, Any]:
    """Query systemctl for the four separate service facts (§7.3, LC-9).

    Returns dict with keys:
      boot_enabled: bool
      timer_active: bool
      last_collect_ok: Optional[bool]
      last_collect_age_s: Optional[int]
      last_collect_reason: Optional[str]
    """
    timer_props = _systemctl_show(
        "fenris-collect.timer",
        "UnitFileState", "ActiveState", "LastTriggerUSec",
    )
    service_props = _systemctl_show(
        "fenris-collect.service",
        "ActiveState", "ExecMainStatus", "ExecMainExitTimestamp",
    )

    boot_enabled_str = timer_props.get("UnitFileState", "")
    boot_enabled = boot_enabled_str == "enabled"

    active_state = timer_props.get("ActiveState", "inactive")
    timer_active = active_state == "active"

    last_collect_ok = None
    last_collect_age_s = None
    last_collect_reason = None

    last_trigger = timer_props.get("LastTriggerUSec", "")
    if last_trigger and last_trigger != "n/a":
        try:
            trigger_dt = datetime.fromisoformat(last_trigger.replace("Z", "+00:00"))
            now = datetime.now(timezone.utc)
            last_collect_age_s = int((now - trigger_dt).total_seconds())
        except (ValueError, TypeError):
            pass

    exec_status = service_props.get("ExecMainStatus", "")
    if exec_status:
        try:
            exit_code = int(exec_status)
            last_collect_ok = exit_code == 0
            if exit_code != 0:
                last_collect_reason = "exit code %d" % exit_code
        except (ValueError, TypeError):
            pass

    return {
        "boot_enabled": boot_enabled,
        "timer_active": timer_active,
        "last_collect_ok": last_collect_ok,
        "last_collect_age_s": last_collect_age_s,
        "last_collect_reason": last_collect_reason,
    }


# ---------------------------------------------------------------------------
# Freshness grading (§8.9)
# ---------------------------------------------------------------------------

def grade_freshness(newest_sample_ts: Optional[str], clock_now: datetime) -> str:
    """Grade freshness from the newest sample timestamp (never a stored flag).

    Returns 'fresh', 'missed', 'stale', or 'empty'.
    """
    if newest_sample_ts is None:
        return "empty"

    try:
        ts = datetime.fromisoformat(newest_sample_ts)
        if ts.tzinfo is None:
            ts = ts.replace(tzinfo=timezone.utc)
        else:
            ts = ts.astimezone(timezone.utc)
    except (ValueError, TypeError):
        return "empty"

    age_s = (clock_now - ts).total_seconds()

    if age_s <= FRESH_THRESHOLD_S:
        return "fresh"
    elif age_s < STALENESS_THRESHOLD_S:
        return "missed"
    else:
        return "stale"


def freshness_age_human(age_s: Optional[int]) -> str:
    """Human-readable age string for freshness fact."""
    if age_s is None:
        return "unknown age"
    if age_s < 60:
        return "%ds ago" % age_s
    if age_s < 3600:
        return "%dm ago" % (age_s // 60)
    if age_s < 86400:
        return "%dh %dm ago" % (age_s // 3600, (age_s % 3600) // 60)
    return "%dd ago" % (age_s // 86400)


# ---------------------------------------------------------------------------
# Drive anomalies (§9.7 — FL-7)
# ---------------------------------------------------------------------------

def _query_drive_facts(conn: sqlite3.Connection) -> List[str]:
    """Query drive-reported anomalies from the latest sample (§9.7, FL-7).

    critical_warning, media errors, and unsafe shutdowns render as ordinary
    facts and never affect the projection.
    """
    cursor = conn.execute(
        "SELECT critical_warning, media_errors, unsafe_shutdowns, "
        "temperature_c, available_spare "
        "FROM samples ORDER BY id DESC LIMIT 1"
    )
    row = cursor.fetchone()
    if row is None:
        return []

    facts = []
    cw = row[0]
    if cw and cw != 0:
        facts.append("critical warning: %s" % hex(cw) if isinstance(cw, int) else str(cw))
    me = row[1]
    if me and me > 0:
        facts.append("media errors: %d" % me)
    us = row[2]
    if us and us > 0:
        facts.append("unsafe shutdowns: %d" % us)
    return facts


# ---------------------------------------------------------------------------
# Retired command rejection (§8.8)
# ---------------------------------------------------------------------------

RETIRED_COMMANDS = {
    "start": "use 'fenris monitor resume' to enable monitoring",
    "stop": "use 'fenris monitor pause' to disable monitoring",
    "run": "use 'fenris monitor resume' to enable monitoring; the timer runs in the background",
}

MIGRATION_POINTERS = {
    "--device": "device is configured in /etc/fenris/fenris.conf",
}


def check_retired_command(cmd: str) -> Optional[str]:
    """Check if a command is retired and return the migration pointer, or None."""
    return RETIRED_COMMANDS.get(cmd)


def check_retired_flag(flag: str) -> Optional[str]:
    """Check if a flag is retired and return the migration pointer, or None."""
    return MIGRATION_POINTERS.get(flag)


# ---------------------------------------------------------------------------
# Formatting
# ---------------------------------------------------------------------------

def _format_projection(proj, freshness: str, service: Dict[str, Any],
                       drive_facts: List[str], config_error: Optional[str],
                       store_fault: Optional[str], newer_schema: Optional[str],
                       journal_hint: Optional[str],
                       sample_count: int = 0, day_count: int = 0) -> str:
    """Format the complete status output."""
    lines = []

    # --- Store/system fault overrides (§9.4, §9.5) ---
    if store_fault:
        lines.append("observation store unreadable")
        if journal_hint:
            lines.append("")
            lines.append("Recent journal entries:")
            lines.append(journal_hint)
        return "\n".join(lines)

    if newer_schema:
        lines.append("observation store written by a newer Fenris — upgrade Fenris")
        return "\n".join(lines)

    # --- Configuration error (§8.3) ---
    if config_error:
        lines.append("configuration error: %s" % config_error)
        lines.append("")

    # --- Empty store (§8.9) ---
    if freshness == "empty":
        lines.append("no observations yet")
        lines.append("")
        lines.append("Enable monitoring: fenris monitor resume")
        _append_service_facts(lines, service)
        return "\n".join(lines)

    # --- Single sample: awaiting another sample (issue #73 AC3) ---
    # Only show awaiting state when there are no day aggregates (e.g., legacy import
    # or hand-crafted stores can have 1 sample but sufficient day data for projection)
    if sample_count <= 1 and day_count == 0:
        lines.append("awaiting another sample")
        lines.append("")
        lines.append("Collecting usage data — the first projection requires at least two samples.")
        _append_service_facts(lines, service)
        return "\n".join(lines)

    # --- Projection headline ---
    headline = _format_headline(proj)
    lines.append(headline)
    lines.append("")

    # --- Confidence state + contributing facts (§6.7, §6.11) ---
    state_label = proj.confidence_state.value
    facts_list = list(proj.contributing_facts) if proj.contributing_facts else []
    
    # Issue #77: Show qualifying day progress for honesty
    if proj.qualifying_days_progress:
        facts_list.insert(0, proj.qualifying_days_progress)
    
    if facts_list:
        facts_str = " · ".join(facts_list)
        lines.append("%s evidence · %s" % (state_label, facts_str))
    else:
        lines.append("%s evidence" % state_label)
    lines.append("")

    # --- Scenario range (§6.5) with horizon reasons ---
    if proj.scenario_range:
        parts = []
        for horizon in sorted(proj.scenario_range.rates.keys()):
            rate_gb_day = proj.scenario_range.rates[horizon] * 86400 / 1e9
            parts.append("%dd: %.2f GB/day" % (horizon, rate_gb_day))
        for horizon, reason in sorted(proj.scenario_range.horizon_reasons.items()):
            parts.append("%dd: %s" % (horizon, reason))
        if parts:
            lines.append("scenario range: %s" % " · ".join(parts))
            lines.append("")

    # --- PU context line (§6.1) ---
    lines.append(proj.pu_context_line)
    lines.append("")

    # --- Drive anomalies (§9.7, FL-7) ---
    if drive_facts:
        for fact in drive_facts:
            lines.append(fact)
        lines.append("")

    # --- Four separate service facts (§7.3, LC-9) ---
    _append_service_facts(lines, service)

    # --- Journal hint on failure or staleness (§8.8) ---
    if journal_hint:
        if freshness in ("missed", "stale"):
            lines.append("")
            lines.append("Recent journal entries:")
            lines.append(journal_hint)

    return "\n".join(lines)


def _format_headline(proj) -> str:
    """Format the lifespan headline or its no-projection wording (§6.11)."""
    if proj.headline_remaining_seconds is None:
        if proj.zero_rate_fact:
            return "no finite projection from this history"
        if proj.warming_fact:
            return proj.warming_fact
        return "no projection available"

    secs = proj.headline_remaining_seconds
    if secs <= 0:
        return "endurance exhausted"

    # Human-readable time
    years = int(secs // 31557600)
    rem = secs % 31557600
    days = int(rem // 86400)
    rem %= 86400
    hours = int(rem // 3600)

    parts = []
    if years:
        parts.append("%d yr" % years)
    if days or years:
        parts.append("%d d" % days)
    parts.append("%d h" % hours)

    remaining_human = " ".join(parts)

    # Regime line
    regime_parts = []
    if proj.regime_days:
        regime_parts.append("sustained regime: %d days" % proj.regime_days)

    headline = "%s remaining" % remaining_human
    if regime_parts:
        headline += " · %s" % " · ".join(regime_parts)

    return headline


def _append_service_facts(lines: List[str], service: Dict[str, Any]) -> None:
    """Append service facts and dashboard-clarity monitoring state."""
    boot = "enabled" if service.get("boot_enabled") else "disabled"
    activity = "active" if service.get("timer_active") else "inactive"

    if service.get("last_collect_ok") is True:
        collect = "ok"
    elif service.get("last_collect_ok") is False:
        collect = "FAILED"
        if service.get("last_collect_reason"):
            collect += " (%s)" % service["last_collect_reason"]
    else:
        collect = "unknown"

    collect_age = ""
    if service.get("last_collect_age_s") is not None:
        collect_age = " %s" % freshness_age_human(service["last_collect_age_s"])

    freshness_str = service.get("freshness", "unknown")
    freshness_age = ""
    if service.get("freshness_age_s") is not None:
        freshness_age = " (%s)" % freshness_age_human(service["freshness_age_s"])

    lines.append("boot: %s · timer: %s · last collect: %s%s · freshness: %s%s"
                 % (boot, activity, collect, collect_age, freshness_str, freshness_age))
    lines.append("CONTINUITY: %s" % monitoring_continuity(service))
    if service.get("deliberately_paused"):
        lines.extend(deliberate_pause_lines())


# ---------------------------------------------------------------------------
# Dashboard clarity parity wording (DC-2, DC-3)
# ---------------------------------------------------------------------------

_CONTINUITY_ACTIVE = "monitoring: active in background · persists across reboots"
_CONTINUITY_DISABLED = "monitoring: does not start on next boot"
_PAUSED_TITLE = "monitoring: paused — deliberate disable"
_PAUSED_CONSEQUENCE = (
    "paused time is excluded from your usage habit · resume: fenris monitor resume"
)


def monitoring_continuity(service: Dict[str, Any]) -> str:
    """Return the boot-persistence wording, independent of timer runtime."""
    return _CONTINUITY_ACTIVE if service.get("boot_enabled") else _CONTINUITY_DISABLED


def deliberate_pause_lines() -> List[str]:
    """Return the exact CLI/TUI presentation for a sanctioned pause."""
    return [_PAUSED_TITLE, _PAUSED_CONSEQUENCE]


def is_deliberately_paused(conn: sqlite3.Connection, service: Dict[str, Any]) -> bool:
    """Whether the latest closed period was ended by Fenris's own pause path.

    Raw systemd operations have no `user_disabled` row, so they must never be
    presented as a Deliberate disable. A live enabled timer also wins over a
    stale period marker, keeping the presentation consistent with service facts.
    """
    if service.get("boot_enabled") or service.get("timer_active"):
        return False

    open_period = conn.execute(
        "SELECT 1 FROM monitoring_periods WHERE ended_at IS NULL LIMIT 1"
    ).fetchone()
    if open_period is not None:
        return False

    row = conn.execute(
        "SELECT end_cause FROM monitoring_periods "
        "WHERE ended_at IS NOT NULL "
        "ORDER BY ended_at DESC, id DESC LIMIT 1"
    ).fetchone()
    return row is not None and row[0] == "user_disabled"


def format_disclosures() -> str:
    """Format the six disclosures (§6.11, CI-4)."""
    lines = []
    lines.append("Disclosures")
    lines.append("")
    for i, disc in enumerate(DISCLOSURES, 1):
        lines.append("%d. %s" % (i, disc))
    return "\n".join(lines)


# ---------------------------------------------------------------------------
# Main status entry point
# ---------------------------------------------------------------------------

def get_status(store_path: Optional[Path] = None, clock_now: Optional[datetime] = None,
               query_services: bool = True, query_journal: bool = True) -> str:
    """Render the complete read-only status (§8.8, LC-9).

    This is the single entry point for 'fenris status'.  It never auto-samples,
    never prompts, and never writes to the store.
    """
    if clock_now is None:
        clock_now = datetime.now(timezone.utc)

    # --- Configuration (§8.3) ---
    config_error = None
    device = None
    try:
        config = read_config()
        device = config["device"]
    except ConfigError as e:
        config_error = str(e)

    # --- Service state ---
    service = {}
    if query_services:
        service = query_service_state()

    # --- Store open ---
    store_fault = None
    newer_schema = None
    conn = None

    if store_path is None:
        store_path = Path("/var/lib/fenris/observations.db")

    try:
        conn = open_store_readonly(store_path)
    except StoreFault as e:
        store_fault = str(e)
    except NewerSchema as e:
        newer_schema = str(e)

    # --- Store fault / newer schema short-circuit ---
    if store_fault or newer_schema:
        journal_hint = None
        if query_journal:
            journal_hint = _journalctl_hint("fenris-collect.service")
        service["freshness"] = "unknown"
        service["freshness_age_s"] = None
        return _format_projection(
            None, "unknown", service, [], config_error, store_fault, newer_schema, journal_hint
        )

    # --- Freshness grading (§8.9) ---
    try:
        cursor = conn.execute("SELECT ts FROM samples ORDER BY id DESC LIMIT 1")
        row = cursor.fetchone()
        newest_ts = row[0] if row else None
    except sqlite3.Error:
        newest_ts = None

    freshness = grade_freshness(newest_ts, clock_now)

    # --- Sample count for single-sample state (issue #73 AC3) ---
    sample_count = 0
    day_count = 0
    try:
        cursor = conn.execute("SELECT COUNT(*) FROM samples")
        sample_count = cursor.fetchone()[0]
        cursor = conn.execute("SELECT COUNT(*) FROM day_aggregates")
        day_count = cursor.fetchone()[0]
    except sqlite3.Error:
        pass

    # Freshness age for the service fact
    freshness_age_s = None
    if newest_ts:
        try:
            ts = datetime.fromisoformat(newest_ts)
            if ts.tzinfo is None:
                ts = ts.replace(tzinfo=timezone.utc)
            freshness_age_s = int((clock_now - ts).total_seconds())
        except (ValueError, TypeError):
            pass

    service["freshness"] = freshness
    service["freshness_age_s"] = freshness_age_s
    try:
        service["deliberately_paused"] = is_deliberately_paused(conn, service)
    except sqlite3.Error:
        service["deliberately_paused"] = False

    # --- Drive anomalies (§9.7, FL-7) ---
    drive_facts = []
    try:
        drive_facts = _query_drive_facts(conn)
    except sqlite3.Error:
        pass

    # --- Projection (§6 — recomputed on read, never stored) ---
    try:
        proj = compute_projection(conn, clock_now)
    except Exception:
        proj = None

    # --- Journal hint on failure or staleness (§8.8) ---
    journal_hint = None
    if query_journal and freshness in ("missed", "stale"):
        journal_hint = _journalctl_hint("fenris-collect.service")

    # --- Compose output ---
    result = _format_projection(
        proj, freshness, service, drive_facts, config_error,
        None, None, journal_hint, sample_count, day_count,
    )

    conn.close()
    return result


def render_status(store_path: Optional[Path] = None, clock_now: Optional[datetime] = None,
                  query_services: bool = True, query_journal: bool = True,
                  show_disclosures: bool = False) -> str:
    """High-level status renderer: status + optional disclosures.

    Used by the CLI entry point.
    """
    parts = [get_status(store_path, clock_now, query_services, query_journal)]
    if show_disclosures:
        parts.append("")
        parts.append(format_disclosures())
    return "\n\n".join(parts)



# ---------------------------------------------------------------------------
# Shared status composition integration (issue #78)
# ---------------------------------------------------------------------------

def get_status_composition(
    store_path: Optional[Path] = None,
    clock_now: Optional[datetime] = None,
    query_services: bool = True,
    collecting: bool = False,
    reduced_motion: bool = False,
) -> 'StatusComposition':
    """Get the shared status composition consumed by both TUI and CLI.

    This is the new entry point that centralizes the status lattice.
    """
    # Lazy import to avoid circular dependency
    from .status_composition import (
        StatusComposition,
        compose_status,
    )

    if clock_now is None:
        clock_now = datetime.now(timezone.utc)

    # --- Configuration (§8.3) ---
    # Config errors are surfaced through the store fault mechanism

    # --- Service state ---
    service = {}
    if query_services:
        try:
            service = query_service_state()
        except Exception:
            service = None

    # --- Store open ---
    store_fault = None
    newer_schema = None
    conn = None

    if store_path is None:
        store_path = Path("/var/lib/fenris/observations.db")

    try:
        conn = open_store_readonly(store_path)
    except StoreFault as e:
        store_fault = str(e)
    except NewerSchema as e:
        newer_schema = str(e)

    # --- Use shared composition ---
    if conn is not None:
        try:
            comp = compose_status(
                conn, service, clock_now,
                store_fault=store_fault,
                newer_schema=newer_schema,
                collecting=collecting,
                reduced_motion=reduced_motion,
            )
        finally:
            conn.close()
    else:
        # Store fault or newer schema - compose without store data
        comp = compose_status(
            None, service, clock_now,
            store_fault=store_fault,
            newer_schema=newer_schema,
            collecting=collecting,
            reduced_motion=reduced_motion,
        )

    return comp