use std::path::{Path, PathBuf};
use std::time::Duration;

use anyhow::{Result, bail};
use clap::{Parser, Subcommand};
use hive_ag3nt::{DEFAULT_SOCKET, client};
use hive_sh4re::{AgentRequest, AgentResponse};
use tokio::process::Command;

#[derive(Parser)]
#[command(name = "hive-ag3nt", about = "hyperhive sub-agent harness")]
struct Cli {
    /// Path to the per-agent MCP socket (bind-mounted from the host).
    #[arg(long, global = true, default_value = DEFAULT_SOCKET)]
    socket: PathBuf,

    #[command(subcommand)]
    cmd: Cmd,
}

#[derive(Subcommand)]
enum Cmd {
    /// Run the long-lived harness loop. Polls inbox; replies via `claude --print`
    /// when available, falling back to a simple echo otherwise.
    Serve {
        /// Inbox poll interval in milliseconds.
        #[arg(long, default_value_t = 1000)]
        poll_ms: u64,
    },
    /// Send a message to another agent.
    Send { to: String, body: String },
    /// Pop one message from the inbox.
    Recv,
}

#[tokio::main]
async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
        )
        .init();

    let cli = Cli::parse();
    match cli.cmd {
        Cmd::Serve { poll_ms } => serve(&cli.socket, Duration::from_millis(poll_ms)).await,
        Cmd::Send { to, body } => {
            let resp: AgentResponse =
                client::request(&cli.socket, &AgentRequest::Send { to, body }).await?;
            render(&resp)?;
            check(&resp)
        }
        Cmd::Recv => {
            let resp: AgentResponse = client::request(&cli.socket, &AgentRequest::Recv).await?;
            render(&resp)?;
            check(&resp)
        }
    }
}

async fn serve(socket: &Path, interval: Duration) -> Result<()> {
    tracing::info!(socket = %socket.display(), "hive-ag3nt serve");
    loop {
        let recv: Result<AgentResponse> = client::request(socket, &AgentRequest::Recv).await;
        match recv {
            Ok(AgentResponse::Message { from, body }) => {
                tracing::info!(%from, %body, "inbox");
                // Don't auto-reply to echoes — prevents infinite ping-pong when
                // both ends are falling back to echo. Real loop control is the
                // manager's job (Phase 4+).
                if !body.starts_with("echo: ") {
                    let reply = compute_reply(&body).await;
                    let send: Result<AgentResponse> = client::request(
                        socket,
                        &AgentRequest::Send {
                            to: from,
                            body: reply,
                        },
                    )
                    .await;
                    if let Err(e) = send {
                        tracing::warn!(error = ?e, "send reply failed");
                    }
                }
            }
            Ok(AgentResponse::Empty) => {}
            Ok(AgentResponse::Ok) => {
                tracing::warn!("recv produced Ok (unexpected)");
            }
            Ok(AgentResponse::Err { message }) => {
                tracing::warn!(%message, "recv error");
            }
            Err(e) => {
                tracing::warn!(error = ?e, "recv failed; retrying");
            }
        }
        tokio::time::sleep(interval).await;
    }
}

async fn compute_reply(prompt: &str) -> String {
    match invoke_claude(prompt).await {
        Ok(s) => s,
        Err(e) => {
            tracing::warn!(error = %format!("{e:#}"), "claude failed; falling back to echo");
            format!("echo: {prompt}")
        }
    }
}

async fn invoke_claude(prompt: &str) -> Result<String> {
    let out = Command::new("claude")
        .arg("--print")
        .arg(prompt)
        .output()
        .await?;
    if !out.status.success() {
        bail!(
            "claude exited {}: {}",
            out.status,
            String::from_utf8_lossy(&out.stderr).trim()
        );
    }
    let text = String::from_utf8_lossy(&out.stdout).trim().to_owned();
    if text.is_empty() {
        bail!("claude produced empty output");
    }
    Ok(text)
}

fn render(resp: &AgentResponse) -> Result<()> {
    println!("{}", serde_json::to_string_pretty(resp)?);
    Ok(())
}

fn check(resp: &AgentResponse) -> Result<()> {
    if let AgentResponse::Err { message } = resp {
        bail!("{message}");
    }
    Ok(())
}