//! In-agent socket server (loose-ends v2 + harness-local reminders +
//! questions mirror + self-service compact). Binds the harness-owned
//! `HIVE_AGENT_SOCKET` and serves the `hive-agent-sock` protocol to the
//! in-container producers — matrix / bash daemons and forge-notify are the
//! built-in ones, but any user-configured MCP server can dial the same
//! socket and push its own todos — and to
//! `hive-agent-mcp`'s `ask`/`answer`/`remind`/`get_loose_ends`/
//! `cancel_loose_end`/`compact` tool impls. Todo ops hit the harness-local
//! [`Todos`] store; a new-or-changed upsert fires an in-process [`Notify`]
//! so the serve loop drives a turn. Reminder ops hit the harness-local
//! [`Reminders`] store (`None` when the store failed to open — every
//! reminder op then returns `Response::Err`); a reminder *firing* is a
//! separate path (`reminder_timer`), not driven through this socket.
//! Question ops hit the harness-local [`Questions`] mirror the same way
//! (`None` when it failed to open) — c0re stays the actual `Ask`/`Answer`
//! routing + delivery rendezvous, this store only mirrors the durable
//! "still owed a reply" view for `get_loose_ends`. `Request::Compact` is
//! the odd one out — it doesn't touch any store, just the harness's
//! [`Bus`] (gate-checked context usage, then the same deferred
//! `compact_pending` flag the operator dashboard's `/compact` button
//! sets). No hive-c0re round-trip, no broker long-poll, no marker files.
//!
//! One request/response line per connection, matching the producers'
//! existing best-effort JSON-line clients (they just change which socket
//! they dial, not the payload).

use std::os::unix::fs::PermissionsExt;
use std::path::{Path, PathBuf};
use std::sync::Arc;

use anyhow::{Context, Result};
use hive_agent_sock::{Request, Response};
use hive_sh4re::inbox::LooseEnd;
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
use tokio::net::{UnixListener, UnixStream};
use tokio::sync::Notify;

use crate::events::Bus;
use crate::questions::{QuestionMirror, Questions, Role};
use crate::reminders::{Reminder, Reminders};
use crate::todos::{Todo, Todos};

/// Context-usage floor for `Request::Compact`: below this fraction of the
/// effective context window, an agent-initiated compact is refused (nothing
/// meaningful to reclaim yet, and it'd just burn a compaction pass on a
/// near-empty session). Same number a human operator would eyeball off the
/// dashboard's `ctx·Nk` badge before hitting the `/compact` button.
const COMPACT_MIN_USAGE_FRACTION: f64 = 0.66;

/// Resolve the in-agent socket path from `HIVE_AGENT_SOCKET`. `None` when
/// unset/empty (e.g. a standalone dev run) — the server then stays off.
fn socket_path() -> Option<PathBuf> {
    std::env::var_os("HIVE_AGENT_SOCKET")
        .filter(|v| !v.is_empty())
        .map(PathBuf::from)
}

/// Dial this same in-agent socket from elsewhere IN THIS PROCESS — the
/// harness's own `web_ui` endpoints (`api_todos`, `/api/stats` reminder
/// rollup) and `Surface::post_turn_counts` all need read access to the
/// `Todos`/`Reminders` stores this module owns behind an `Arc` on a
/// different spawned task, and a loopback dial is simpler than threading
/// those `Arc`s through every caller. One-shot, best-effort (no retry,
/// unlike the broker client): a connect failure means the socket server
/// task itself isn't up, which a retry within one call wouldn't fix.
pub(crate) async fn dial(req: &Request) -> Option<Response> {
    let path = socket_path()?;
    if !path.exists() {
        return None;
    }
    tokio::time::timeout(
        std::time::Duration::from_secs(3),
        hive_sock_client::request::<_, Response>(&path, req, hive_sock_client::Retry::None),
    )
    .await
    .ok()?
    .ok()
}

