macltok

use matrix_sdk::{Room, room::RoomMember};

use ruma::{OwnedUserId, events::room::member::MembershipState};

use crate::{MediaId, MemberMembership, MemberSummary, Sender};

pub(crate) fn member_summary(member: RoomMember) -> MemberSummary {

    MemberSummary {

        user_id: member.user_id().to_owned(),

        name: member.name().to_owned(),

        display_name: member.display_name().map(ToOwned::to_owned),

        avatar: member.avatar_url().map(MediaId::plain),

        membership: match member.membership() {

            MembershipState::Join => MemberMembership::Joined,

            MembershipState::Invite => MemberMembership::Invited,

            MembershipState::Leave => MemberMembership::Left,

            MembershipState::Knock => MemberMembership::Knocked,

            MembershipState::Ban => MemberMembership::Banned,

            value => MemberMembership::Custom(value.to_string()),

        },

        own: member.is_account_user(),

        name_ambiguous: member.name_ambiguous(),

        ignored: member.is_ignored(),

        service: member.is_service_member(),

    }

}

/// fetches the member list when it isn't synced yet, and settles for the store when that fails

pub(crate) async fn member_sender(room: &Room, user_id: &OwnedUserId) -> Option<Sender> {

    match room.get_member(user_id).await {

        Ok(Some(member)) => Some(sender(user_id, &member)),

        _ => stored_member_sender(room, user_id).await,

    }

}

/// what the state store already knows, without asking the server

async fn stored_member_sender(room: &Room, user_id: &OwnedUserId) -> Option<Sender> {

    let member = room.get_member_no_sync(user_id).await.ok().flatten()?;

    Some(sender(user_id, &member))

}

fn sender(user_id: &OwnedUserId, member: &RoomMember) -> Sender {

    Sender {

        user_id: user_id.clone(),

        display_name: member.display_name().map(str::to_owned),

        avatar: member.avatar_url().map(MediaId::plain),

        name_ambiguous: member.name_ambiguous(),

    }

}