use std::collections::HashMap;

use crate::{
    model::{
        family::Family,
        log::Log,
        logbook::Logbook,
        role::Role,
        user::{
            AdminUser, AllowedToEditPaymentStatusUser, ManageUserUser, SchnupperBetreuerUser, User,
            UserWithDetails, UserWithMembershipPdf, UserWithRolesAndMembershipPdf, VorstandUser,
        },
    },
    tera::Config,
};
use futures::future::join_all;
use lettre::Address;
use rocket::{
    form::Form,
    fs::TempFile,
    get,
    http::{ContentType, Status},
    post,
    request::{FlashMessage, FromRequest, Outcome},
    response::{Flash, Redirect},
    routes, FromForm, Request, Route, State,
};
use rocket_dyn_templates::{tera::Context, Template};
use sqlx::SqlitePool;

// Custom request guard to extract the Referer header
struct Referer(String);

#[rocket::async_trait]
impl<'r> FromRequest<'r> for Referer {
    type Error = ();

    async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::Error> {
        match request.headers().get_one("Referer") {
            Some(referer) => Outcome::Success(Referer(referer.to_string())),
            None => Outcome::Error((Status::BadRequest, ())),
        }
    }
}

#[get("/user")]
async fn index(
    db: &State<SqlitePool>,
    user: VorstandUser,
    flash: Option<FlashMessage<'_>>,
) -> Template {
    let user_futures: Vec<_> = User::all(db)
        .await
        .into_iter()
        .map(|u| async move { UserWithRolesAndMembershipPdf::from_user(db, u).await })
        .collect();

    let user: User = user.into_inner();
    let allowed_to_edit = ManageUserUser::new(db, user.clone()).await.is_some();

    let users: Vec<UserWithRolesAndMembershipPdf> = join_all(user_futures).await;

    let roles = Role::all(db).await;
    let families = Family::all_with_members(db).await;

    let mut context = Context::new();
    if let Some(msg) = flash {
        context.insert("flash", &msg.into_inner());
    }
    context.insert("allowed_to_edit", &allowed_to_edit);
    context.insert("users", &users);
    context.insert("roles", &roles);
    context.insert("families", &families);
    context.insert("loggedin_user", &UserWithDetails::from_user(user, db).await);

    Template::render("admin/user/index", context.into_json())
}

#[get("/user", rank = 2)]
async fn index_admin(
    db: &State<SqlitePool>,
    user: AdminUser,
    flash: Option<FlashMessage<'_>>,
) -> Template {
    let user_futures: Vec<_> = User::all(db)
        .await
        .into_iter()
        .map(|u| async move { UserWithRolesAndMembershipPdf::from_user(db, u).await })
        .collect();
    let users: Vec<UserWithRolesAndMembershipPdf> = join_all(user_futures).await;

    let user: User = user.user;
    let allowed_to_edit = ManageUserUser::new(db, user.clone()).await.is_some();

    let roles = Role::all(db).await;
    let families = Family::all_with_members(db).await;

    let mut context = Context::new();
    if let Some(msg) = flash {
        context.insert("flash", &msg.into_inner());
    }
    context.insert("allowed_to_edit", &allowed_to_edit);
    context.insert("users", &users);
    context.insert("roles", &roles);
    context.insert("families", &families);
    context.insert("loggedin_user", &UserWithDetails::from_user(user, db).await);

    Template::render("admin/user/index", context.into_json())
}

#[get("/user/fees")]
async fn fees(
    db: &State<SqlitePool>,
    user: VorstandUser,
    flash: Option<FlashMessage<'_>>,
) -> Template {
    let mut context = Context::new();

    let users = User::all_payer_groups(db).await;
    let mut fees = Vec::new();
    for user in users {
        if let Some(fee) = user.fee(db).await {
            fees.push(fee);
        }
    }

    context.insert("fees", &fees);

    if let Some(msg) = flash {
        context.insert("flash", &msg.into_inner());
    }
    context.insert(
        "loggedin_user",
        &UserWithDetails::from_user(user.into_inner(), db).await,
    );

    Template::render("admin/user/fees", context.into_json())
}

#[get("/user/scheckbuch")]
async fn scheckbuch(
    db: &State<SqlitePool>,
    user: VorstandUser,
    flash: Option<FlashMessage<'_>>,
) -> Template {
    let mut context = Context::new();

    let scheckbooks = Role::find_by_name(db, "scheckbuch").await.unwrap();
    let scheckbooks = User::all_with_role(db, &scheckbooks).await;
    let mut scheckbooks_with_roles = Vec::new();
    for s in scheckbooks {
        scheckbooks_with_roles.push((
            Logbook::completed_with_user(db, &s).await,
            UserWithDetails::from_user(s, db).await,
        ))
    }

    context.insert("scheckbooks", &scheckbooks_with_roles);

    if let Some(msg) = flash {
        context.insert("flash", &msg.into_inner());
    }
    context.insert(
        "loggedin_user",
        &UserWithDetails::from_user(user.into_inner(), db).await,
    );

    Template::render("admin/user/scheckbuch", context.into_json())
}