/// Run the in-agent socket server: bind + accept loop, one request/response
/// line per connection. A no-op (returns `Ok`) when `HIVE_AGENT_SOCKET` is
/// unset, so a standalone harness without producers just skips it.
///
/// # Errors
///
/// Returns an error if the socket path is set but can't be bound.
pub async fn run(
    store: Arc<Todos>,
    wake: Arc<Notify>,
    reminders: Option<Arc<Reminders>>,
    questions: Option<Arc<Questions>>,
    bus: Bus,
) -> Result<()> {
    let Some(path) = socket_path() else {
        tracing::info!("HIVE_AGENT_SOCKET unset — in-agent todo socket disabled");
        return Ok(());
    };
    let listener = bind(&path)?;
    tracing::info!(socket = %path.display(), "in-agent todo socket listening");
    loop {
        match listener.accept().await {
            Ok((stream, _)) => {
                let store = store.clone();
                let wake = wake.clone();
                let reminders = reminders.clone();
                let questions = questions.clone();
                let bus = bus.clone();
                tokio::spawn(async move {
                    if let Err(e) = handle_conn(
                        stream,
                        &store,
                        &wake,
                        reminders.as_deref(),
                        questions.as_deref(),
                        &bus,
                    )
                    .await
                    {
                        tracing::warn!(error = ?e, "in-agent todo connection failed");
                    }
                });
            }
            Err(e) => tracing::warn!(error = ?e, "in-agent todo accept failed"),
        }
    }
}

/// Bind a `UnixListener` at `path`, creating the parent dir and unlinking a
/// stale socket left by a prior boot (which would otherwise block `bind`
/// with `EADDRINUSE`).
///
/// The mode is set **here, at creation** — not corrected afterwards by
/// whoever notices. `connect(2)` on a unix socket requires *write*
/// permission, and `bind` leaves `0777 & ~umask` (typically `0755`), which
/// silently excludes every uid but the harness's own. `hive-c0re` pushes
/// todos in over this socket from the host, so that default locks it out.
/// Same two lines the sibling `web.sock` has carried all along
/// (`web_ui::serve`); access control is the containing directory's job, not
/// the socket's.
fn bind(path: &Path) -> Result<UnixListener> {
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent)
            .with_context(|| format!("create in-agent socket dir {}", parent.display()))?;
    }
    if path.exists() {
        let _ = std::fs::remove_file(path);
    }
    let listener = UnixListener::bind(path)
        .with_context(|| format!("bind in-agent socket {}", path.display()))?;
    std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o666))
        .with_context(|| format!("set perms on in-agent socket {}", path.display()))?;
    Ok(listener)
}

/// Handle one connection: read a single JSON request line, apply it to the
/// store, write the JSON response line back.
async fn handle_conn(
    stream: UnixStream,
    store: &Todos,
    wake: &Notify,
    reminders: Option<&Reminders>,
    questions: Option<&Questions>,
    bus: &Bus,
) -> Result<()> {
    let (read, mut write) = stream.into_split();
    let mut reader = BufReader::new(read);
    let mut line = String::new();
    if reader.read_line(&mut line).await? == 0 {
        return Ok(());
    }
    let resp = match serde_json::from_str::<Request>(line.trim()) {
        Ok(req) => dispatch(req, store, wake, reminders, questions, bus),
        Err(e) => Response::Err {
            message: format!("bad request: {e}"),
        },
    };
    let mut out = serde_json::to_string(&resp)?;
    out.push('\n');
    write.write_all(out.as_bytes()).await?;
    write.flush().await?;
    Ok(())
}

