use std::env;
use axum::{
    // http::StatusCode,
    // routing::{get, post},
    // Json,
    Router,
};
use axum::http::Method;
// use pbkdf2::password_hash::Error;
// use serde::{Deserialize, Serialize};
use tower::ServiceBuilder;
use tower_http::cors::{Any, CorsLayer};
use tower_http::trace::TraceLayer;
use tracing::info;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use crate::util::pass::get_pbkdf2_from_psw;

// Project modules
mod ledger;
mod middleware;
mod model;
mod util;
mod user;

// Passed App State
#[derive(Clone)]
pub struct AppState {
    db: deadpool_diesel::postgres::Pool,
}

#[tokio::main]
async fn main() {
    dotenvy::dotenv().unwrap();
    tracing_subscriber::registry()
        .with(tracing_subscriber::fmt::layer())
        .init();

    let args: Vec<String> = env::args().collect();

    if args.len() <= 1 {
        return;
    }
    // initialize db connection
    let db_url = std::env::var("DATABASE_URL").unwrap();

    let manager = deadpool_diesel::postgres::Manager::new(db_url, deadpool_diesel::Runtime::Tokio1);
    let pool = deadpool_diesel::postgres::Pool::builder(manager)
        .build()
        .unwrap();

    let shared_state = AppState { db: pool };
    let cmd = args[1].clone();

    match cmd.as_str() {
        "add_user" => {
            println!("adding user");
            if args.len() <= 4 {
                println!("insufficient arg number");
                return;
            }
            let user = args[2].clone();
            let psw = args[3].clone();
            let mail = args[4].clone();
            println!("adding user {}", user);
            let hashed = get_pbkdf2_from_psw(psw);
            let mut hash_psw = "".to_string();
            match hashed {
                Ok(val) => {
                    println!("get hash {}", val);
                    hash_psw=val;
                }
                Err(_) => {}
            }
            let res = user::dal::add_user(shared_state, user, hash_psw, mail)
                .await;
            return;
        }
        _ => {
            println!("unknown command {}", cmd);
        }
    }


    // Register routers
    let cors_layer = CorsLayer::new()
        .allow_methods([Method::GET, Method::POST])
        .allow_origin(Any);
    let global_layer = ServiceBuilder::new()
                                   .layer(TraceLayer::new_for_http())
                                   .layer(cors_layer);

    let app = Router::new()
        // V1 apis
        .nest("/api/v1/category", ledger::category::get_nest_handlers())
        .nest("/api/v1/tag", ledger::tag::get_nest_handlers())
        .nest("/api/v1/book", ledger::book::get_nest_handlers())
        .nest("/api/v1/account", ledger::account::get_nest_handlers())
        .nest("/api/v1/transaction", ledger::transaction::get_nest_handlers())
        .nest("/api/v1/user", user::handler::get_nest_handlers())
        .nest("/api/v1/operation", ledger::operation::get_nest_handlers())
        .with_state(shared_state)
        .layer(global_layer);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:8987").await.unwrap();
    info!("starting server on 0.0.0.0:8987");
    axum::serve(listener, app).await.unwrap();
}