use rand::distr::{Alphanumeric, SampleString};
use sqlx::{PgPool, Postgres, QueryBuilder};
use validator::Validate;

#[derive(Debug, Validate)]
pub struct Member {
    #[validate(length(equal = 7))]
    pub member_id: String,
    pub first_name: String,
    pub full_name: String,
    pub registration_token: Option<String>,
    pub diploma: Option<String>,
    pub hours: Vec<String>,
    pub groups: Vec<String>,
}

impl Member {
    pub async fn get_many(transaction: &PgPool, members: Vec<Self>) -> Result<(), sqlx::Error> {
        Ok(())
    }

    pub async fn get_all(pool: &PgPool) -> Result<Vec<Self>, sqlx::Error> {
        let members = sqlx::query_as!(Member, "SELECT * FROM members;",)
            .fetch_all(pool)
            .await?;

        Ok(members)
    }

    pub async fn insert_many(
        transaction: &mut sqlx::Transaction<'_, Postgres>,
        members: Vec<Self>,
    ) -> Result<(), sqlx::Error> {
        if members.len() == 0 {
            return Ok(());
        }

        let mut query_builder = QueryBuilder::new(
            "INSERT INTO members(member_id, first_name, full_name, registration_token, diploma, hours, groups) "
        );

        query_builder.push_values(members.into_iter(), |mut b, member| {
            let registration_token = Alphanumeric.sample_string(&mut rand::rng(), 16);

            b.push_bind(member.member_id);
            b.push_bind(member.first_name);
            b.push_bind(member.full_name);
            b.push_bind(registration_token);
            b.push_bind(member.diploma);
            b.push_bind(member.hours);
            b.push_bind(member.groups);
        });

        let query = query_builder.build();
        query.execute(&mut **transaction).await?;

        Ok(())
    }

    pub async fn update_many(
        transaction: &mut sqlx::Transaction<'_, Postgres>,
        members: Vec<Self>,
    ) -> Result<(), sqlx::Error> {
        if members.len() == 0 {
            return Ok(());
        }

        for member in members {
            sqlx::query!("UPDATE ONLY members SET first_name = $1, full_name = $2, diploma = $3, hours = $4, groups = $5 WHERE member_id = $6", member.first_name, member.full_name, member.diploma, &member.hours, &member.groups, member.member_id).execute(&mut **transaction).await?;
        }

        Ok(())
    }

    pub async fn remove_many(
        transaction: &mut sqlx::Transaction<'_, Postgres>,
        member_ids: &Vec<String>,
    ) -> Result<(), sqlx::Error> {
        sqlx::query!(
            "
                DELETE FROM members WHERE member_id = ANY($1)
            ",
            member_ids
        )
        .execute(&mut **transaction)
        .await?;

        Ok(())
    }
}