use crate::{db_async_handler, Result};

#[derive(Debug, Copy, Clone, PartialEq, serde::Serialize, thiserror::Error)]
pub enum Error {
    #[error("Can't load account addresses")]
    AccountAddresses,
    #[error("Failed to save account address")]
    CreateAccountAddress,
}

#[derive(actix::Message)]
#[rtype(result = "Result<Vec<model::AccountAddress>>")]
pub struct AccountAddresses {
    pub account_id: model::AccountId,
}

db_async_handler!(
    AccountAddresses,
    account_addresses,
    Vec<model::AccountAddress>,
    inner_account_addresses
);

pub(crate) async fn account_addresses(
    msg: AccountAddresses,
    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
) -> Result<Vec<model::AccountAddress>> {
    sqlx::query_as(
        r#"
SELECT id, name, email, phone, street, city, country, zip, account_id, is_default
FROM account_addresses
WHERE account_id = $1
    "#,
    )
    .bind(msg.account_id)
    .fetch_all(pool)
    .await
    .map_err(|_| Error::AccountAddresses.into())
}

#[derive(actix::Message)]
#[rtype(result = "Result<model::AccountAddress>")]
pub struct FindAccountAddress {
    pub account_id: model::AccountId,
    pub address_id: model::AddressId,
}

db_async_handler!(
    FindAccountAddress,
    find_account_address,
    model::AccountAddress,
    inner_find_account_address
);

pub(crate) async fn find_account_address(
    msg: FindAccountAddress,
    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
) -> Result<model::AccountAddress> {
    sqlx::query_as(
        r#"
SELECT id, name, email, phone, street, city, country, zip, account_id, is_default
FROM account_addresses
WHERE account_id = $1 AND id = $2
    "#,
    )
    .bind(msg.account_id)
    .bind(msg.address_id)
    .fetch_one(pool)
    .await
    .map_err(|_| Error::AccountAddresses.into())
}

#[derive(actix::Message)]
#[rtype(result = "Result<model::AccountAddress>")]
pub struct DefaultAccountAddress {
    pub account_id: model::AccountId,
}

db_async_handler!(
    DefaultAccountAddress,
    default_account_address,
    model::AccountAddress,
    inner_default_account_address
);

pub(crate) async fn default_account_address(
    msg: DefaultAccountAddress,
    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
) -> Result<model::AccountAddress> {
    sqlx::query_as(
        r#"
SELECT id, name, email, phone, street, city, country, zip, account_id, is_default
FROM account_addresses
WHERE account_id = $1 AND is_default
    "#,
    )
    .bind(msg.account_id)
    .fetch_one(pool)
    .await
    .map_err(|_| Error::AccountAddresses.into())
}

#[derive(actix::Message)]
#[rtype(result = "Result<model::AccountAddress>")]
pub struct CreateAccountAddress {
    pub name: model::Name,
    pub email: model::Email,
    pub phone: model::Phone,
    pub street: model::Street,
    pub city: model::City,
    pub country: model::Country,
    pub zip: model::Zip,
    pub account_id: Option<model::AccountId>,
    pub is_default: bool,
}

db_async_handler!(
    CreateAccountAddress,
    create_address,
    model::AccountAddress,
    inner_create_address
);

pub(crate) async fn create_address(
    msg: CreateAccountAddress,
    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
) -> Result<model::AccountAddress> {
    if msg.is_default && msg.account_id.is_some() {
        if let Err(e) = sqlx::query(
            r#"
UPDATE account_addresses
SET is_default = FALSE
WHERE account_id = $1
        "#,
        )
        .bind(msg.account_id)
        .fetch_all(&mut *pool)
        .await
        {
            tracing::error!("{e}");
            dbg!(e);
        }
    }

    sqlx::query_as(
        r#"
INSERT INTO account_addresses ( name, email, phone, street, city, country, zip, account_id, is_default)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
RETURNING id, name, email, phone, street, city, country, zip, account_id, is_default
    "#,
    )
    .bind(msg.name)
    .bind(msg.email)
    .bind(msg.phone)
    .bind(msg.street)
    .bind(msg.city)
    .bind(msg.country)
    .bind(msg.zip)
    .bind(msg.account_id)
    .bind(msg.is_default)
    .fetch_one(pool)
    .await
    .map_err(|e| {
        tracing::error!("{e}");
        dbg!(e);
        Error::CreateAccountAddress.into()
    })
}

