use anyhow::Result;
use clap::{Parser, Subcommand};
use hero_openrpc_server::{OpenRpcServer, OpenRpcServerConfig, Transport};
use std::net::SocketAddr;
use std::path::PathBuf;
use tracing::{info, Level};
use tracing_subscriber;

#[derive(Parser)]
#[command(name = "hero-openrpc-server")]
#[command(about = "Hero OpenRPC Server - WebSocket and Unix socket JSON-RPC server")]
struct Cli {
    #[command(subcommand)]
    command: Commands,

    /// Path to supervisor configuration file
    #[arg(long)]
    supervisor_config: Option<PathBuf>,

    /// Database path for supervisor
    #[arg(long, default_value = "./supervisor.db")]
    db_path: PathBuf,

    /// Log level
    #[arg(long, default_value = "info")]
    log_level: String,
}

#[derive(Subcommand)]
enum Commands {
    /// Start WebSocket server
    Websocket {
        /// Address to bind to
        #[arg(long, default_value = "127.0.0.1:9944")]
        addr: SocketAddr,
    },
    /// Start Unix socket server
    Unix {
        /// Unix socket path
        #[arg(long, default_value = "/tmp/hero-openrpc.sock")]
        socket_path: PathBuf,
    },
}

#[tokio::main]
async fn main() -> Result<()> {
    let cli = Cli::parse();

    // Initialize tracing
    let log_level = match cli.log_level.to_lowercase().as_str() {
        "trace" => Level::TRACE,
        "debug" => Level::DEBUG,
        "info" => Level::INFO,
        "warn" => Level::WARN,
        "error" => Level::ERROR,
        _ => Level::INFO,
    };

    tracing_subscriber::fmt()
        .with_max_level(log_level)
        .init();

    let transport = match cli.command {
        Commands::Websocket { addr } => {
            info!("Starting WebSocket server on {}", addr);
            Transport::WebSocket(addr)
        }
        Commands::Unix { socket_path } => {
            info!("Starting Unix socket server on {:?}", socket_path);
            // Remove existing socket file if it exists
            if socket_path.exists() {
                std::fs::remove_file(&socket_path)?;
            }
            Transport::Unix(socket_path)
        }
    };

    let config = OpenRpcServerConfig {
        transport: transport.clone(),
        supervisor_config_path: cli.supervisor_config,
        db_path: cli.db_path,
    };

    // Create and start the server
    let server = OpenRpcServer::new(config.clone()).await?;
    let handle = server.start(config).await?;

    info!("Server started successfully");

    // Wait for the server to finish
    handle.stopped().await;

    info!("Server stopped");
    Ok(())
}