path: root/src/message.rs

use std::ops::{Deref, DerefMut};

use filamento::{chat::Message, user::User};
use leptos::prelude::*;
use reactive_stores::ArcStore;
use uuid::Uuid;

use crate::{
    state_store::{StateListener, StateStore},
    user::{ArcMacawUser, MacawUser},
};

#[derive(Clone, Copy)]
pub struct MacawMessage {
    pub message: ArenaItem<StateListener<Uuid, ArcStore<Message>>>,
    pub user: MacawUser,
}

impl MacawMessage {
    pub fn get(&self) -> ArcStore<Message> {
        self.try_get_value().unwrap().get()
    }
}

impl Deref for MacawMessage {
    type Target = ArenaItem<StateListener<Uuid, ArcStore<Message>>>;

    fn deref(&self) -> &Self::Target {
        &self.message
    }
}

impl DerefMut for MacawMessage {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.message
    }
}

impl From<ArcMacawMessage> for MacawMessage {
    fn from(value: ArcMacawMessage) -> Self {
        Self {
            message: ArenaItem::new_with_storage(value.message),
            user: value.user.into(),
        }
    }
}

#[derive(Clone)]
pub struct ArcMacawMessage {
    pub message: StateListener<Uuid, ArcStore<Message>>,
    pub user: ArcMacawUser,
}

impl ArcMacawMessage {
    pub async fn got_message_and_user(message: Message, user: User) -> Self {
        let message_state_store: StateStore<Uuid, ArcStore<Message>> =
            use_context().expect("no message state store");
        let message = message_state_store.store(message.id, ArcStore::new(message));
        let user = ArcMacawUser::got_user(user).await;
        Self { message, user }
    }
}

impl Deref for ArcMacawMessage {
    type Target = StateListener<Uuid, ArcStore<Message>>;

    fn deref(&self) -> &Self::Target {
        &self.message
    }
}

impl DerefMut for ArcMacawMessage {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.message
    }
}