#[derive(actix::Message)]
#[rtype(result = "Result<model::AccountAddress>")]
pub struct UpdateAccountAddress {
    pub id: model::AddressId,
    pub name: model::Name,
    pub email: model::Email,
    pub phone: model::Phone,
    pub street: model::Street,
    pub city: model::City,
    pub country: model::Country,
    pub zip: model::Zip,
    pub account_id: model::AccountId,
    pub is_default: bool,
}

db_async_handler!(
    UpdateAccountAddress,
    update_account_address,
    model::AccountAddress,
    inner_update_account_address
);

pub(crate) async fn update_account_address(
    msg: UpdateAccountAddress,
    pool: &mut sqlx::Transaction<'_, sqlx::Postgres>,
) -> Result<model::AccountAddress> {
    sqlx::query_as(
        r#"
UPDATE account_addresses
SET name = $2, email = $3, street = $4, city = $5, country = $6, zip = $7, account_id = $8, is_default = $9, phone = $10
WHERE id = $1
RETURNING id, name, email, phone, street, city, country, zip, account_id, is_default
    "#,
    )
    .bind(msg.id)
    .bind(msg.name)
    .bind(msg.email)
    .bind(msg.street)
    .bind(msg.city)
    .bind(msg.country)
    .bind(msg.zip)
    .bind(msg.account_id)
    .bind(msg.is_default)
    .bind(msg.phone)
    .fetch_one(pool)
    .await
    .map_err(|_| Error::CreateAccountAddress.into())
}

#[cfg(test)]
mod test {
    use config::*;
    use fake::Fake;
    use model::*;

    use crate::*;

    pub struct NoOpts;

    impl UpdateConfig for NoOpts {}

    async fn test_create_account(pool: &mut sqlx::Transaction<'_, sqlx::Postgres>) -> FullAccount {
        let login: String = fake::faker::internet::en::Username().fake();
        let email: String = fake::faker::internet::en::FreeEmail().fake();
        let hash: String = fake::faker::internet::en::Password(10..20).fake();

        crate::create_account(
            CreateAccount {
                email: Email::new(email),
                login: Login::new(login),
                pass_hash: PassHash::new(hash),
                role: Role::Admin,
            },
            pool,
        )
        .await
        .unwrap()
    }

    #[actix::test]
    async fn full_check() {
        testx::db_t!(t);

        // account
        let account = test_create_account(&mut t).await;

        // address
        let mut address: AccountAddress = {
            let name: String = fake::faker::name::en::Name().fake();
            let email: String = fake::faker::internet::en::FreeEmail().fake();
            let phone: String = fake::faker::phone_number::en::PhoneNumber().fake();
            let street: String = fake::faker::address::en::StreetName().fake();
            let city: String = fake::faker::address::en::CityName().fake();
            let country: String = fake::faker::address::en::CountryName().fake();
            let zip: String = fake::faker::address::en::ZipCode().fake();
            let account_id = Some(account.id);
            let is_default: bool = true;

            let address = super::create_address(
                CreateAccountAddress {
                    name: Name::new(name.clone()),
                    email: Email::new(email.clone()),
                    phone: Phone::new(phone.clone()),
                    street: Street::new(street.clone()),
                    city: City::new(city.clone()),
                    country: Country::new(country.clone()),
                    zip: Zip::new(zip.clone()),
                    account_id: account_id.clone(),
                    is_default,
                },
                &mut t,
            )
            .await
            .unwrap();

            assert_eq!(
                address,
                AccountAddress {
                    id: address.id,
                    name: Name::new(name.clone()),
                    email: Email::new(email.clone()),
                    phone: Phone::new(phone.clone()),
                    street: Street::new(street.clone()),
                    city: City::new(city.clone()),
                    country: Country::new(country.clone()),
                    zip: Zip::new(zip.clone()),
                    account_id: account.id,
                    is_default,
                }
            );
            address
        };

        let found = super::find_account_address(
            FindAccountAddress {
                account_id: account.id,
                address_id: address.id,
            },
            &mut t,
        )
        .await
        .unwrap();

        assert_eq!(found, address);

        let changed = super::update_account_address(
            UpdateAccountAddress {
                id: address.id,
                name: address.name.clone(),
                email: address.email.clone(),
                phone: address.phone.clone(),
                street: address.street.clone(),
                city: address.city.clone(),
                country: address.country.clone(),
                zip: address.zip.clone(),
                account_id: address.account_id.clone(),
                is_default: true,
            },
            &mut t,
        )
        .await
        .unwrap();

        address.is_default = true;

        assert_eq!(changed, address);

        let default_address = super::default_account_address(
            DefaultAccountAddress {
                account_id: account.id,
            },
            &mut t,
        )
        .await
        .unwrap();

        testx::db_rollback!(t);
        assert_eq!(default_address, address);
    }
}