path: root/src/capabilities.rs

use std::any::Any;
use std::collections::BTreeMap;
use std::sync::Arc;

use lazy_static;
use serde::{Deserialize, Serialize};

use crate::request::{JMAPInvocationArg, JMAPResult, MethodRegistry};
use crate::session::ISession;
use crate::*;

// JMAP Core capability {{{
/// JMAP Core URN
pub const URN_JMAP_CORE: &str = "urn:ietf:params:jmap:core";

lazy_static::lazy_static! {
    static ref JMAP_CORE_METHODS: MethodRegistry = {
        let mut reg = MethodRegistry::new();
        reg.add_method::<CoreEchoArgs>();
        reg
    };

    static ref DEFAULT_METHODS_REG: MethodRegistry = {
        MethodRegistry::new()
    };
}
// Capabilities {{{
//

pub trait Capability: 'static + Sized {
    const URN: &str;

    fn get_methods() -> &'static MethodRegistry {
        &DEFAULT_METHODS_REG
    }

    fn from_object(obj: &JObject) -> Self;
    fn account_cap(&self, account_id: JMAPId, obj: &JObject) -> Self;
    fn account(&self) -> Option<JMAPId>;
    fn from_object_dyn(obj: &JObject) -> Box<dyn CapabilityDyn> {
        Box::new(Self::from_object(obj))
    }

    fn is_account_capability(&self) -> bool {
        self.account().is_some()
    }
}

pub trait CapabilityDyn {
    // Get urn of the capability
    fn get_urn(&self) -> &'static str;

    // Convert to any for downcasting, immutable
    fn as_any(&self) -> &dyn Any;

    /// Convert to any for downcasting, mutable
    fn as_any_mut(&mut self) -> &mut dyn Any;

    /// Convert to any for downcasting, consumes object
    fn to_any(self) -> Box<dyn Any>;

    /// Given a capability and accountCapabilities Object get a capability
    fn account_cap_dyn(&self, account_id: JMAPId, obj: &JObject) -> Box<dyn CapabilityDyn>;

    /// Return the account if this capabilities has been given info for account
    fn account_dyn(&self) -> Option<JMAPId>;
}

impl<T: Capability> CapabilityDyn for T {
    fn get_urn(&self) -> &'static str {
        T::URN
    }
    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }

    fn to_any(self) -> Box<dyn Any> {
        Box::new(self)
    }

    fn account_cap_dyn(&self, account_id: JMAPId, obj: &JObject) -> Box<dyn CapabilityDyn> {
        Box::new(self.account_cap(account_id, obj))
    }

    fn account_dyn(&self) -> Option<JMAPId> {
        self.account()
    }
}

/// A function that parses a JObject into a Capability Trait object.
/// This capability will be able to implement functionality to the JMAPSession object.
pub type CapabilityParser = Box<dyn Fn(&JObject) -> Box<dyn CapabilityDyn>>;

pub struct CapabilityEntry {
    pub(crate) parser: CapabilityParser,
    pub(crate) methods: &'static MethodRegistry,
}

/// Collection of CapabilityParser
pub struct CapabilityRegistry(pub BTreeMap<String, CapabilityEntry>);

impl Default for CapabilityRegistry {
    fn default() -> Self {
        let mut c = Self::new();
        c.add_capability::<JMAPCoreCapability>();
        c
    }
}

impl CapabilityRegistry {
    /// Create a collection of parsers
    pub fn new() -> Self {
        Self(BTreeMap::new())
    }

    /// Insert a parser
    pub fn add_capability<T: Capability>(&mut self) {
        self.0.insert(
            T::URN.to_string(),
            CapabilityEntry {
                parser: Box::new(T::from_object_dyn),
                methods: T::get_methods(),
            },
        );
    }

    /// Use the parsers to create a list of capabilities supported by the server in the session.
    pub fn server_capabilities(&self, session: &ISession) -> ServerCapabilities {
        let mut out = BTreeMap::new();
        for (urn, cap) in session.capabilities.iter() {
            if let Some(entry) = self.0.get(urn) {
                out.insert(urn.clone(), (entry.parser)(cap));
            };
        }
        ServerCapabilities(out)
    }
}

