//! Topology (set-parent) endpoints for the dashboard.
//!
//! Operator-driven agent reparenting — single (`/api/topology/set-parent`,
//! form-encoded) and bulk (`/api/topology/set-parent-bulk`, JSON array →
//! one git commit). Both go through `Coordinator::reparent*_with_notify`,
//! which wraps `topology::set_parent` with the move-notification messages
//! and the `ContainerView` rescan.

use axum::{
    extract::{Form, State},
    http::StatusCode,
    response::{IntoResponse, Response},
};
use serde::Deserialize;

use problem_details::ProblemDetails;

use super::{AppState, error_problem, error_response};

/// `POST /api/topology/set-parent` body. `child` is required.
/// `new_parent` may be:
/// - absent or empty / whitespace-only → promote to root,
/// - non-empty → new parent's logical name.
///
/// (The CLI surface gates "no parent specified" behind an explicit
/// `--root` flag for safety; the HTTP surface is permissive
/// because the dashboard form encodes "no value" as the empty
/// string for the optional radio-group input.)
#[derive(Deserialize)]
pub(super) struct SetParentForm {
    child: String,
    new_parent: Option<String>,
}

/// One entry in a `POST /api/topology/set-parent-bulk` JSON array.
/// `new_parent`: absent/null/empty-string all mean "promote to root".
#[derive(Deserialize)]
pub(super) struct SetParentBulkEntry {
    child: String,
    #[serde(default)]
    new_parent: Option<String>,
}

/// `POST /api/topology/set-parent` — operator-driven parent move.
/// Form fields: `child` (required, agent name), `new_parent`
/// (optional — empty / absent string ⇒ promote to root). Refuses
/// cycles and unknown agents. The manager is reparentable like any
/// other agent — its privileges come from the privileged MCP socket,
/// not its tree position. On success
/// re-emits container snapshots so the dashboard tree repaints
/// without a refresh.
pub(super) async fn post_set_parent(
    State(state): State<AppState>,
    Form(form): Form<SetParentForm>,
) -> Result<Response, ProblemDetails> {
    let child = form.child.trim().to_owned();
    if child.is_empty() {
        return Err(ProblemDetails::from_status_code(StatusCode::BAD_REQUEST)
            .with_detail("set-parent: `child` required"));
    }
    // Empty / whitespace-only `new_parent` ⇒ promote to root. Web
    // forms submit the empty string for a "no value" radio button,
    // so this is the ergonomic encoding.
    let new_parent = form
        .new_parent
        .as_deref()
        .map(str::trim)
        .filter(|s| !s.is_empty())
        .map(str::to_owned);
    // `reparent_with_notify` wraps `topology::set_parent` with the
    // three notification messages + the ContainerView rescan.
    // Idempotent same-parent calls skip both the messages and the
    // disk write per the topology fast-path.
    match state
        .coord
        .reparent_with_notify(&child, new_parent.as_deref())
        .await
    {
        Ok(()) => {
            tracing::info!(
                child = %child,
                new_parent = ?new_parent,
                "operator: set-parent via dashboard"
            );
            Ok((StatusCode::OK, "ok").into_response())
        }
        Err(e) => Err(error_problem(&format!("set-parent {child} failed: {e}"))),
    }
}

/// `POST /api/topology/set-parent-bulk` — move multiple agents in a single
/// request, producing **one** git commit. JSON body: `[{"child":"name",
/// "new_parent":"target-or-null"}, ...]`. Empty array is a no-op (200 OK).
/// First validation error aborts the whole batch.
pub(super) async fn post_set_parent_bulk(
    State(state): State<AppState>,
    axum::Json(body): axum::Json<Vec<SetParentBulkEntry>>,
) -> Response {
    if body.is_empty() {
        return (StatusCode::OK, "ok").into_response();
    }
    // Collect borrows for the coordinator call.
    let moves: Vec<(&str, Option<&str>)> = body
        .iter()
        .map(|e| {
            let child: &str = &e.child;
            let parent: Option<&str> = e.new_parent.as_deref().filter(|s| !s.is_empty());
            (child, parent)
        })
        .collect();
    match state.coord.reparent_bulk_with_notify(&moves).await {
        Ok(()) => {
            let names: Vec<&str> = body.iter().map(|e| e.child.as_str()).collect();
            tracing::info!(agents = ?names, "operator: set-parent-bulk via dashboard");
            (StatusCode::OK, "ok").into_response()
        }
        Err(e) => error_response(&format!("set-parent-bulk failed: {e}")),
    }
}