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 sdk's own pre-send work, run early. a send landing mid-share waits on the

/// sdk's per-room share lock instead of starting another (forked sdk, see design-decisions)

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

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

    room.prepare_encryption()

        .await

        .map_err(|source| Error::from_sdk("preparing room encryption failed", source))

}