macltok

use crate::{AccountError, account::account_error};

/// the platform's own exclusive lock on a store. matrix-sdk 0.18's cross process lease drops

/// itself silently after one failed renewal or a stall past 500ms, so it can't be what keeps a

/// second engine out

pub(crate) struct StoreLock {

    #[cfg(feature = "sqlite")]

    _file: std::fs::File,

    #[cfg(feature = "indexeddb")]

    release: js_sys::Function,

}

#[cfg(feature = "sqlite")]

pub(crate) const LOCK_FILE: &str = "macltok.lock";

#[cfg(feature = "sqlite")]

impl StoreLock {

    pub(crate) fn file(directory: &std::path::Path) -> Result<Self, AccountError> {

        use std::fs::{self, File, TryLockError};

        fs::create_dir_all(directory)

            .map_err(|error| account_error("creating the Matrix store directory", error))?;

        let file = File::options()

            .create(true)

            .truncate(false)

            .write(true)

            .open(directory.join(LOCK_FILE))

            .map_err(|error| account_error("opening the Matrix store's lock file", error))?;

        match file.try_lock() {

            Ok(()) => Ok(Self { _file: file }),

            Err(TryLockError::WouldBlock) => Err(AccountError::StoreInUse),

            Err(TryLockError::Error(error)) => {

                Err(account_error("locking the Matrix store", error))

            }

        }

    }

}

#[cfg(feature = "indexeddb")]

#[derive(Debug, thiserror::Error)]

enum WebLockError {

    #[error("this global scope has no Web Locks, they need a secure context")]

    Unavailable,

    #[error("requesting the Web Lock failed, {0}")]

    Failed(String),

}

#[cfg(feature = "indexeddb")]

impl StoreLock {

    /// `ifAvailable` answers at once. the lock is ours until the promise we hand back settles

    pub(crate) async fn web(name: &str) -> Result<Self, AccountError> {

        use futures_util::future::{Either, select};

        use js_sys::{Function, Object, Promise, Reflect};

        use tokio::sync::oneshot;

        use wasm_bindgen::{JsCast, JsValue, closure::Closure};

        let failed = |error: JsValue| {

            account_error(

                "locking the Matrix store",

                WebLockError::Failed(format!("{error:?}")),

            )

        };

        let locks = Reflect::get(&js_sys::global(), &JsValue::from_str("navigator"))

            .and_then(|navigator| Reflect::get(&navigator, &JsValue::from_str("locks")))

            .map_err(failed)?;

        if locks.is_undefined() {

            return Err(account_error(

                "locking the Matrix store",

                WebLockError::Unavailable,

            ));

        }

        let request: Function = Reflect::get(&locks, &JsValue::from_str("request"))

            .map_err(failed)?

            .dyn_into()

            .map_err(failed)?;

        let options = Object::new();

        Reflect::set(&options, &JsValue::from_str("ifAvailable"), &JsValue::TRUE)

            .map_err(failed)?;

        let (granted, grant) = oneshot::channel();

        let callback = Closure::once(move |lock: JsValue| -> JsValue {

            if lock.is_null() {

                let _ = granted.send(None);

                return JsValue::UNDEFINED;

            }

            let mut release = None;

            let held = Promise::new(&mut |resolve, _| release = Some(resolve));

            let _ = granted.send(release);

            held.into()

        });

        let outcome: Promise = request

            .call3(

                &locks,

                &JsValue::from_str(&format!("macltok:{name}")),

                &options,

                callback.as_ref(),

            )

            .map_err(failed)?

            .dyn_into()

            .map_err(failed)?;

        match select(grant, wasm_bindgen_futures::JsFuture::from(outcome)).await {

            Either::Left((Ok(Some(release)), _)) => Ok(Self { release }),

            Either::Left((Ok(None), _)) => Err(AccountError::StoreInUse),

            Either::Left((Err(_), _)) | Either::Right((Ok(_), _)) => {

                Err(failed(JsValue::from_str("the lock callback never ran")))

            }

            Either::Right((Err(error), _)) => Err(failed(error)),

        }

    }

}

#[cfg(feature = "indexeddb")]

impl Drop for StoreLock {

    fn drop(&mut self) {

        let _ = self.release.call0(&wasm_bindgen::JsValue::UNDEFINED);

    }

}