#[get("/user/fees/paid?<user_ids>")]
async fn fees_paid(
    db: &State<SqlitePool>,
    calling_user: AllowedToEditPaymentStatusUser,
    user_ids: Vec<i32>,
    referer: Referer,
) -> Flash<Redirect> {
    let mut res = String::new();
    for user_id in user_ids {
        let user = User::find_by_id(db, user_id).await.unwrap();
        res.push_str(&format!("{} + ", user.name));
        if user.has_role(db, "paid").await {
            Log::create(
                db,
                format!(
                    "{} set fees NOT paid for '{}'",
                    calling_user.user.name, user.name
                ),
            )
            .await;
            user.remove_role(db, &Role::find_by_name(db, "paid").await.unwrap())
                .await;
        } else {
            Log::create(
                db,
                format!(
                    "{} set fees paid for '{}'",
                    calling_user.user.name, user.name
                ),
            )
            .await;
            user.add_role(db, &Role::find_by_name(db, "paid").await.unwrap())
                .await
                .expect("paid role has no group");
        }
    }

    res.truncate(res.len() - 3); // remove ' + ' from the end

    Flash::success(
        Redirect::to(referer.0),
        format!("Zahlungsstatus von {} erfolgreich geändert", res),
    )
}

#[get("/user/<user>/send-welcome-mail")]
async fn send_welcome_mail(
    db: &State<SqlitePool>,
    _admin: ManageUserUser,
    config: &State<Config>,
    user: i32,
) -> Flash<Redirect> {
    let Some(user) = User::find_by_id(db, user).await else {
        return Flash::error(Redirect::to("/admin/user"), "User does not exist");
    };

    match user.send_welcome_email(db, &config.smtp_pw).await {
        Ok(()) => Flash::success(
            Redirect::to("/admin/user"),
            format!("Willkommens-Email wurde an {} versandt.", user.name),
        ),
        Err(e) => Flash::error(Redirect::to("/admin/user"), e),
    }
}

#[get("/user/<user>/reset-pw")]
async fn resetpw(db: &State<SqlitePool>, admin: ManageUserUser, user: i32) -> Flash<Redirect> {
    let user = User::find_by_id(db, user).await;
    match user {
        Some(user) => {
            Log::create(
                db,
                format!("{} has resetted the pw for {}", admin.user.name, user.name),
            )
            .await;
            user.reset_pw(db).await;
            Flash::success(
                Redirect::to("/admin/user"),
                format!("Passwort von {} zurückgesetzt", user.name),
            )
        }
        None => Flash::error(Redirect::to("/admin/user"), "User does not exist"),
    }
}

#[get("/user/<user>/delete")]
async fn delete(db: &State<SqlitePool>, admin: ManageUserUser, user: i32) -> Flash<Redirect> {
    let user = User::find_by_id(db, user).await;
    Log::create(db, format!("{} deleted user: {user:?}", admin.user.name)).await;
    match user {
        Some(user) => {
            user.delete(db).await;
            Flash::success(
                Redirect::to("/admin/user"),
                format!("Benutzer {} gelöscht", user.name),
            )
        }
        None => Flash::error(Redirect::to("/admin/user"), "User does not exist"),
    }
}

#[derive(FromForm, Debug)]
pub struct UserEditForm<'a> {
    pub(crate) id: i32,
    pub(crate) dob: Option<String>,
    pub(crate) weight: Option<String>,
    pub(crate) sex: Option<String>,
    pub(crate) roles: HashMap<String, String>,
    pub(crate) member_since_date: Option<String>,
    pub(crate) birthdate: Option<String>,
    pub(crate) mail: Option<String>,
    pub(crate) nickname: Option<String>,
    pub(crate) notes: Option<String>,
    pub(crate) phone: Option<String>,
    pub(crate) address: Option<String>,
    pub(crate) family_id: Option<i64>,
    pub(crate) membership_pdf: Option<TempFile<'a>>,
}

#[post("/user", data = "<data>", format = "multipart/form-data")]
async fn update(
    db: &State<SqlitePool>,
    data: Form<UserEditForm<'_>>,
    admin: ManageUserUser,
) -> Flash<Redirect> {
    let user = User::find_by_id(db, data.id).await;
    Log::create(
        db,
        format!("{} updated user from {user:?} to {data:?}", admin.user.name),
    )
    .await;
    let Some(user) = user else {
        return Flash::error(
            Redirect::to("/admin/user"),
            format!("User with ID {} does not exist!", data.id),
        );
    };

    match user.update(db, data.into_inner()).await {
        Ok(_) => Flash::success(Redirect::to("/admin/user"), "Successfully updated user"),
        Err(e) => Flash::error(Redirect::to("/admin/user"), e),
    }
}

