use super::foerdernd::FoerderndUser;
use super::regular::RegularUser;
use super::scheckbuch::ScheckbuchUser;
use super::unterstuetzend::UnterstuetzendUser;
use super::{ManageUserUser, User};
use crate::NonEmptyString;
use crate::model::activity::ActivityBuilder;
use crate::model::role::Role;
use crate::model::notification::Notification;
use chrono::NaiveDate;
use rocket::fs::TempFile;
use sqlx::SqlitePool;
use std::fmt::Display;
use std::ops::Deref;

pub(crate) struct NoMembershipUser {
    pub(crate) user: User,
}

impl Deref for NoMembershipUser {
    type Target = User;
    fn deref(&self) -> &Self::Target {
        &self.user
    }
}

impl Display for NoMembershipUser {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.user.name)
    }
}

impl NoMembershipUser {
    pub(crate) async fn new(db: &SqlitePool, user: &User) -> Option<Self> {
        if ScheckbuchUser::new(db, user).await.is_some() {
            return None;
        }
        if user.has_role(db, "schnupper-interessierte").await {
            return None;
        }
        if user.has_role(db, "schnupperant").await {
            return None;
        }
        if user.has_role(db, "Donau Linz").await {
            return None;
        }
        if user.has_role(db, "Förderndes Mitglied").await {
            return None;
        }
        if user.has_role(db, "Unterstützend").await {
            return None;
        }
        Some(Self { user: user.clone() })
    }

    async fn set_data_for_clubmember(
        &self,
        db: &SqlitePool,
        changed_by: &ManageUserUser,
        member_since: &NaiveDate,
        birthdate: &NaiveDate,
        phone: NonEmptyString,
        address: NonEmptyString,
        membership_pdf: &TempFile<'_>,
    ) -> Result<(), String> {
        self.user.update_birthdate(db, changed_by, birthdate).await;
        self.user
            .update_member_since(db, changed_by, member_since)
            .await;
        self.user.update_phone(db, changed_by, &phone).await;
        self.user.update_address(db, changed_by, &address).await;
        self.user
            .add_membership_pdf(db, changed_by, membership_pdf)
            .await?;
        Ok(())
    }

    pub(crate) async fn convert_to_regular_user(
        self,
        db: &SqlitePool,
        smtp_pw: &str,
        changed_by: &ManageUserUser,
        member_since: &NaiveDate,
        birthdate: &NaiveDate,
        phone: NonEmptyString,
        address: NonEmptyString,
        membership_pdf: &TempFile<'_>,
    ) -> Result<(), String> {
        self.set_data_for_clubmember(
            db,
            changed_by,
            member_since,
            birthdate,
            phone,
            address,
            membership_pdf,
        )
        .await?;

        let regular = Role::find_by_name(db, "Donau Linz").await.unwrap();
        self.user.add_role(db, changed_by, &regular).await?;

        let regular = RegularUser::new(db, &self.user).await.unwrap();
        regular.send_welcome_mail_to_user(db, smtp_pw).await?;
        Notification::create_for_steering_people(
            db,
            &format!(
                "Liebe Steuerberechtigte, {} hatte keinen Mitgliedsstatus und ist nun seit {} ein neues reguläres Mitglied. 🎉",
                self.name,
                member_since
            ),
            "Neues Vereinsmitglied",
            None,
            None,
        )
        .await;

        ActivityBuilder::new(&format!(
            "{changed_by} hat den User ohne Mitgliedsstatus {self} auf ein reguläres Mitglied upgegraded! Die Steuerpersonen wurden via Notification informiert."
        ))
        .user(&self)
        .save(db)
        .await;

        Ok(())
    }

    pub(crate) async fn convert_to_unterstuetzend_user(
        self,
        db: &SqlitePool,
        smtp_pw: &str,
        changed_by: &ManageUserUser,
        member_since: &NaiveDate,
        birthdate: &NaiveDate,
        phone: NonEmptyString,
        address: NonEmptyString,
        membership_pdf: &TempFile<'_>,
    ) -> Result<(), String> {
        self.set_data_for_clubmember(
            db,
            changed_by,
            member_since,
            birthdate,
            phone,
            address,
            membership_pdf,
        )
        .await?;

        let unterstuetzend = Role::find_by_name(db, "Unterstützend").await.unwrap();
        self.user.add_role(db, changed_by, &unterstuetzend).await?;

        let unterstuetzend = UnterstuetzendUser::new(db, &self.user).await.unwrap();
        unterstuetzend
            .send_welcome_mail_to_user(db, smtp_pw)
            .await?;
        if let Some(vorstand) = Role::find_by_name(db, "vorstand").await {
            Notification::create_for_role(
                db,
                &vorstand,
                &format!(
                    "Lieber Vorstand, {} hatte keinen Mitgliedsstatus und ist nun seit {} ein neues unterstützendes Mitglied.",
                    self.name,
                    member_since
                ),
                "Neues unterstützendes Vereinsmitglied",
                None,
                None,
            )
            .await;
        }
        ActivityBuilder::new(&format!(
            "{changed_by} hat den User ohne Mitgliedsstatus {self} auf ein unterstützendes Mitglied upgegraded!"
        ))
        .user(&self)
        .save(db)
        .await;

        Ok(())
    }

    pub(crate) async fn convert_to_foerdernd_user(
        self,
        db: &SqlitePool,
        smtp_pw: &str,
        changed_by: &ManageUserUser,
        member_since: &NaiveDate,
        birthdate: &NaiveDate,
        phone: NonEmptyString,
        address: NonEmptyString,
        membership_pdf: &TempFile<'_>,
    ) -> Result<(), String> {
        self.set_data_for_clubmember(
            db,
            changed_by,
            member_since,
            birthdate,
            phone,
            address,
            membership_pdf,
        )
        .await?;

        let foerdernd = Role::find_by_name(db, "Förderndes Mitglied").await.unwrap();
        self.user.add_role(db, changed_by, &foerdernd).await?;

        let foerdernd = FoerderndUser::new(db, &self.user).await.unwrap();
        foerdernd.send_welcome_mail_to_user(db, smtp_pw).await?;
        if let Some(vorstand) = Role::find_by_name(db, "vorstand").await {
            Notification::create_for_role(
                db,
                &vorstand,
                &format!(
                    "Lieber Vorstand, {} hatte keinen Mitgliedsstatus und ist nun seit {} ein neues förderndes Mitglied.",
                    self.name,
                    member_since
                ),
                "Neues förderndes Vereinsmitglied",
                None,
                None,
            )
            .await;
        }
        ActivityBuilder::new(&format!(
            "{changed_by} hat den User ohne Mitgliedsstatus {self} auf ein förderndes Mitglied upgegraded!"
        ))
        .user(&self)
        .save(db)
        .await;

        Ok(())
    }
}