/// Apply one request to the store, firing `wake` on a new/changed upsert so
/// the serve loop runs a turn. Each arm calls a small named handler function
/// directly — no sub-match/`unreachable!()` indirection per family (that
/// pattern got reviewed out of the todo family in the diagnostic-logging
/// follow-up PR; kept the reminder and question families consistent with it
/// here rather than reintroducing it). `reminders`/`questions` are `None` when that store failed to open at
/// boot, in which case every op in that family returns an `Err` — each
/// handler checks for its own `None` case.
fn dispatch(
    req: Request,
    store: &Todos,
    wake: &Notify,
    reminders: Option<&Reminders>,
    questions: Option<&Questions>,
    bus: &Bus,
) -> Response {
    match req {
        Request::UpsertTodo {
            subsystem,
            key,
            summary,
            source,
            reopen_if_acked,
        } => upsert_todo(
            store,
            wake,
            &subsystem,
            key.as_deref(),
            &summary,
            source.as_deref(),
            reopen_if_acked,
        ),
        Request::ClearTodo {
            subsystem,
            key,
            all,
        } => clear_todo(store, &subsystem, key.as_deref(), all),
        Request::ListTodos { subsystem } => list_todos(store, subsystem.as_deref()),
        Request::MarkTodoDone { id } => mark_todo_done(store, id),
        Request::MarkTodosDone { ids } => mark_todos_done(store, &ids),
        Request::StoreReminder {
            message,
            timing,
            file_path,
        } => store_reminder(reminders, &message, &timing, file_path.as_deref()),
        Request::ListReminders => list_reminders(reminders),
        Request::CancelReminder { id } => cancel_reminder(reminders, id),
        Request::CountPendingReminders => count_pending_reminders(reminders),
        Request::ReminderRollup { since_secs } => reminder_rollup(reminders, since_secs),
        Request::RecordAskedQuestion {
            id,
            target,
            question,
        } => record_asked_question(questions, id, &target, &question),
        Request::RecordAnsweringQuestion {
            id,
            asker,
            question,
        } => record_answering_question(questions, id, &asker, &question),
        Request::ClearQuestion { id } => clear_question(questions, id),
        Request::ListQuestions => list_questions(questions),
        Request::Compact { wake_prompt } => compact(bus, wake_prompt),
    }
}

/// `StoreReminder` handler: persists a reminder due at `timing`.
fn store_reminder(
    reminders: Option<&Reminders>,
    message: &str,
    timing: &hive_sh4re::inbox::ReminderTiming,
    file_path: Option<&str>,
) -> Response {
    let Some(r) = reminders else {
        return no_reminders_store();
    };
    match crate::reminder_timer::store(r, message, timing, file_path) {
        Ok(_id) => Response::Ok,
        Err(message) => Response::Err { message },
    }
}

/// `ListReminders` handler: this agent's own pending reminders.
fn list_reminders(reminders: Option<&Reminders>) -> Response {
    let Some(r) = reminders else {
        return no_reminders_store();
    };
    match r.list_pending() {
        Ok(rows) => Response::LooseEnds {
            loose_ends: rows.into_iter().map(reminder_to_loose_end).collect(),
        },
        Err(e) => err(&e),
    }
}

/// `CancelReminder` handler: drops one pending reminder by id.
fn cancel_reminder(reminders: Option<&Reminders>, id: i64) -> Response {
    let Some(r) = reminders else {
        return no_reminders_store();
    };
    match r.cancel(id) {
        Ok(count) => Response::Acked {
            count: u64::try_from(count).unwrap_or(0),
        },
        Err(e) => err(&e),
    }
}

/// `CountPendingReminders` handler.
fn count_pending_reminders(reminders: Option<&Reminders>) -> Response {
    let Some(r) = reminders else {
        return no_reminders_store();
    };
    match r.count_pending() {
        Ok(count) => Response::PendingRemindersCount { count },
        Err(e) => err(&e),
    }
}

/// `ReminderRollup` handler: scheduled/delivered/pending counts over a
/// trailing `since_secs` window (`0` = all time).
fn reminder_rollup(reminders: Option<&Reminders>, since_secs: u64) -> Response {
    let Some(r) = reminders else {
        return no_reminders_store();
    };
    let since_secs = i64::try_from(since_secs).unwrap_or(i64::MAX);
    match r.rollup(since_secs) {
        Ok(stats) => Response::ReminderRollup { stats },
        Err(e) => err(&e),
    }
}

/// `RecordAskedQuestion` handler: mirror a question this agent asked.
fn record_asked_question(
    questions: Option<&Questions>,
    id: i64,
    target: &str,
    question: &str,
) -> Response {
    let Some(q) = questions else {
        return no_questions_store();
    };
    match q.record(id, Role::Asked, target, question) {
        Ok(()) => Response::Ok,
        Err(e) => err(&e),
    }
}

/// `RecordAnsweringQuestion` handler: mirror a question this agent owes a
/// reply to.
fn record_answering_question(
    questions: Option<&Questions>,
    id: i64,
    asker: &str,
    question: &str,
) -> Response {
    let Some(q) = questions else {
        return no_questions_store();
    };
    match q.record(id, Role::Answering, asker, question) {
        Ok(()) => Response::Ok,
        Err(e) => err(&e),
    }
}

