use std::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};

#[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; prints messages to stdout.
    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 = client::request(&cli.socket, AgentRequest::Send { to, body }).await?;
            render(&resp)?;
            check(&resp)
        }
        Cmd::Recv => {
            let resp = client::request(&cli.socket, AgentRequest::Recv).await?;
            render(&resp)?;
            check(&resp)
        }
    }
}

async fn serve(socket: &std::path::Path, interval: Duration) -> Result<()> {
    tracing::info!(socket = %socket.display(), "hive-ag3nt serve");
    loop {
        match client::request(socket, AgentRequest::Recv).await {
            Ok(AgentResponse::Message { from, body }) => {
                tracing::info!(%from, %body, "inbox");
            }
            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;
    }
}

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(())
}