use std::str::FromStr;

use giterated_api::{DaemonConnectionPool, GiteratedApiBuilder};
use giterated_daemon::model::{
    instance::Instance,
    repository::{Repository, RepositoryVisibility},
    user::User,
};
use jsonwebtoken::{decode, Algorithm, DecodingKey, TokenData, Validation};
use serde::{Deserialize, Serialize};
// use jwt::SignWithKey;

#[macro_use]
extern crate tracing;

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    tracing_subscriber::fmt::init();

    let pool = DaemonConnectionPool::connect(Instance::from_str("giterated.dev")?).unwrap();

    let mut api = GiteratedApiBuilder::from_local("giterated.dev")
        .unwrap()
        .private_key(include_str!("example_keys/giterated.key"))
        .public_key(include_str!("example_keys/giterated.key.pub"))
        .build()
        .await
        .unwrap();

    info!("Lets try to make an account!");

    let response = api
        .register(
            String::from("ambee"),
            None,
            String::from("lolthisisinthecommithistory"),
            &pool,
        )
        .await;

    info!("Registration response: {:?}", response);

    let token = api
        .authentication_token(
            String::from("foobar"),
            String::from("ambee"),
            String::from("password"),
            &pool,
        )
        .await
        .unwrap();

    println!("Token: {}", token);

    let public_key = api.public_key().await;

    println!("Server public key:\n{}", public_key);
    let verification_key = DecodingKey::from_rsa_pem(public_key.as_bytes()).unwrap();
    let data: TokenData<UserTokenMetadata> = decode(
        &token,
        &verification_key,
        &Validation::new(Algorithm::RS256),
    )
    .unwrap();

    println!("The token was valid! Data:\n{:#?}", data.claims);

    info!("Lets extend that token!");

    let new_token = api
        .extend_token(String::from("foobar"), token.clone(), &pool)
        .await
        .unwrap();
    info!("New Token Returned:\n{:?}", new_token);

    info!("Try to create a repository? uwu");

    let repository = api
        .create_repository(
            new_token.unwrap(),
            String::from("super-repository"),
            None,
            RepositoryVisibility::Public,
            String::from("master"),
            User::from_str("ambee:giterated.dev").unwrap(),
            &pool,
        )
        .await
        .unwrap();

    assert!(repository);

    info!("Lets view our repository!");

    let view = api
        .repository_info(
            &token,
            Repository::from_str("ambee:giterated.dev/super-repository@giterated.dev").unwrap(),
            &pool,
        )
        .await
        .unwrap();

    info!("Repository Info:\n{:#?}", view);

    Ok(())
}

#[derive(Debug, Serialize, Deserialize)]
struct UserTokenMetadata {
    user: User,
    generated_for: Instance,
    exp: u64,
}