macltok

use std::collections::HashMap;

use futures_util::{

    FutureExt,

    future::{Shared, WeakShared},

};

use matrix_sdk::Client;

use ruma::OwnedRoomId;

use super::executor::EngineBoxFuture;

use crate::Error;

type Flight = Shared<EngineBoxFuture<'static, Result<(), Error>>>;

/// one warm-up per room at a time, later asks join the one in flight

#[derive(Default)]

pub(super) struct Preparations(

    HashMap<OwnedRoomId, WeakShared<EngineBoxFuture<'static, Result<(), Error>>>>,

);

impl Preparations {

    pub(super) fn join(&mut self, client: &Client, room_id: OwnedRoomId) -> Flight {

        self.0.retain(|_, flight| flight.upgrade().is_some());

        if let Some(flight) = self.0.get(&room_id).and_then(WeakShared::upgrade) {

            return flight;

        }

        let work: EngineBoxFuture<'static, _> = Box::pin(prepare(client.clone(), room_id.clone()));

        let flight = work.shared();

        if let Some(weak) = flight.downgrade() {

            self.0.insert(room_id, weak);

        }

        flight

    }

}

/// the part of the sdk's pre-send encryption work it lets us reach. syncing the members

/// has the sdk track them all, and its own background `/keys/query` then catches up

/// their devices. the one time key claim and the room key share stay on the send path

async fn prepare(client: Client, room_id: OwnedRoomId) -> Result<(), Error> {

    let room = client.get_room(&room_id).ok_or_else(Error::room_unknown)?;

    if room.encryption_state().is_encrypted() && !room.are_members_synced() {

        room.sync_members()

            .await

            .map_err(|source| Error::from_sdk("syncing room members failed", source))?;

    }

    Ok(())

}