use std::net::SocketAddr;
use axum::{
    middleware, routing::{get, get_service}, Extension, Router
};
use secret_gift_exchange::{giftexchange, giftexchanges};
use sqlx::{sqlite::SqlitePoolOptions, SqlitePool};
use sqlx::migrate::Migrator;
use tower_http::services::ServeDir;

mod error_handling;
mod google_oauth;
mod middlewares;
mod routes;
mod user;
mod wishlist;
mod email;
mod secret_gift_exchange;

use error_handling::AppError;
use middlewares::inject_user_data;
use google_oauth::{login, logout, google_auth_return};
use routes::{about, contact, cottagecalendar, dashboard, index, profile, user_profile, useradmin};
use user::{add_user_role, delete_user_role, UserData};
use wishlist::{user_wishlist, user_wishlist_add, user_wishlist_add_item, user_wishlist_bought_item, user_wishlist_received_item, wishlists};
//use email::send_emails;

#[derive(Clone)]
pub struct AppState {
    pub db_pool: SqlitePool
}

#[tokio::main]
async fn main() {
    // initialize tracing
    tracing_subscriber::fmt::init();

    let db_pool = SqlitePoolOptions::new()
        .max_connections(5)
        .connect("sqlite://db/db.sqlite3")
        .await;
    
    let app_state = AppState {db_pool:db_pool.expect("Failed to get db_pool")};

    static MIGRATOR: Migrator = sqlx::migrate!();

    MIGRATOR
        .run(&app_state.db_pool)
        .await
        .expect("Failed to run migrations");

    let user_data: Option<UserData> = None;

    // build our application with some routes
    let app = Router::new()
        .route("/dashboard", get(dashboard))
        .route("/cottagecalendar", get(cottagecalendar))
        .route("/profile", get(profile))
        .route("/useradmin", get(useradmin))
        .route("/users/:user_id", get(user_profile))
        .route("/roles/:user_id/:role_id/add", get(add_user_role))
        .route("/roles/:user_id/:user_role_id/delete", get(delete_user_role))
        .route("/wishlists", get(wishlists))
        .route("/userwishlist/:user_id", get(user_wishlist))
        .route("/userwishlist/add/:user_id", get(user_wishlist_add).post(user_wishlist_add_item))
        .route("/userwishlist/bought/:user_id", get(user_wishlist_bought_item))
        .route("/userwishlist/received/:user_id", get(user_wishlist_received_item))
        .route("/giftexchanges", get(giftexchanges))
        .route("/giftexchange/:giftexchange_id", get(giftexchange))
        .nest_service("/assets", ServeDir::new("templates/assets")
            .fallback(get_service(ServeDir::new("templates/assets"))))
        .route("/", get(index))
        .route("/about", get(about))
        .route("/contactus", get(contact))
        .route("/login", get(login))
        .route("/logout", get(logout))
        .route("/google_auth_return", get(google_auth_return))
        .route_layer(middleware::from_fn_with_state(app_state.db_pool.clone(), inject_user_data))
        .with_state(app_state.db_pool.clone())
        .layer(Extension(user_data))
        ;

    // Send email indicating server has started
    //let recipients = get_useremails_by_role("admin".to_string(), &app_state.db_pool).await;
    //send_emails("Server started".to_string(), recipients, "Server has been started".to_string());

    // run it
    let addr = SocketAddr::from(([0, 0, 0, 0], 40192));
    tracing::debug!("listening on {}", addr);
    axum_server::bind(addr)
        .serve(app.into_make_service())
        .await
        .unwrap();

}