use clap::Parser;
use rhailib_engine::create_heromodels_engine;
use rhailib_worker::spawn_rhai_worker;
use tokio::sync::mpsc;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    /// Worker ID for identification
    #[arg(short, long)]
    worker_id: String,

    /// Redis URL
    #[arg(short, long, default_value = "redis://localhost:6379")]
    redis_url: String,

    /// Preserve task details after completion (for benchmarking)
    #[arg(long, default_value = "false")]
    preserve_tasks: bool,

    /// Root directory for engine database
    #[arg(long, default_value = "worker_rhai_temp_db")]
    db_path: String,

    /// Disable timestamps in log output
    #[arg(long, help = "Remove timestamps from log output")]
    no_timestamp: bool,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let args = Args::parse();

    // Configure env_logger with or without timestamps
    if args.no_timestamp {
        env_logger::Builder::from_default_env()
            .format_timestamp(None)
            .init();
    } else {
        env_logger::init();
    }


    log::info!("Rhai Worker (binary) starting with performance-optimized engine.");
    log::info!(
        "Worker ID: {}, Redis: {}",
        args.worker_id,
        args.redis_url
    );

    let mut engine = create_heromodels_engine();

    // Performance optimizations for benchmarking
    engine.set_max_operations(0); // Unlimited operations for performance testing
    engine.set_max_expr_depths(0, 0); // Unlimited expression depth
    engine.set_max_string_size(0); // Unlimited string size
    engine.set_max_array_size(0); // Unlimited array size
    engine.set_max_map_size(0); // Unlimited map size

    // Enable full optimization for maximum performance
    engine.set_optimization_level(rhai::OptimizationLevel::Full);

    log::info!("Engine configured for maximum performance");

    // Create shutdown channel (for graceful shutdown, though not used in benchmarks)
    let (_shutdown_tx, shutdown_rx) = mpsc::channel::<()>(1);

    // Spawn the worker
    let worker_handle = spawn_rhai_worker(
        args.worker_id,
        args.db_path,
        engine,
        args.redis_url,
        shutdown_rx,
        args.preserve_tasks,
    );

    // Wait for the worker to complete
    match worker_handle.await {
        Ok(result) => match result {
            Ok(_) => {
                log::info!("Worker completed successfully");
                Ok(())
            }
            Err(e) => {
                log::error!("Worker failed: {}", e);
                Err(e)
            }
        },
        Err(e) => {
            log::error!("Worker task panicked: {}", e);
            Err(Box::new(e) as Box<dyn std::error::Error + Send + Sync>)
        }
    }
}