pub(crate) mod room;
pub(crate) mod space;

use std::cell::RefCell;
use std::{collections::HashMap, rc::Rc};

use async_trait::async_trait;
use dioxus::prelude::*;

use crate::domain::model::room::{Room as DomainRoom, RoomId};
use crate::domain::model::space::{Space as DomainSpace, SpaceId};
use crate::domain::model::store_interface::{
    AccountStoreProviderInterface, RoomStoreProviderInterface, SpaceStoreProviderInterface,
};

use room::{Room, RoomProps};
use space::{Space, SpaceProps};

#[modx::store]
pub struct Store {
    rooms: HashMap<RoomId, Room>,
    spaces: HashMap<SpaceId, Space>,
}

#[async_trait(?Send)]
impl AccountStoreProviderInterface for GlobalSignal<Store> {
    fn on_new_room(&self, domain_room: Rc<DomainRoom>) -> Rc<dyn RoomStoreProviderInterface> {
        let room_id = domain_room.id();

        let props = RoomProps::new(room_id.clone(), domain_room.name());
        let room = Room::new(props);

        let mut rooms = self.read().rooms;
        rooms.write().insert(room_id.clone(), room);

        Rc::new(room.clone())
    }

    fn on_new_space(&self, domain_space: Rc<DomainSpace>) -> Rc<dyn SpaceStoreProviderInterface> {
        let space_id = domain_space.id();

        let props = SpaceProps::new(space_id.clone(), domain_space.name());
        let space = Space::new(props);

        let mut spaces = self.read().spaces;
        spaces.write().insert(space_id.clone(), space);

        Rc::new(RefCell::new(space.clone()))
    }
}