#[get("/user/<user>/membership")]
async fn download_membership_pdf(
    db: &State<SqlitePool>,
    admin: ManageUserUser,
    user: i32,
) -> (ContentType, Vec<u8>) {
    let user = User::find_by_id(db, user).await.unwrap();
    let user = UserWithMembershipPdf::from(db, user).await;
    Log::create(
        db,
        format!(
            "{} downloaded membership application for user: {}",
            admin.user.name, user.user.name
        ),
    )
    .await;

    (ContentType::PDF, user.membership_pdf.unwrap())
}

#[derive(FromForm, Debug)]
struct UserAddForm<'r> {
    name: &'r str,
}

#[post("/user/new", data = "<data>")]
async fn create(
    db: &State<SqlitePool>,
    data: Form<UserAddForm<'_>>,
    admin: ManageUserUser,
) -> Flash<Redirect> {
    if User::create(db, data.name).await {
        Log::create(
            db,
            format!("{} created new user: {data:?}", admin.user.name),
        )
        .await;
        Flash::success(Redirect::to("/admin/user"), "Successfully created user")
    } else {
        Flash::error(
            Redirect::to("/admin/user"),
            format!("User {} already exists", data.name),
        )
    }
}

#[derive(FromForm, Debug)]
struct UserAddScheckbuchForm<'r> {
    name: &'r str,
    mail: &'r str,
}

#[post("/user/new/scheckbuch", data = "<data>")]
async fn create_scheckbuch(
    db: &State<SqlitePool>,
    data: Form<UserAddScheckbuchForm<'_>>,
    admin: VorstandUser,
    config: &State<Config>,
) -> Flash<Redirect> {
    // 1. Check mail adress
    let mail = data.mail.trim();
    if mail.parse::<Address>().is_err() {
        return Flash::error(
            Redirect::to("/admin/user/scheckbuch"),
            "Keine gültige Mailadresse".to_string(),
        );
    }

    // 2. Check name
    let name = data.name.trim();
    if User::find_by_name(db, name).await.is_some() {
        return Flash::error(
            Redirect::to("/admin/user/scheckbuch"),
            "Kann kein Scheckbuch erstellen, der Name wird bereits von einem User verwendet"
                .to_string(),
        );
    }

    // 3. Create user
    User::create_with_mail(db, name, mail).await;
    let user = User::find_by_name(db, name).await.unwrap();

    // 4. Add 'scheckbuch' role
    let scheckbuch = Role::find_by_name(db, "scheckbuch").await.unwrap();
    user.add_role(db, &scheckbuch)
        .await
        .expect("new user has no roles yet");

    // 4. Send welcome mail (+ notification)
    user.send_welcome_email(db, &config.smtp_pw).await.unwrap();

    Log::create(
        db,
        format!("{} created new scheckbuch: {data:?}", admin.name),
    )
    .await;
    Flash::success(Redirect::to("/admin/user/scheckbuch"), &format!("Scheckbuch erfolgreich erstellt. Eine E-Mail in der alles erklärt wird, wurde an {mail} verschickt."))
}

#[get("/user/move/schnupperant/<id>/to/scheckbuch")]
async fn schnupper_to_scheckbuch(
    db: &State<SqlitePool>,
    id: i32,
    admin: SchnupperBetreuerUser,
    config: &State<Config>,
) -> Flash<Redirect> {
    let Some(user) = User::find_by_id(db, id).await else {
        return Flash::error(
            Redirect::to("/admin/schnupper"),
            "user id not found".to_string(),
        );
    };

    if !user.has_role(db, "schnupperant").await {
        return Flash::error(
            Redirect::to("/admin/schnupper"),
            "kein schnupperant...".to_string(),
        );
    }

    let schnupperant = Role::find_by_name(db, "schnupperant").await.unwrap();
    let paid = Role::find_by_name(db, "paid").await.unwrap();
    user.remove_role(db, &schnupperant).await;
    user.remove_role(db, &paid).await;

    let scheckbuch = Role::find_by_name(db, "scheckbuch").await.unwrap();
    user.add_role(db, &scheckbuch)
        .await
        .expect("just removed 'schnupperant' thus can't have a role with that group");

    if let Some(no_einschreibgebuehr) = Role::find_by_name(db, "no-einschreibgebuehr").await {
        user.add_role(db, &no_einschreibgebuehr)
            .await
            .expect("role doesn't have a group");
    }

    user.send_welcome_email(db, &config.smtp_pw).await.unwrap();

    Log::create(
        db,
        format!(
            "{} created new scheckbuch (from schnupperant): {}",
            admin.name, user.name
        ),
    )
    .await;
    Flash::success(Redirect::to("/admin/schnupper"), &format!("Scheckbuch erfolgreich erstellt. Eine E-Mail in der alles erklärt wird, wurde an {} verschickt.", user.mail.unwrap()))
}

pub fn routes() -> Vec<Route> {
    routes![
        index,
        index_admin,
        resetpw,
        update,
        create,
        create_scheckbuch,
        schnupper_to_scheckbuch,
        delete,
        fees,
        fees_paid,
        scheckbuch,
        download_membership_pdf,
        send_welcome_mail
    ]
}