// #![allow(unused_imports)]

use tokio::net::TcpListener;

use herodb::server;

use clap::Parser;

/// Simple program to greet a person
#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Args {
    /// The directory of Redis DB file
    #[arg(long)]
    dir: String,

    /// The port of the Redis server, default is 6379 if not specified
    #[arg(long)]
    port: Option<u16>,

    /// Enable debug mode
    #[arg(long)]
    debug: bool,


    /// Master encryption key for encrypted databases
    #[arg(long)]
    encryption_key: Option<String>,

    /// Encrypt the database
    #[arg(long)]
    encrypt: bool,

    /// Use the sled backend
    #[arg(long)]
    sled: bool,
}

#[tokio::main]
async fn main() {
    // parse args
    let args = Args::parse();

    // bind port
    let port = args.port.unwrap_or(6379);
    println!("will listen on port: {}", port);
    let listener = TcpListener::bind(format!("127.0.0.1:{}", port))
        .await
        .unwrap();

    // new DB option
    let option = herodb::options::DBOption {
        dir: args.dir,
        port,
        debug: args.debug,
        encryption_key: args.encryption_key,
        encrypt: args.encrypt,
        backend: if args.sled {
            herodb::options::BackendType::Sled
        } else {
            herodb::options::BackendType::Redb
        },
    };

    // new server
    let server = server::Server::new(option).await;

    // Add a small delay to ensure the port is ready
    tokio::time::sleep(std::time::Duration::from_millis(100)).await;

    // accept new connections
    loop {
        let stream = listener.accept().await;
        match stream {
            Ok((stream, _)) => {
                println!("accepted new connection");

                let mut sc = server.clone();
                tokio::spawn(async move {
                    if let Err(e) = sc.handle(stream).await {
                        println!("error: {:?}, will close the connection. Bye", e);
                    }
                });
            }
            Err(e) => {
                println!("error: {}", e);
            }
        }
    }
}