/// `ClearQuestion` handler: drop the mirror row for `id` (either role).
fn clear_question(questions: Option<&Questions>, id: i64) -> Response {
    let Some(q) = questions else {
        return no_questions_store();
    };
    match q.clear(id) {
        Ok(count) => Response::Acked {
            count: u64::try_from(count).unwrap_or(0),
        },
        Err(e) => err(&e),
    }
}

/// `ListQuestions` handler: this agent's mirrored questions (both roles).
fn list_questions(questions: Option<&Questions>) -> Response {
    let Some(q) = questions else {
        return no_questions_store();
    };
    match q.list() {
        Ok(rows) => Response::LooseEnds {
            loose_ends: rows.into_iter().map(question_to_loose_end).collect(),
        },
        Err(e) => err(&e),
    }
}

/// `UpsertTodo` handler: writes/refreshes a todo row, logs the outcome, and
/// fires `wake` on a new-or-changed upsert so the serve loop runs a turn.
fn upsert_todo(
    store: &Todos,
    wake: &Notify,
    subsystem: &str,
    key: Option<&str>,
    summary: &str,
    source: Option<&str>,
    reopen_if_acked: bool,
) -> Response {
    match store.upsert(subsystem, key, summary, source, reopen_if_acked) {
        Ok((id, changed)) => {
            tracing::debug!(%subsystem, ?key, id, changed, "todo upsert");
            if changed {
                wake.notify_one();
            }
            Response::Ok
        }
        Err(e) => err(&e),
    }
}

/// `ClearTodo` handler: drops one keyed todo, or every todo in `subsystem`
/// when `all` is set.
fn clear_todo(store: &Todos, subsystem: &str, key: Option<&str>, all: bool) -> Response {
    let result = if all {
        store.clear_subsystem(subsystem)
    } else {
        store.clear(subsystem, key)
    };
    match result {
        Ok(count) => {
            tracing::debug!(%subsystem, ?key, all, count, "todo clear");
            Response::Acked {
                count: u64::try_from(count).unwrap_or(0),
            }
        }
        Err(e) => err(&e),
    }
}

/// `ListTodos` handler: read-only, so no debug logging — not relevant to
/// diagnosing wake behaviour.
fn list_todos(store: &Todos, subsystem: Option<&str>) -> Response {
    match store.list(subsystem) {
        Ok(todos) => Response::LooseEnds {
            loose_ends: todos.into_iter().map(to_loose_end).collect(),
        },
        Err(e) => err(&e),
    }
}

/// `MarkTodoDone` handler: marks a single todo done by id.
fn mark_todo_done(store: &Todos, id: i64) -> Response {
    match store.mark_done(id) {
        Ok(count) => {
            tracing::debug!(id, count, "todo mark-done");
            Response::Acked {
                count: u64::try_from(count).unwrap_or(0),
            }
        }
        Err(e) => err(&e),
    }
}

/// `MarkTodosDone` handler: bulk-acks an explicit list of todo ids — the
/// escape hatch for a backlog too large to triage one-by-one (see
/// `Todos::mark_done_many`'s doc for why it's ids, not a threshold).
fn mark_todos_done(store: &Todos, ids: &[i64]) -> Response {
    match store.mark_done_many(ids) {
        Ok(count) => {
            tracing::debug!(n_ids = ids.len(), count, "todo bulk mark-done");
            Response::Acked {
                count: u64::try_from(count).unwrap_or(0),
            }
        }
        Err(e) => err(&e),
    }
}