/// The backing datatype in the CapabilityCollection trait.
pub type CapabilityMap = BTreeMap<String, Box<dyn CapabilityDyn>>;

/// Trait for list of capabilities, or any URN -> Capabilty collection
pub trait CapabilityCollection {
    fn inner(&self) -> &CapabilityMap;
    fn inner_mut(&mut self) -> &mut CapabilityMap;

    fn get_capability<T: Capability>(&self) -> Option<&T> {
        self.inner().get(T::URN)?.as_any().downcast_ref::<T>()
    }

    fn get_capability_mut<T: Capability>(&mut self) -> Option<&mut T> {
        self.inner_mut()
            .get_mut(T::URN)?
            .as_any_mut()
            .downcast_mut::<T>()
    }
}

/// Collection
pub struct ServerCapabilities(pub CapabilityMap);

impl CapabilityCollection for ServerCapabilities {
    fn inner(&self) -> &CapabilityMap {
        &self.0
    }

    fn inner_mut(&mut self) -> &mut CapabilityMap {
        &mut self.0
    }
}

impl std::fmt::Debug for ServerCapabilities {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_tuple("ServerCapabilities")
            .field(&self.0.keys().collect::<Vec<&String>>())
            .finish()
    }
}

impl ServerCapabilities {
    /// Evaluate AccountCapabilities using this list of capabilities and the intermediate session
    pub fn account_capabilities(
        &self,
        client: &JMAPId,
        session: &ISession,
    ) -> Option<AccountCapabilities> {
        session.accounts.get(client).map(|acc| {
            let mut out = BTreeMap::new();
            let empty = JObj::new();
            for (urn, scap) in self.0.iter() {
                let ccap = acc.accountCapabilities.get(urn).unwrap_or(&empty);
                out.insert(urn.clone(), scap.account_cap_dyn(client.clone(), ccap));
            }
            AccountCapabilities(out)
        })
    }
}

/// List of capabilities, specific to an account.
pub struct AccountCapabilities(pub CapabilityMap);

impl std::fmt::Debug for AccountCapabilities {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_tuple("AccountCapabilities")
            .field(&self.0.keys().collect::<Vec<&String>>())
            .finish()
    }
}
impl CapabilityCollection for AccountCapabilities {
    fn inner(&self) -> &CapabilityMap {
        &self.0
    }

    fn inner_mut(&mut self) -> &mut CapabilityMap {
        &mut self.0
    }
}

// }}}
/// JMAP Core capability as outlined in RFC 8620
pub struct CoreEchoArgs {
    pub obj: JObject,
}

impl JMAPInvocationArg for CoreEchoArgs {
    const CAP_URN: &str = URN_JMAP_CORE;

    const METHOD_HINT: &str = "Core/Echo";

    fn from_obj(obj: &JObject) -> JMAPResult<Self> {
        Ok(Self { obj: obj.clone() })
    }

    fn into_obj(self) -> JMAPResult<JObject> {
        Ok(self.obj)
    }
}

#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Clone)]
pub struct JMAPCoreCapability {
    pub maxSizeUpload: JUint,
    pub maxConcurrentUpload: JUint,
    pub maxSizeRequest: JUint,
    pub maxConcurrentRequests: JUint,
    pub maxCallsInRequest: JUint,
    pub maxObjectsInGet: JUint,
    pub maxObjectsInSet: JUint,
    pub collationAlgorithms: JArr<String>,
    #[serde(skip)]
    accountId: Option<JMAPId>,
}

impl Capability for JMAPCoreCapability {
    const URN: &str = URN_JMAP_CORE;

    fn from_object(obj: &JObject) -> Self {
        // TODO: Unwrap
        let out: Self = serde_json::from_value(JUnknown::Object(obj.clone()).into()).unwrap();
        out
    }

    fn get_methods() -> &'static MethodRegistry {
        &JMAP_CORE_METHODS
    }

    fn account_cap(&self, account_id: JMAPId, _: &JObject) -> Self {
        let mut out = self.clone();
        out.accountId = Some(account_id);
        out
    }

    fn account(&self) -> Option<JMAPId> {
        self.accountId.clone()
    }
}

// }}}