use std::collections::HashSet;

use scylla::{
    DeserializeValue, SerializeValue,
    client::session::Session,
    deserialize::row::DeserializeRow,
    errors::{
        DeserializationError, ExecutionError, FirstRowError, IntoRowsResultError, RowsError,
        SingleRowError,
    },
    response::query_result::QueryRowsResult,
    statement::{
        Statement,
        batch::{Batch, BatchType},
    },
};
use thiserror::Error;
use time::{Duration, OffsetDateTime, UtcDateTime, UtcOffset};
use tokio::sync::mpsc::Sender;
use twilight_http::Client;
use twilight_model::{
    channel::{Message as TwilightMessage, Webhook},
    guild::Guild as TwilightGuild,
    id::Id,
    user::User as TwilightUser,
};
use twilight_validate::request::{ValidationError, ValidationErrorType, webhook_username};

use crate::{
    colors::AvatarColorFetchingRequest,
    constants::DEFAULT_PREFIX,
    groups::calls::masks::{get_mask_avatar_url, get_mask_display_name, get_random_mask},
    utils::{Bye, get_random_u64, i64_to_u64, u64_to_i64},
};

#[derive(Debug, Error)]
pub enum DatabaseOrDiscordError {
    #[error("An error occurred when querying the database")]
    Database(#[from] DatabaseError),

    #[error("An error occurred when querying the Discord API")]
    Discord(#[from] twilight_http::Error),

    #[error("The Discord API returned a response that could not be deserialized")]
    DiscordDeserializationFailed,
}

#[derive(Debug, Error)]
pub enum DatabaseError {
    #[error("An error occurred when querying the database")]
    QueryError(#[from] ExecutionError),

    #[error("The database responded but the result of the query weren't rows")]
    ResultNotRows(#[from] IntoRowsResultError),

    #[error("The resulting row could not be deserialized into an object")]
    DeserializationFailed(#[from] DeserializationError),

    #[error("The database responded but the result of the query weren't rows")]
    RowsError(#[from] RowsError),

    #[error("The resulting row could not be deserialized into an object")]
    SingleRowFailed(#[from] SingleRowError),

    #[error("The database responded but the first row raised an error")]
    FirstRowError(#[from] FirstRowError),

    #[error("An unknown error occurred")]
    Unknown(&'static str),
}

trait Object<'a> {
    type Row: DeserializeRow<'a, 'a>;

    fn from_row(row: Self::Row) -> Self;
    fn to_row(value: Self) -> Self::Row;
}

/// Returns the first row of the result set, if any.
///
/// Arguments:
/// * `result` - The DB result.
///
/// Returns:
/// [`Result<Option<T>, DatabaseError>`] - The first row of the result set, if any.
async fn get_single_row_from_result<'a, T: Object<'a>>(
    result: &'a QueryRowsResult,
) -> Result<Option<T>, DatabaseError> {
    match result.single_row::<T::Row>() {
        Ok(row) => Ok(Some(T::from_row(row))),
        Err(error) => match error {
            SingleRowError::UnexpectedRowCount(_) => Ok(None),
            _ => Err(error.into()),
        },
    }
}

#[derive(Debug, Clone)]
pub struct User {
    pub id: u64,
    pub name: String,
    pub email: Option<String>,
    pub is_masked: bool,
    pub is_moderator: bool,
    pub joined_at: UtcDateTime,
    pub last_seen_at: UtcDateTime,
    pub supporter_since: Option<UtcDateTime>,
    pub supporter_until: Option<UtcDateTime>,
    pub is_banned_from_leaderboard: Option<bool>,
    pub findings: HashSet<String>,
    pub avatar_hash: Option<String>,
    pub color: Option<i32>,
}

impl<'a> Object<'a> for User {
    type Row = (
        i64,
        String,
        Option<String>,
        bool,
        bool,
        OffsetDateTime,
        OffsetDateTime,
        Option<OffsetDateTime>,
        Option<OffsetDateTime>,
        Option<bool>,
        HashSet<String>,
        Option<String>,
        Option<i32>,
        Option<bool>,
    );

    fn from_row(row: Self::Row) -> Self {
        Self {
            id: i64_to_u64(row.0),
            name: row.1,
            email: row.2,
            is_masked: row.3,
            is_moderator: row.4,
            joined_at: row.5.into(),
            last_seen_at: row.6.into(),
            supporter_since: row.7.map(|i| i.into()),
            supporter_until: row.8.map(|i| i.into()),
            is_banned_from_leaderboard: row.9,
            findings: row.10,
            avatar_hash: row.11,
            color: row.12,
        }
    }

    fn to_row(value: Self) -> Self::Row {
        (
            u64_to_i64(value.id),
            value.name,
            value.email,
            value.is_masked,
            value.is_moderator,
            value.joined_at.into(),
            value.last_seen_at.into(),
            value.supporter_since.map(|i| i.into()),
            value.supporter_until.map(|i| i.into()),
            Some(value.is_banned_from_leaderboard.unwrap_or(false)),
            value.findings,
            value.avatar_hash,
            value.color,
            Some(value.color.is_some()),
        )
    }
}

pub struct NewUserIncident {
    pub counting_incidents: usize,
    pub is_first_incident: bool,
}

impl User {
    pub async fn get_by_id(id: u64, session: &Session) -> Result<Option<Self>, DatabaseError> {
        let id = u64_to_i64(id);

        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        user_id,
                        name,
                        email,
                        is_masked,
                        is_moderator,
                        joined_at,
                        last_seen_at,
                        supporter_since,
                        supporter_until,
                        is_banned_from_leaderboard,
                        findings,
                        avatar_hash,
                        color,
                        is_color_set
                    FROM
                        payphone.users
                    WHERE
                        user_id = ?
                    LIMIT 1;
                "#,
                (id,),
            )
            .await?
            .into_rows_result()?;

        get_single_row_from_result(&result).await
    }

    pub async fn get_by_name(
        name: String,
        session: &Session,
    ) -> Result<Option<Self>, DatabaseError> {
        let Some(user_by_name) = UserByName::get(name, session).await? else {
            return Ok(None);
        };

        Self::get_by_id(user_by_name.user_id, session).await
    }

    /// Gets a user from the DB and sets their last seen timestamp or inserts a new user from Discord.
    ///
    /// It also updates the user's username.
    ///
    /// Arguments:
    /// * `user` - The Twilight user to get or create.
    /// * `session` - The Scylla session to use for database operations.
    ///
    /// Returns:
    /// [`Result<User, DatabaseError>`] - The user from the database or a new user created from
    /// Discord.
    pub async fn create_or_update(
        user: TwilightUser,
        session: &Session,
        sender: &Sender<AvatarColorFetchingRequest>,
    ) -> Result<Self, DatabaseError> {
        let db_user = User::get_by_id(user.id.get(), session).await?;

        if let Some(mut db_user) = db_user {
            db_user.last_seen_at = UtcDateTime::now();
            db_user.name = user.name;

            if user.avatar.map(|hash| hash.to_string()) != db_user.avatar_hash {
                db_user.avatar_hash = user.avatar.map(|hash| hash.to_string());
                db_user.color = None;

                if let Some(avatar_hash) = &db_user.avatar_hash {
                    sender
                        .send(AvatarColorFetchingRequest::new(avatar_hash, user.id.get()))
                        .await
                        .inspect_err(|e| {
                            log::error!(
                                "Failed to send avatar color fetching request to queue! {e}"
                            )
                        })
                        .bye();
                }
            }

            return Ok(db_user);
        }

        let new_user = User::from(user);

        if let Some(avatar_hash) = &new_user.avatar_hash {
            sender
                .send(AvatarColorFetchingRequest::new(avatar_hash, new_user.id))
                .await
                .inspect_err(|e| {
                    log::error!("Failed to send avatar color fetching request to queue! {e}")
                })
                .bye();
        }

        new_user.insert(session).await?;

        Ok(new_user)
    }

    pub async fn insert(&self, session: &Session) -> Result<(), DatabaseError> {
        session
            .query_unpaged(
                r#"
                    INSERT INTO payphone.users (
                        user_id,
                        name,
                        email,
                        is_masked,
                        is_moderator,
                        joined_at,
                        last_seen_at,
                        supporter_since,
                        supporter_until,
                        is_banned_from_leaderboard,
                        findings,
                        avatar_hash,
                        color,
                        is_color_set
                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
                "#,
                Self::to_row(self.clone()),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }

    pub async fn incident(
        &self,
        reason: String,
        message: Option<MessageData>,
        created_by_id: Option<u64>,
        session: &Session,
    ) -> Result<NewUserIncident, DatabaseError> {
        let incidents = UserIncident::get_for_user(self.id, session).await?;

        let counting_incidents = incidents
            .iter()
            .filter(|incident| incident.created_at + Duration::weeks(12) > UtcDateTime::now())
            .count();

        let incident_type = if counting_incidents != 0 {
            UserIncidentType::Ban
        } else {
            UserIncidentType::Warning
        };

        let duration = match counting_incidents {
            0 => None,                    // Warning
            1 => Some(Duration::days(1)), // First ban
            _ => None,                    // Permanent ban
        };

        let incident = UserIncident {
            user_id: self.id,
            incident_id: get_random_u64(),
            report_id: None,
            r#type: incident_type,
            created_at: UtcDateTime::now(),
            expires_at: duration.map(|d| UtcDateTime::now() + d),
            message,
            reason,
            created_by_id,
            duration: duration.map(|_| "1 day".into()),
        };
        incident.insert(session).await?;

        Ok(NewUserIncident {
            counting_incidents,
            is_first_incident: incidents.is_empty(),
        })
    }

    pub async fn count(session: &Session) -> Result<usize, DatabaseError> {
        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        user_id
                    FROM
                        payphone.users;
                "#,
                (),
            )
            .await?
            .into_rows_result()?;

        Ok(result.rows_num())
    }
}

impl From<TwilightUser> for User {
    fn from(value: TwilightUser) -> Self {
        Self {
            id: value.id.get(),
            name: value.name,
            email: value.email,
            is_masked: false,
            is_moderator: false,
            joined_at: UtcDateTime::now(),
            last_seen_at: UtcDateTime::now(),
            supporter_since: None,
            supporter_until: None,
            is_banned_from_leaderboard: None,
            findings: HashSet::new(),
            avatar_hash: value.avatar.map(|a| a.to_string()),
            color: None,
        }
    }
}

#[derive(Debug, Clone)]
struct UserByName {
    pub user_id: u64,
    pub name: String,
}

impl<'a> Object<'a> for UserByName {
    type Row = (i64, String);

    fn from_row(row: Self::Row) -> Self {
        Self {
            user_id: i64_to_u64(row.0),
            name: row.1,
        }
    }

    fn to_row(value: Self) -> Self::Row {
        (u64_to_i64(value.user_id), value.name)
    }
}

impl UserByName {
    async fn get(name: String, session: &Session) -> Result<Option<Self>, DatabaseError> {
        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        user_id,
                        name
                    FROM
                        payphone.users_by_name
                    WHERE
                        name = ?
                    LIMIT 1;
                "#,
                (name,),
            )
            .await?
            .into_rows_result()?;

        get_single_row_from_result(&result).await
    }
}

#[derive(Debug, Clone)]
pub struct Server {
    pub id: u64,
    pub name: String,
    pub prefix: String,
    pub language: String,
}

impl<'a> Object<'a> for Server {
    type Row = (i64, String, String, String);

    fn from_row(row: Self::Row) -> Self {
        Self {
            id: i64_to_u64(row.0),
            name: row.1,
            prefix: row.2,
            language: row.3,
        }
    }

    fn to_row(value: Self) -> Self::Row {
        (
            u64_to_i64(value.id),
            value.name,
            value.prefix,
            value.language,
        )
    }
}

impl Server {
    pub async fn get_by_id(id: u64, session: &Session) -> Result<Option<Self>, DatabaseError> {
        let id = u64_to_i64(id);

        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        server_id,
                        name,
                        prefix,
                        language
                    FROM
                        payphone.servers
                    WHERE
                        server_id = ?
                    LIMIT 1;
                "#,
                (id,),
            )
            .await?
            .into_rows_result()?;

        get_single_row_from_result(&result).await
    }

    pub async fn get_or_create_by_id(
        id: u64,
        session: &Session,
        http: &Client,
    ) -> Result<Self, DatabaseOrDiscordError> {
        let server = Server::get_by_id(id, session)
            .await
            .map_err(DatabaseOrDiscordError::Database)?;

        if let Some(server) = server {
            Ok(server)
        } else {
            let server: Server = http
                .guild(Id::new(id))
                .await
                .map_err(DatabaseOrDiscordError::Discord)?
                .model()
                .await
                .map_err(|_| DatabaseOrDiscordError::DiscordDeserializationFailed)?
                .into();

            server
                .insert(session)
                .await
                .map_err(DatabaseOrDiscordError::Database)?;

            Ok(server)
        }
    }

    pub async fn insert(&self, session: &Session) -> Result<(), DatabaseError> {
        session
            .query_unpaged(
                r#"
                    INSERT INTO payphone.servers (
                        server_id,
                        name,
                        prefix,
                        language
                    ) VALUES (?, ?, ?, ?) IF NOT EXISTS;
                "#,
                Self::to_row(self.clone()),
            )
            .await
            .inspect_err(|e| log::error!("{e:?}"))
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }

    pub async fn upsert(&self, session: &Session) -> Result<(), DatabaseError> {
        session
            .query_unpaged(
                r#"
                    INSERT INTO payphone.servers (
                        server_id,
                        name,
                        prefix,
                        language
                    ) VALUES (
                        ?,
                        ?,
                        ?,
                        ?
                    );
                "#,
                Self::to_row(self.clone()),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }

    pub async fn delete_by_id(id: u64, session: &Session) -> Result<(), DatabaseError> {
        session
            .query_unpaged(
                "DELETE FROM payphone.servers WHERE server_id = ?;",
                (u64_to_i64(id),),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }
}

impl From<TwilightGuild> for Server {
    fn from(value: TwilightGuild) -> Self {
        Self {
            id: value.id.get(),
            name: value.name,
            prefix: DEFAULT_PREFIX.into(),
            language: value.preferred_locale,
        }
    }
}

#[derive(Debug, Clone)]
pub struct Channel {
    pub id: u64,
    pub server_id: u64,
    pub call_id: Option<u64>,
    pub is_searching: bool,
    pub recently_called_server_ids: Vec<u64>,
    pub webhook_id: Option<u64>,
    pub webhook_token: Option<String>,
}

impl<'a> Object<'a> for Channel {
    type Row = (
        i64,
        i64,
        Option<i64>,
        bool,
        Vec<i64>,
        Option<i64>,
        Option<String>,
    );

    fn from_row(row: Self::Row) -> Self {
        Self {
            id: i64_to_u64(row.0),
            server_id: i64_to_u64(row.1),
            call_id: row.2.map(i64_to_u64),
            is_searching: row.3,
            recently_called_server_ids: row.4.iter().map(|&i| i64_to_u64(i)).collect(),
            webhook_id: row.5.map(i64_to_u64),
            webhook_token: row.6,
        }
    }

    fn to_row(value: Self) -> Self::Row {
        (
            u64_to_i64(value.id),
            u64_to_i64(value.server_id),
            value.call_id.map(u64_to_i64),
            value.is_searching,
            value
                .recently_called_server_ids
                .iter()
                .map(|&u| u64_to_i64(u))
                .collect(),
            value.webhook_id.map(u64_to_i64),
            value.webhook_token,
        )
    }
}

async fn get_or_create_channel_webhook(
    channel_id: u64,
    http: &Client,
) -> Result<Webhook, DatabaseOrDiscordError> {
    let webhooks = http
        .channel_webhooks(Id::new(channel_id))
        .await
        .inspect_err(|e| log::error!("Failed to get webhooks from channel {channel_id}: {e:?}"))
        .map_err(DatabaseOrDiscordError::Discord)?
        .model()
        .await
        .inspect_err(|e| log::error!("Failed to get model for webhooks {channel_id}: {e:?}"))
        .map_err(|_| DatabaseOrDiscordError::DiscordDeserializationFailed)?;

    let webhook = if let Some(item) = webhooks.into_iter().find(|item| item.token.is_some()) {
        item
    } else {
        http.create_webhook(Id::new(channel_id), "Payphone Messages")
            .await
            .inspect_err(|e| {
                log::error!("Failed to create webhook for channel {channel_id}: {e:?}")
            })
            .map_err(DatabaseOrDiscordError::Discord)?
            .model()
            .await
            .inspect_err(|e| log::error!("Failed to get model for webhook {channel_id}: {e:?}"))
            .map_err(|_| DatabaseOrDiscordError::DiscordDeserializationFailed)?
    };

    Ok(webhook)
}

impl Channel {
    pub async fn get_by_id(id: u64, session: &Session) -> Result<Option<Self>, DatabaseError> {
        let id = u64_to_i64(id);

        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        channel_id,
                        server_id,
                        call_id,
                        is_searching,
                        recently_called_server_ids,
                        webhook_id,
                        webhook_token
                    FROM
                        payphone.channels
                    WHERE
                        channel_id = ?
                    LIMIT 1;
                "#,
                (id,),
            )
            .await?
            .into_rows_result()?;

        get_single_row_from_result(&result).await
    }

    pub async fn get_or_create_by_id(
        id: u64,
        session: &Session,
        http: &Client,
    ) -> Result<Self, DatabaseOrDiscordError> {
        if let Some(channel) = Channel::get_by_id(id, session)
            .await
            .map_err(DatabaseOrDiscordError::Database)?
        {
            Ok(channel)
        } else {
            let webhook = get_or_create_channel_webhook(id, http).await?;

            let response = http
                .channel(Id::new(id))
                .await
                .map_err(DatabaseOrDiscordError::Discord)?
                .model()
                .await
                .inspect_err(|e| {
                    log::error!("The discord API didn't return a parseable channel! {e:?}")
                })
                .map_err(|_| DatabaseOrDiscordError::DiscordDeserializationFailed)?;

            let channel = Channel {
                id: response.id.get(),
                server_id: response.guild_id.map(|i| i.get()).unwrap_or(0),
                call_id: None,
                is_searching: false,
                recently_called_server_ids: vec![],
                webhook_id: Some(webhook.id.get()),
                webhook_token: webhook.token,
            };
            channel
                .upsert(session)
                .await
                .inspect_err(|e| log::error!("Could not upsert channel in database! {e:?}"))
                .map_err(DatabaseOrDiscordError::Database)?;

            Ok(channel)
        }
    }

    pub async fn upsert(&self, session: &Session) -> Result<(), DatabaseError> {
        session
            .query_unpaged(
                r#"
                    INSERT INTO payphone.channels (
                        channel_id,
                        server_id,
                        call_id,
                        is_searching,
                        recently_called_server_ids,
                        webhook_id,
                        webhook_token
                    ) VALUES (?, ?, ?, ?, ?, ?, ?);
                "#,
                Self::to_row(self.clone()),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }

    pub async fn cancel_search(&self, session: &Session) -> Result<(), DatabaseError> {
        session
            .query_unpaged(
                "UPDATE payphone.channels SET is_searching = false WHERE channel_id = ?;",
                (u64_to_i64(self.id),),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }

    pub async fn update_webhook(
        &mut self,
        session: &Session,
        http: &Client,
    ) -> Result<(), DatabaseOrDiscordError> {
        let webhook = get_or_create_channel_webhook(self.id, http).await?;

        self.webhook_id = Some(webhook.id.get());
        self.webhook_token = webhook.token;

        self.upsert(session).await?;

        Ok(())
    }
}

#[derive(Debug, Clone)]
pub struct SearchingChannel {
    pub id: u64,
    pub server_id: u64,
    pub recently_called_server_ids: Vec<u64>,
}

impl<'a> Object<'a> for SearchingChannel {
    type Row = (i64, i64, Vec<i64>);

    fn from_row(row: Self::Row) -> Self {
        Self {
            id: i64_to_u64(row.0),
            server_id: i64_to_u64(row.1),
            recently_called_server_ids: row.2.iter().map(|&i| i64_to_u64(i)).collect(),
        }
    }

    fn to_row(value: Self) -> Self::Row {
        (
            u64_to_i64(value.id),
            u64_to_i64(value.server_id),
            value
                .recently_called_server_ids
                .iter()
                .map(|&u| u64_to_i64(u))
                .collect(),
        )
    }
}

impl SearchingChannel {
    pub async fn get_all(session: &Session) -> Result<Vec<Self>, DatabaseError> {
        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        channel_id,
                        server_id,
                        recently_called_server_ids
                    FROM
                        payphone.searching_channels;
                "#,
                (),
            )
            .await?
            .into_rows_result()?;

        Ok(result
            .rows::<<SearchingChannel as Object>::Row>()?
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .map(Self::from_row)
            .collect::<Vec<_>>())
    }
}

#[derive(Debug, Clone)]
pub struct Call {
    pub id: u64,
    pub channel_ids: Vec<u64>,
    pub started_at: UtcDateTime,
    pub finished_at: Option<UtcDateTime>,
}

impl<'a> Object<'a> for Call {
    type Row = (i64, Vec<i64>, OffsetDateTime, Option<OffsetDateTime>);

    fn from_row(row: Self::Row) -> Self {
        Self {
            id: i64_to_u64(row.0),
            channel_ids: row.1.iter().map(|&i| i64_to_u64(i)).collect(),
            started_at: row.2.into(),
            finished_at: row.3.map(|i| i.into()),
        }
    }

    fn to_row(value: Self) -> Self::Row {
        (
            u64_to_i64(value.id),
            value.channel_ids.iter().map(|&u| u64_to_i64(u)).collect(),
            value.started_at.into(),
            value.finished_at.map(|i| i.into()),
        )
    }
}

fn push_and_cap<T>(vec: &mut Vec<T>, value: T, max_size: usize) {
    if vec.len() >= max_size {
        vec.remove(0);
    }

    vec.push(value);
}

impl Call {
    pub async fn get_by_id(id: u64, session: &Session) -> Result<Option<Self>, DatabaseError> {
        let id = u64_to_i64(id);

        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        call_id,
                        channel_ids,
                        started_at,
                        finished_at
                    FROM
                        payphone.calls
                    WHERE
                        call_id = ?
                    LIMIT 1;
                "#,
                (id,),
            )
            .await
            .map_err(DatabaseError::QueryError)?
            .into_rows_result()?;

        get_single_row_from_result(&result).await
    }

    /// Returns the opposite party's channel ID.
    pub fn other_party_channel_id(&self, channel_id: u64) -> u64 {
        if self.channel_ids[0] == channel_id {
            self.channel_ids[1]
        } else {
            self.channel_ids[0]
        }
    }

    pub fn is_active(&self) -> bool {
        self.finished_at.is_none()
    }

    /// Starts a call, or marks the channel as searching if the call is not started.
    ///
    /// Arguments:
    /// * `channel` - The channel to start the call in.
    /// * `session` - The Scylla session to use for database operations.
    ///
    /// Returns:
    /// [`Result<Option<Self>, DatabaseError>`] - `Ok(Some(Call))` if the call was started
    /// successfully, or `Ok(None)` if the channel was marked as searching. If an error occurs, it
    /// returns `Err(DatabaseError)`.
    pub async fn start(
        channel: &Channel,
        session: &Session,
    ) -> Result<Option<Self>, DatabaseError> {
        let searching_channels = SearchingChannel::get_all(session).await?;

        let call_id = get_random_u64();

        log::trace!("Call ID is {call_id}");

        for searching_channel in searching_channels
            .iter()
            .filter(|sc| !sc.recently_called_server_ids.contains(&channel.server_id))
        {
            if searching_channel.server_id == channel.server_id {
                return Ok(None);
            }

            if channel
                .recently_called_server_ids
                .contains(&searching_channel.server_id)
            {
                continue;
            }

            log::trace!("Found a searching channel: {searching_channel:?}");

            let mut searching_channel_recently_called_server_ids = searching_channel
                .recently_called_server_ids
                .clone()
                .into_iter()
                .map(u64_to_i64)
                .collect::<Vec<_>>();
            push_and_cap(
                &mut searching_channel_recently_called_server_ids,
                u64_to_i64(channel.server_id),
                5,
            );

            let (is_applied, ..) = session
                .query_unpaged(
                    r#"
                        UPDATE payphone.channels
                        SET
                            is_searching = false,
                            call_id = ?,
                            recently_called_server_ids = ?
                        WHERE
                            channel_id = ?
                        IF call_id = NULL;
                    "#,
                    (
                        u64_to_i64(call_id),
                        searching_channel_recently_called_server_ids,
                        u64_to_i64(searching_channel.id),
                    ),
                )
                .await
                .inspect_err(|e| log::error!("Failed to add channel to the call! {e:?}"))?
                .into_rows_result()
                .inspect_err(|e| log::error!("Failed to get result of the query! {e:?}"))?
                .first_row::<(bool, Option<i64>)>()
                .inspect_err(|e| log::error!("Failed to get first row of the result! {e:?}"))?;

            log::trace!("Is applied: {is_applied:?}");

            if is_applied {
                let mut channel_recently_called_server_ids = channel
                    .recently_called_server_ids
                    .clone()
                    .into_iter()
                    .map(u64_to_i64)
                    .collect::<Vec<_>>();
                push_and_cap(
                    &mut channel_recently_called_server_ids,
                    u64_to_i64(searching_channel.server_id),
                    5,
                );

                session
                    .query_unpaged(
                        "UPDATE payphone.channels SET call_id = ?, recently_called_server_ids = ? WHERE channel_id = ?",
                        (u64_to_i64(call_id), channel_recently_called_server_ids, u64_to_i64(channel.id)),
                    )
                    .await
                    .inspect_err(|e| log::error!("Failed to update channel {e:?}"))
                    .map_err(DatabaseError::QueryError)?;

                let call = Call {
                    id: call_id,
                    channel_ids: vec![searching_channel.id, channel.id].into_iter().collect(),
                    started_at: UtcDateTime::now(),
                    finished_at: None,
                };
                call.insert(session)
                    .await
                    .inspect_err(|e| log::error!("Failed to insert call {e:?}"))?;

                return Ok(Some(call));
            } else {
                // This channel already got a call, so we skip it, preventing race conditions.
                continue;
            }
        }

        session.query_unpaged(
            "UPDATE payphone.channels SET is_searching = true WHERE channel_id = ? IF call_id = NULL;",
            (u64_to_i64(channel.id),),
        )
        .await
        .inspect_err(|e| log::error!("Failed to mark channel as searching! {e:?}"))
        .map_err(DatabaseError::QueryError)?;

        Ok(None)
    }

    pub async fn insert(&self, session: &Session) -> Result<(), DatabaseError> {
        session
            .query_unpaged(
                r#"
                    INSERT INTO payphone.calls (
                        call_id,
                        channel_ids,
                        started_at,
                        finished_at
                    ) VALUES (?, ?, ?, ?);
                "#,
                Self::to_row(self.clone()),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }

    pub async fn hangup(&self, session: &Session) -> Result<(), DatabaseError> {
        let mut batch = Batch::new(BatchType::Unlogged);

        batch.append_statement(Statement::new(
            "UPDATE payphone.calls SET finished_at = ? WHERE call_id = ?;",
        ));
        batch.append_statement(Statement::new(
            "UPDATE payphone.channels SET call_id = NULL WHERE channel_id = ?;",
        ));
        batch.append_statement(Statement::new(
            "UPDATE payphone.channels SET call_id = NULL WHERE channel_id = ?;",
        ));

        let call_id = u64_to_i64(self.id);

        session
            .batch(
                &batch,
                (
                    (OffsetDateTime::now_utc(), call_id),
                    (u64_to_i64(self.channel_ids[0]),),
                    (u64_to_i64(self.channel_ids[1]),),
                ),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        log::trace!("Hung up call {call_id}");

        Ok(())
    }

    pub async fn count(session: &Session) -> Result<usize, DatabaseError> {
        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        call_id
                    FROM
                        payphone.calls;
                "#,
                (),
            )
            .await?
            .into_rows_result()?;

        Ok(result.rows_num())
    }
}

#[derive(Debug, Clone, SerializeValue, DeserializeValue)]
pub struct MessageData {
    pub id: i64,
    pub call_id: i64,

    pub author_id: i64,
    pub author_name: String,
    pub author_avatar_url: String,
    pub author_mask: Option<String>,

    pub content: String,
    pub attachments: Vec<String>,
    pub sticker: Option<i64>,

    pub propagation_message_id: Option<i64>,
    pub propagation_channel_id: Option<i64>,

    pub replying_to_message_id: Option<i64>,

    pub is_deleted: bool,
    pub is_edited: bool,
    pub is_censored: bool,
}

#[derive(Debug, Error)]
#[error("The message was missing either the event's message, the user's profile, or the call ID")]
pub struct MessageBuilderError;

#[derive(Default)]
pub struct MessageBuilder {
    message: Option<TwilightMessage>,
    participant: Option<Participant>,
    call_id: Option<u64>,
    is_censored: bool,
    propagation_message_id: Option<u64>,
    propagation_channel_id: Option<u64>,
    replying_to_message_id: Option<u64>,
}

impl MessageBuilder {
    fn new() -> Self {
        Self {
            message: None,
            participant: None,
            call_id: None,
            is_censored: false,
            propagation_message_id: None,
            propagation_channel_id: None,
            replying_to_message_id: None,
        }
    }

    pub fn message(mut self, message: TwilightMessage) -> Self {
        self.message = Some(message);
        self
    }

    pub fn participant(mut self, participant: Participant) -> Self {
        self.participant = Some(participant);
        self
    }

    pub fn call_id(mut self, call_id: u64) -> Self {
        self.call_id = Some(call_id);
        self
    }

    #[allow(clippy::wrong_self_convention)]
    pub fn is_censored(mut self, is_censored: bool) -> Self {
        self.is_censored = is_censored;
        self
    }

    pub fn propagation_message_id(mut self, propagation_message_id: u64) -> Self {
        self.propagation_message_id = Some(propagation_message_id);
        self
    }

    pub fn propagation_channel_id(mut self, propagation_channel_id: u64) -> Self {
        self.propagation_channel_id = Some(propagation_channel_id);
        self
    }

    // Argument is made optional here because it happens to be more convenient for where this is
    // used.
    pub fn replying_to_message_id(mut self, replying_to_id: Option<u64>) -> Self {
        self.replying_to_message_id = replying_to_id;
        self
    }

    pub fn build(self) -> Result<Message, MessageBuilderError> {
        let message = self.message.ok_or(MessageBuilderError)?;
        let participant = self.participant.ok_or(MessageBuilderError)?;
        let call_id = self.call_id.ok_or(MessageBuilderError)?;

        let data = MessageData {
            id: u64_to_i64(message.id.get()),
            call_id: u64_to_i64(call_id),
            author_id: u64_to_i64(participant.user_id),
            author_name: participant.user_name,
            author_avatar_url: participant.user_avatar_url,
            author_mask: participant.is_masked.then_some(participant.user_mask),
            content: message.content,
            attachments: message.attachments.iter().map(|a| a.url.clone()).collect(),
            sticker: message
                .sticker_items
                .first()
                .map(|s| u64_to_i64(s.id.get())),
            propagation_message_id: self.propagation_message_id.map(u64_to_i64),
            propagation_channel_id: self.propagation_channel_id.map(u64_to_i64),
            replying_to_message_id: self.replying_to_message_id.map(u64_to_i64),

            // You can't create a deleted message, this is always going to be false when
            // initializing
            is_deleted: false,
            is_edited: message.edited_timestamp.is_some(),
            is_censored: self.is_censored,
        };

        Ok(Message {
            call_id,
            message_id: message.id.get(),
            author_id: participant.user_id,
            propagation_message_id: self.propagation_message_id,
            data,
        })
    }
}

#[derive(Debug, Clone)]
pub struct Message {
    pub call_id: u64,
    pub message_id: u64,
    pub author_id: u64,
    pub propagation_message_id: Option<u64>,
    pub data: MessageData,
}

impl<'a> Object<'a> for Message {
    type Row = (i64, i64, i64, Option<i64>, MessageData);

    fn from_row(row: Self::Row) -> Self {
        Self {
            call_id: i64_to_u64(row.0),
            message_id: i64_to_u64(row.1),
            author_id: i64_to_u64(row.2),
            propagation_message_id: row.3.map(i64_to_u64),
            data: row.4,
        }
    }

    fn to_row(value: Self) -> Self::Row {
        (
            u64_to_i64(value.call_id),
            u64_to_i64(value.message_id),
            u64_to_i64(value.author_id),
            value.propagation_message_id.map(u64_to_i64),
            value.data,
        )
    }
}

impl Message {
    pub fn build() -> MessageBuilder {
        MessageBuilder::new()
    }

    pub async fn get_by_call_and_message_id(
        call_id: u64,
        message_id: u64,
        session: &Session,
    ) -> Result<Option<Self>, DatabaseError> {
        let call_id = u64_to_i64(call_id);
        let message_id_i64 = u64_to_i64(message_id);

        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        call_id,
                        message_id,
                        author_id,
                        propagation_message_id,
                        data
                    FROM
                        payphone.messages
                    WHERE
                        call_id = ? AND message_id = ?
                    LIMIT 1;
                "#,
                (call_id, message_id_i64),
            )
            .await?
            .into_rows_result()?;

        if result.rows_num() == 0 {
            Self::get_by_propagation_message_id(message_id, session).await
        } else {
            get_single_row_from_result(&result).await
        }
    }

    pub async fn get_by_propagation_message_id(
        propagation_message_id: u64,
        session: &Session,
    ) -> Result<Option<Self>, DatabaseError> {
        let message_by_propagation_id =
            MessageByPropagationId::get_by_propagation_message_id(propagation_message_id, session)
                .await?;

        if let Some(message_by_propagation_id) = message_by_propagation_id {
            let result = session
                .query_unpaged(
                    r#"
                        SELECT
                            call_id,
                            message_id,
                            author_id,
                            propagation_message_id,
                            data
                        FROM
                            payphone.messages
                        WHERE
                            call_id = ? AND message_id = ?
                        LIMIT 1;
                    "#,
                    (
                        u64_to_i64(message_by_propagation_id.call_id),
                        u64_to_i64(message_by_propagation_id.message_id),
                    ),
                )
                .await?
                .into_rows_result()?;

            return get_single_row_from_result(&result).await;
        }

        Ok(None)
    }

    pub async fn get_last_by_author_id(
        call_id: u64,
        author_id: u64,
        session: &Session,
    ) -> Result<Option<Self>, DatabaseError> {
        let message_by_author_id =
            MessageByAuthorId::get_last_by_author_id(call_id, author_id, session).await?;

        if let Some(message_by_author_id) = message_by_author_id {
            let result = session
                .query_unpaged(
                    r#"
                        SELECT
                            call_id,
                            message_id,
                            author_id,
                            propagation_message_id,
                            data
                        FROM
                            payphone.messages
                        WHERE
                            call_id = ? AND message_id = ?
                        LIMIT 1;
                    "#,
                    (
                        u64_to_i64(message_by_author_id.call_id),
                        u64_to_i64(message_by_author_id.message_id),
                    ),
                )
                .await?
                .into_rows_result()?;

            return get_single_row_from_result(&result).await;
        }

        Ok(None)
    }

    pub async fn insert(&self, session: &Session) -> Result<(), DatabaseError> {
        session
            .query_unpaged(
                r#"
                    INSERT INTO payphone.messages (
                        call_id,
                        message_id,
                        author_id,
                        propagation_message_id,
                        data
                    ) VALUES (?, ?, ?, ?, ?);
                "#,
                Self::to_row(self.clone()),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }

    pub async fn count(session: &Session) -> Result<usize, DatabaseError> {
        let result = session
            .query_unpaged(
                r#"
                    SELECT message_id FROM payphone.messages;
                "#,
                (),
            )
            .await?
            .into_rows_result()?;

        Ok(result.rows_num())
    }
}

pub struct MessageByPropagationId {
    pub call_id: u64,
    pub message_id: u64,
    pub propagation_message_id: u64,
}

impl<'a> Object<'a> for MessageByPropagationId {
    type Row = (i64, i64, i64);

    fn from_row(row: Self::Row) -> Self {
        Self {
            call_id: i64_to_u64(row.0),
            message_id: i64_to_u64(row.1),
            propagation_message_id: i64_to_u64(row.2),
        }
    }

    fn to_row(value: Self) -> Self::Row {
        (
            u64_to_i64(value.call_id),
            u64_to_i64(value.message_id),
            u64_to_i64(value.propagation_message_id),
        )
    }
}

impl MessageByPropagationId {
    pub async fn get_by_propagation_message_id(
        propagation_message_id: u64,
        session: &Session,
    ) -> Result<Option<Self>, DatabaseError> {
        let propagation_message_id = u64_to_i64(propagation_message_id);

        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        call_id,
                        message_id,
                        propagation_message_id
                    FROM
                        payphone.messages_by_propagation_id
                    WHERE
                        propagation_message_id = ?
                    LIMIT 1;
                "#,
                (propagation_message_id,),
            )
            .await?
            .into_rows_result()?;

        get_single_row_from_result(&result).await
    }
}

pub struct MessageByAuthorId {
    pub call_id: u64,
    pub message_id: u64,
    pub author_id: u64,
}

impl<'a> Object<'a> for MessageByAuthorId {
    type Row = (i64, i64, i64);

    fn from_row(row: Self::Row) -> Self {
        Self {
            call_id: i64_to_u64(row.0),
            message_id: i64_to_u64(row.1),
            author_id: i64_to_u64(row.2),
        }
    }

    fn to_row(value: Self) -> Self::Row {
        (
            u64_to_i64(value.call_id),
            u64_to_i64(value.message_id),
            u64_to_i64(value.author_id),
        )
    }
}

impl MessageByAuthorId {
    pub async fn get_last_by_author_id(
        call_id: u64,
        author_id: u64,
        session: &Session,
    ) -> Result<Option<Self>, DatabaseError> {
        let call_id = u64_to_i64(call_id);
        let author_id = u64_to_i64(author_id);

        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        call_id,
                        message_id,
                        author_id
                    FROM
                        payphone.messages_by_author_id
                    WHERE
                        call_id = ? AND
                        author_id = ?
                    ORDER BY message_id DESC
                    LIMIT 1;
                "#,
                (call_id, author_id),
            )
            .await?
            .into_rows_result()?;

        get_single_row_from_result(&result).await
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ReportResolution {
    Ban,
    Warn,
    Skip,
}

#[derive(Debug, Clone)]
pub struct Report {
    pub id: u64,
    pub user_id: u64,

    pub message: MessageData,
    pub replying_to: Option<MessageData>,

    pub created_at: UtcDateTime,
    pub reviewed_at: Option<UtcDateTime>,

    pub created_by_ids: Vec<u64>,

    pub reviewed_by_id: Option<u64>,
    pub resolution: Option<ReportResolution>,
}

impl<'a> Object<'a> for Report {
    type Row = (
        i64,
        i64,
        MessageData,
        Option<MessageData>,
        OffsetDateTime,
        Option<OffsetDateTime>,
        Vec<i64>,
        Option<i64>,
        Option<String>,
    );

    fn from_row(row: Self::Row) -> Self {
        Self {
            id: i64_to_u64(row.0),
            user_id: i64_to_u64(row.1),
            message: row.2,
            replying_to: row.3,
            created_at: row.4.to_utc(),
            reviewed_at: row.5.map(|i| i.to_utc()),
            created_by_ids: row.6.into_iter().map(i64_to_u64).collect(),
            reviewed_by_id: row.7.map(i64_to_u64),
            resolution: row.8.map(|r| match r.as_str() {
                "ban" => ReportResolution::Ban,
                "warn" => ReportResolution::Warn,
                "skip" => ReportResolution::Skip,
                _ => unreachable!(),
            }),
        }
    }

    fn to_row(value: Self) -> Self::Row {
        (
            u64_to_i64(value.id),
            u64_to_i64(value.user_id),
            value.message,
            value.replying_to,
            value.created_at.to_offset(UtcOffset::UTC),
            value.reviewed_at.map(|i| i.to_offset(UtcOffset::UTC)),
            value.created_by_ids.into_iter().map(u64_to_i64).collect(),
            value.reviewed_by_id.map(u64_to_i64),
            value.resolution.map(|r| match r {
                ReportResolution::Ban => "ban".into(),
                ReportResolution::Warn => "warn".into(),
                ReportResolution::Skip => "skip".into(),
            }),
        )
    }
}

impl Report {
    pub async fn insert(&self, session: &Session) -> Result<(), DatabaseError> {
        session
            .query_unpaged(
                r#"
                    INSERT INTO payphone.reports (
                        report_id,
                        user_id,
                        message,
                        replying_to,
                        created_at,
                        reviewed_at,
                        created_by_ids,
                        reviewed_by_id,
                        resolution
                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);
                "#,
                Self::to_row(self.clone()),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum UserIncidentType {
    Warning,
    Ban,
}

#[derive(Debug, Clone)]
pub struct UserIncident {
    pub user_id: u64,
    pub incident_id: u64,
    pub report_id: Option<u64>,

    pub r#type: UserIncidentType,

    pub message: Option<MessageData>,

    pub reason: String,

    pub created_by_id: Option<u64>,

    pub created_at: UtcDateTime,
    pub expires_at: Option<UtcDateTime>,
    pub duration: Option<String>,
}

impl<'a> Object<'a> for UserIncident {
    type Row = (
        i64,
        i64,
        Option<i64>,
        String,
        Option<MessageData>,
        String,
        Option<i64>,
        OffsetDateTime,
        Option<OffsetDateTime>,
        Option<String>,
    );

    fn from_row(row: Self::Row) -> Self {
        Self {
            user_id: i64_to_u64(row.0),
            incident_id: i64_to_u64(row.1),
            report_id: row.2.map(i64_to_u64),
            r#type: match row.3.as_str() {
                "warning" => UserIncidentType::Warning,
                "ban" => UserIncidentType::Ban,
                _ => unreachable!(),
            },
            message: row.4,
            reason: row.5,
            created_by_id: row.6.map(i64_to_u64),
            created_at: row.7.to_utc(),
            expires_at: row.8.map(|i| i.to_utc()),
            duration: row.9,
        }
    }

    fn to_row(value: Self) -> Self::Row {
        (
            u64_to_i64(value.user_id),
            u64_to_i64(value.incident_id),
            value.report_id.map(u64_to_i64),
            match value.r#type {
                UserIncidentType::Warning => "warning".into(),
                UserIncidentType::Ban => "ban".into(),
            },
            value.message,
            value.reason,
            value.created_by_id.map(u64_to_i64),
            value.created_at.to_offset(UtcOffset::UTC),
            value.expires_at.map(|i| i.to_offset(UtcOffset::UTC)),
            value.duration,
        )
    }
}

impl UserIncident {
    pub fn is_active(&self) -> bool {
        self.expires_at
            .map(|e| e > UtcDateTime::now())
            .unwrap_or(true)
            && self.r#type == UserIncidentType::Ban
    }

    pub async fn get_by_user_and_incident_id(
        user_id: u64,
        incident_id: u64,
        session: &Session,
    ) -> Result<Option<Self>, DatabaseError> {
        let user_id = u64_to_i64(user_id);
        let incident_id = u64_to_i64(incident_id);

        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        user_id,
                        incident_id,
                        report_id,
                        type,
                        message,
                        reason,
                        created_by_id,
                        created_at,
                        expires_at,
                        duration
                    FROM
                        payphone.user_incidents
                    WHERE
                        user_id = ? AND incident_id = ?;
                "#,
                (user_id, incident_id),
            )
            .await?
            .into_rows_result()?;

        get_single_row_from_result(&result).await
    }

    pub async fn get_for_user(user_id: u64, session: &Session) -> Result<Vec<Self>, DatabaseError> {
        let user_id = u64_to_i64(user_id);

        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        user_id,
                        incident_id,
                        report_id,
                        type,
                        message,
                        reason,
                        created_by_id,
                        created_at,
                        expires_at,
                        duration
                    FROM
                        payphone.user_incidents
                    WHERE
                        user_id = ?;
                "#,
                (user_id,),
            )
            .await?
            .into_rows_result()?;

        Ok(result
            .rows::<<Self as Object>::Row>()?
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .map(Self::from_row)
            .collect::<Vec<_>>())
    }

    pub async fn insert(&self, session: &Session) -> Result<(), DatabaseError> {
        session
            .query_unpaged(
                r#"
                    INSERT INTO payphone.user_incidents (
                        user_id,
                        incident_id,
                        report_id,
                        type,
                        message,
                        reason,
                        created_by_id,
                        created_at,
                        expires_at,
                        duration
                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
                "#,
                Self::to_row(self.clone()),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }

    pub async fn delete_by_user_and_incident_id(
        user_id: u64,
        incident_id: u64,
        session: &Session,
    ) -> Result<(), DatabaseError> {
        let user_id = u64_to_i64(user_id);
        let incident_id = u64_to_i64(incident_id);

        session
            .query_unpaged(
                r#"
                    DELETE FROM payphone.user_incidents
                    WHERE user_id = ? AND incident_id = ?;
                "#,
                (user_id, incident_id),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }

    pub async fn expire_by_user_and_incident_id(
        user_id: u64,
        incident_id: u64,
        session: &Session,
    ) -> Result<(), DatabaseError> {
        let Some(mut incident) =
            Self::get_by_user_and_incident_id(user_id, incident_id, session).await?
        else {
            return Ok(());
        };

        incident.expires_at = Some(UtcDateTime::now());

        incident.insert(session).await
    }
}

#[derive(Debug, Clone)]
pub struct Participant {
    pub call_id: u64,
    pub user_id: u64,
    pub channel_id: u64,

    pub user_name: String,
    pub user_avatar_url: String,
    pub user_mask: String,

    pub is_masked: bool,
}

impl<'a> Object<'a> for Participant {
    type Row = (i64, i64, i64, String, String, String, bool);

    fn from_row(row: Self::Row) -> Self {
        Self {
            call_id: i64_to_u64(row.0),
            user_id: i64_to_u64(row.1),
            channel_id: i64_to_u64(row.2),
            user_name: row.3,
            user_avatar_url: row.4,
            user_mask: row.5,
            is_masked: row.6,
        }
    }

    fn to_row(value: Self) -> Self::Row {
        (
            u64_to_i64(value.call_id),
            u64_to_i64(value.user_id),
            u64_to_i64(value.channel_id),
            value.user_name,
            value.user_avatar_url,
            value.user_mask,
            value.is_masked,
        )
    }
}

fn make_name_valid(mut name: String) -> String {
    if let Err(error) = webhook_username(&name) {
        if let ValidationErrorType::WebhookUsername { len, substring } = error.kind() {
            if let Some(len) = len {
                if *len < 2 {
                    name = format!("{name}--");
                } else {
                    name = format!("{name:.80}");
                }
            } else {
                name = "Invalid name".into();
            }
        }
    }

    name
}

impl Participant {
    pub fn display_name(&self) -> String {
        if self.is_masked {
            get_mask_display_name(self.user_mask.clone())
        } else {
            make_name_valid(self.user_name.clone())
        }
    }

    pub fn avatar_url(&self) -> String {
        if self.is_masked {
            get_mask_avatar_url(self.user_mask.clone()).expect("Failed to get mask avatar URL")
        } else {
            self.user_avatar_url.clone()
        }
    }

    pub async fn get_for_call(call_id: u64, session: &Session) -> Result<Vec<Self>, DatabaseError> {
        let call_id = u64_to_i64(call_id);

        let rows = session
            .query_unpaged(
                r#"
                    SELECT
                        call_id,
                        user_id,
                        channel_id,
                        user_name,
                        user_avatar_url,
                        user_mask,
                        is_masked
                    FROM payphone.participants
                    WHERE call_id = ?;
                "#,
                (call_id,),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(rows
            .into_rows_result()?
            .rows()?
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .map(Self::from_row)
            .collect::<Vec<_>>())
    }

    pub async fn get_for_user_and_channel_in_call(
        user_id: u64,
        channel_id: u64,
        call_id: u64,
        session: &Session,
    ) -> Result<Option<Self>, DatabaseError> {
        let user_id = u64_to_i64(user_id);
        let channel_id = u64_to_i64(channel_id);
        let call_id = u64_to_i64(call_id);

        let result = session
            .query_unpaged(
                r#"
                    SELECT
                        call_id,
                        user_id,
                        channel_id,
                        user_name,
                        user_avatar_url,
                        user_mask,
                        is_masked
                    FROM
                        payphone.participants
                    WHERE
                        call_id = ? AND user_id = ? AND channel_id = ?
                    LIMIT 1;
                "#,
                (call_id, user_id, channel_id),
            )
            .await?
            .into_rows_result()?;

        get_single_row_from_result(&result).await
    }

    pub async fn get_or_create(
        user_id: u64,
        channel_id: u64,
        call_id: u64,
        display_name: String,
        display_avatar_url: String,
        is_masked: bool,
        session: &Session,
    ) -> Result<Self, DatabaseError> {
        let participants = Self::get_for_call(call_id, session).await?;

        if let Some(participant) = participants
            .iter()
            .find(|p| p.user_id == user_id && p.channel_id == channel_id)
        {
            // User is already a participant in the call
            return Ok(participant.clone());
        }

        let masks_in_use = participants
            .iter()
            .filter_map(|p| {
                if p.channel_id == channel_id {
                    Some(p.user_mask.clone())
                } else {
                    None
                }
            })
            .collect::<Vec<_>>();

        let (mask, _) = get_random_mask(&masks_in_use).ok_or(DatabaseError::Unknown(
            "No remaining masks available for the channel",
        ))?;

        let participant = Participant {
            call_id,
            user_id,
            channel_id,
            user_name: display_name,
            user_avatar_url: display_avatar_url,
            user_mask: mask,
            is_masked,
        };

        participant.insert(session).await?;

        Ok(participant)
    }

    pub async fn insert(&self, session: &Session) -> Result<(), DatabaseError> {
        session
            .query_unpaged(
                r#"
                    INSERT INTO payphone.participants (
                        call_id,
                        user_id,
                        channel_id,
                        user_name,
                        user_avatar_url,
                        user_mask,
                        is_masked
                    ) VALUES (?, ?, ?, ?, ?, ?, ?) IF NOT EXISTS;
                "#,
                Self::to_row(self.clone()),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }

    pub async fn upsert(&self, session: &Session) -> Result<(), DatabaseError> {
        session
            .query_unpaged(
                r#"
                    INSERT INTO payphone.participants (
                        call_id,
                        user_id,
                        channel_id,
                        user_name,
                        user_avatar_url,
                        user_mask,
                        is_masked
                    ) VALUES (?, ?, ?, ?, ?, ?, ?);
                "#,
                Self::to_row(self.clone()),
            )
            .await
            .map_err(DatabaseError::QueryError)?;

        Ok(())
    }
}