/// `Request::Compact` handler: gate on context usage, then queue the same
/// deferred `compact_pending` flag the operator's `/compact` button sets.
/// Mirrors `hive-agent::web_ui::actions::post_compact` but reachable from
/// the agent's own MCP tool instead of the dashboard, and refuses below
/// [`COMPACT_MIN_USAGE_FRACTION`] instead of always honouring the request —
/// an agent can call this speculatively, a human clicking the dashboard
/// button already made the judgment call. `wake_prompt`, when set, is
/// forwarded to `Bus::request_compact` so the turn loop drives a synthetic
/// follow-up turn once the compaction actually finishes.
fn compact(bus: &Bus, wake_prompt: Option<String>) -> Response {
    let Some(usage) = bus.last_ctx_usage() else {
        return Response::Err {
            message: "compact refused: no completed turn yet — nothing to compact".to_owned(),
        };
    };
    let model = bus.model();
    let window = bus.effective_context_window(&model);
    if window == 0 {
        return Response::Err {
            message: "compact refused: effective context window is unknown (0)".to_owned(),
        };
    }
    // Token counts stay well under 2^53 in practice, so the f64 conversion
    // is exact; this is a threshold ratio, not a byte-count display, but the
    // same "cosmetic precision loss" reasoning as `hivectl::quota::human_bytes` applies.
    #[allow(clippy::cast_precision_loss)]
    let fraction = usage.context_tokens() as f64 / window as f64;
    if fraction < COMPACT_MIN_USAGE_FRACTION {
        return Response::Err {
            message: format!(
                "compact refused: context usage is {:.0}% of the {window}-token window, \
                 below the {:.0}% floor — not worth compacting yet",
                fraction * 100.0,
                COMPACT_MIN_USAGE_FRACTION * 100.0
            ),
        };
    }
    let will_wake = wake_prompt.is_some();
    bus.request_compact(wake_prompt);
    bus.emit(crate::events::LiveEvent::Note {
        text: if will_wake {
            "agent: self-requested /compact (with wake prompt) — running at the end of the \
             current turn"
                .into()
        } else {
            "agent: self-requested /compact — running at the end of the current turn".into()
        },
    });
    Response::Ok
}

/// Shared "reminders db unavailable" response for every reminder op when
/// the store failed to open at boot (see `main.rs`'s best-effort open).
fn no_reminders_store() -> Response {
    Response::Err {
        message: "reminders store unavailable on this agent".to_owned(),
    }
}

/// Shared "questions mirror unavailable" response for every question op
/// when the store failed to open at boot (see `main.rs`'s best-effort open).
fn no_questions_store() -> Response {
    Response::Err {
        message: "questions mirror unavailable on this agent".to_owned(),
    }
}

/// Map a mirrored [`QuestionMirror`] to a [`LooseEnd::Question`]. `asker`/
/// `target` are derived from `role` — this agent's own label fills whichever
/// side `role` says is us, `peer` fills the other.
fn question_to_loose_end(q: QuestionMirror) -> LooseEnd {
    let now = chrono::Utc::now().timestamp();
    let age = u64::try_from(now.saturating_sub(q.asked_at.timestamp())).unwrap_or(0);
    let me = crate::identity::label();
    let (asker, target) = match q.role {
        Role::Asked => (me, Some(q.peer)),
        Role::Answering => (q.peer, Some(me)),
    };
    LooseEnd::Question {
        id: q.id,
        asker,
        target,
        question: q.question,
        age_seconds: age,
    }
}

/// Map a stored [`Reminder`] to a [`LooseEnd::Reminder`], deriving
/// `age_seconds` from `created_at` (mirrors the old c0re rendering —
/// "age" is how long the reminder has been *scheduled*, not how soon
/// it's due).
fn reminder_to_loose_end(r: Reminder) -> LooseEnd {
    let now = chrono::Utc::now().timestamp();
    let age = u64::try_from(now.saturating_sub(r.created_at.timestamp())).unwrap_or(0);
    LooseEnd::Reminder {
        id: r.id,
        owner: crate::identity::label(),
        message: r.message,
        due_at: r.due_at,
        age_seconds: age,
    }
}

/// Format a store error into an `Err` response.
fn err(e: &anyhow::Error) -> Response {
    Response::Err {
        message: format!("{e:#}"),
    }
}

/// Map a stored [`Todo`] to a [`LooseEnd::Todo`], deriving `age_seconds`
/// from `updated_at` (saturating so a backwards clock step reads 0).
fn to_loose_end(t: Todo) -> LooseEnd {
    let now = chrono::Utc::now().timestamp();
    let age = u64::try_from(now.saturating_sub(t.updated_at.timestamp())).unwrap_or(0);
    LooseEnd::Todo {
        id: t.id,
        subsystem: t.subsystem,
        subsystem_key: t.subsystem_key,
        summary: t.summary,
        source: t.source,
        age_seconds: age,
    }
}