use clap::{Parser, Subcommand};
// use ed25519_dalek::{Signature, SigningKey};

use cll2v0::{
    // db,
    config,
    // keys::{self}
};

/// cll2v0 is a playground for rust libraries.
/// This is signing service.
#[derive(Parser)]
#[command(arg_required_else_help(true), version, about)]
struct Args {
    #[command(subcommand)]
    cmd: Option<Command>,
}

#[derive(Subcommand)]
enum Command {
    /// Generate a default config
    GenConfig, // /// Add new ephemeral key to an existing persistent key
               // Add {
               //     ephemeral_key: String,
               //     persistent_key: String,
               //     expires_at: i64,
               // },
               // /// Revoke an existing ephemeral key
               // Revoke { ephemeral_key: String },
               // /// Check persistent keys are available and display
               // Check,
               // /// Gen from seed some sensible ephemeral key args to be used with `add`
               // Gen { seed: u8 },
               // /// Sign a message
               // Sign {
               //     signing_key: String,
               //     message: String,
               // },
               // /// Verify a message
               // Verify {
               //     verifying_key: String,
               //     message: String,
               //     signature: String,
               // },
}

#[tokio::main(flavor = "current_thread")]
async fn main() -> anyhow::Result<()> {
    let args = Args::parse();

    // let (_, pool) = db::start_db().await?;

    match args.cmd {
        Some(Command::GenConfig) => {
            let c = config::Config::default().to_string()?;
            println!("{}", c);
        }
        // Some(Command::Add {
        //     ephemeral_key,
        //     persistent_key,
        //     expires_at,
        // }) => {
        //     println!("Adding new ephemeral key '{ephemeral_key}'");
        //     let e = keys::from_hex(&ephemeral_key).expect("cannot parse key");
        //     let p = keys::from_hex(&persistent_key).expect("cannot parse key");
        //     let res = db::add_ephemeral_key(&pool, &e, &p, expires_at).await?;
        //     println!("Added new ekey: {}", res);
        // }
        // Some(Command::Revoke { ephemeral_key }) => {
        //     let e = keys::from_hex(&ephemeral_key).expect("cannot parse key");
        //     let res = db::revoke_ephemeral_key(&pool, &e).await?;
        //     println!("Revoked key: {}", res);
        // }
        // Some(Command::Check) => {
        //     eprintln!("!Check skipped");
        //     let res = db::list_persistent_keys(&pool).await?;
        //     println!("Persistent keys:");
        //     res.into_iter()
        //         .for_each(|key| println!("{}", keys::to_hex(&key)));
        //     let res = db::list_ephemeral_keys(&pool).await?;
        //     println!("ephemeral keys:");
        //     res.into_iter()
        //         .for_each(|(e, p, t)| println!("{} {} {t}", keys::to_hex(&e), keys::to_hex(&p)))
        // }
        // Some(Command::Gen { seed }) => {
        //     let ekey = SigningKey::from_bytes(&[
        //         seed, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        //         0, 0, 0, 0, 0,
        //     ]);
        //     println!("Ephemeral signing key:");
        //     println!("{}", keys::signing_key_to_hex(&ekey));
        //     let res = db::list_persistent_keys(&pool).await?;
        //     let idx = (seed as usize) % res.len();
        //     let pkey = res.get(idx);
        //     match pkey {
        //         None => eprintln!("No persistent keys found"),
        //         Some(pkey) => {
        //             let now: usize = std::time::SystemTime::now()
        //                 .duration_since(std::time::UNIX_EPOCH)
        //                 .unwrap()
        //                 .as_millis()
        //                 .try_into()
        //                 .unwrap();
        //             let twenty_mins_from_now = 20usize * 60 * 1000 + now;
        //             println!("Args");
        //             println!(
        //                 "{} {} {}",
        //                 keys::to_hex(&ekey.verifying_key()),
        //                 keys::to_hex(pkey),
        //                 twenty_mins_from_now
        //             )
        //         }
        //     }
        // }
        // Some(Command::Sign {
        //     signing_key,
        //     message,
        // }) => {
        //     let mut skey = keys::signing_key_from_hex(&signing_key).unwrap();
        //     let msg = hex::decode(message).unwrap();
        //     let sig = keys::sign(&mut skey, msg);
        //     println!("{}", hex::encode(sig.to_bytes()))
        // }
        // Some(Command::Verify {
        //     verifying_key,
        //     message,
        //     signature,
        // }) => {
        //     let vkey = keys::from_hex(&verifying_key).unwrap();
        //     let msg = hex::decode(message).unwrap();
        //     let sig = Signature::from_bytes(
        //         &TryInto::<[u8; 64]>::try_into(hex::decode(signature).unwrap()).unwrap(),
        //     );
        //     let res = keys::verify(&vkey, &msg, &sig).unwrap();
        //     println!("{:?}", res);
        // }
        None => {
            println!("See help");
        }
    }

    Ok(())
}