use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::sync::Arc;
use alloc::vec::Vec;
use crate::connect::proto::{
AccessToken, ConnectionDetails, NodeDescription, NodeId, NodeIdAlias, PairingToken, TokenStore,
};
#[derive(Debug, Clone)]
pub struct PairedNode {
pub local: NodeId,
pub remote: NodeDescription,
pub tokens: TokenStore,
pub details: Option<ConnectionDetails>,
}
pub trait Store: Send + Sync + 'static {
fn pairing_token(&self, node: NodeId) -> Option<PairingToken>;
fn resolve_alias(&self, alias: &NodeIdAlias) -> Option<NodeId>;
fn sole_node(&self) -> Option<NodeId>;
fn node(&self, node: NodeId) -> Option<NodeDescription>;
fn nodes(&self) -> Vec<(NodeDescription, Option<NodeIdAlias>)>;
fn pair(&self, paired: PairedNode);
fn paired(&self, remote: NodeId) -> Option<PairedNode>;
fn paired_with(&self, local: NodeId) -> Vec<NodeId>;
fn set_tokens(&self, remote: NodeId, tokens: TokenStore);
fn unpair(&self, remote: NodeId);
fn node_for_token(&self, token: &AccessToken) -> Option<NodeId>;
}
#[derive(Debug, Default)]
pub struct Memory {
inner: std::sync::RwLock<Inner>,
}
#[derive(Debug, Default)]
struct Inner {
nodes: BTreeMap<NodeId, NodeDescription>,
aliases: BTreeMap<String, NodeId>,
tokens: BTreeMap<NodeId, PairingToken>,
pairings: BTreeMap<NodeId, PairedNode>,
}
impl Memory {
#[must_use]
pub fn new() -> Arc<Self> {
Arc::new(Self::default())
}
pub fn add_node(&self, node: NodeDescription, alias: Option<NodeIdAlias>) {
let Ok(mut inner) = self.inner.write() else {
return;
};
if let Some(alias) = alias {
inner.aliases.insert(alias.0, node.id);
}
inner.nodes.insert(node.id, node);
}
pub fn open_for_pairing(&self, node: NodeId, token: PairingToken) {
if let Ok(mut inner) = self.inner.write() {
inner.tokens.insert(node, token);
}
}
pub fn close_pairing(&self, node: NodeId) {
if let Ok(mut inner) = self.inner.write() {
inner.tokens.remove(&node);
}
}
}
impl Store for Memory {
fn pairing_token(&self, node: NodeId) -> Option<PairingToken> {
self.inner.read().ok()?.tokens.get(&node).cloned()
}
fn resolve_alias(&self, alias: &NodeIdAlias) -> Option<NodeId> {
self.inner.read().ok()?.aliases.get(&alias.0).copied()
}
fn sole_node(&self) -> Option<NodeId> {
let inner = self.inner.read().ok()?;
if inner.nodes.len() == 1 {
inner.nodes.keys().next().copied()
} else {
None
}
}
fn node(&self, node: NodeId) -> Option<NodeDescription> {
self.inner.read().ok()?.nodes.get(&node).cloned()
}
fn nodes(&self) -> Vec<(NodeDescription, Option<NodeIdAlias>)> {
let Ok(inner) = self.inner.read() else {
return Vec::new();
};
inner
.nodes
.values()
.map(|node| {
let alias = inner
.aliases
.iter()
.find(|(_, id)| **id == node.id)
.map(|(alias, _)| NodeIdAlias(alias.clone()));
(node.clone(), alias)
})
.collect()
}
fn pair(&self, paired: PairedNode) {
if let Ok(mut inner) = self.inner.write() {
inner.tokens.remove(&paired.local);
inner.pairings.insert(paired.remote.id, paired);
}
}
fn paired(&self, remote: NodeId) -> Option<PairedNode> {
self.inner.read().ok()?.pairings.get(&remote).cloned()
}
fn paired_with(&self, local: NodeId) -> Vec<NodeId> {
let Ok(inner) = self.inner.read() else {
return Vec::new();
};
inner
.pairings
.values()
.filter(|paired| paired.local == local)
.map(|paired| paired.remote.id)
.collect()
}
fn set_tokens(&self, remote: NodeId, tokens: TokenStore) {
if let Ok(mut inner) = self.inner.write()
&& let Some(paired) = inner.pairings.get_mut(&remote)
{
paired.tokens = tokens;
}
}
fn unpair(&self, remote: NodeId) {
if let Ok(mut inner) = self.inner.write() {
inner.pairings.remove(&remote);
}
}
fn node_for_token(&self, token: &AccessToken) -> Option<NodeId> {
let inner = self.inner.read().ok()?;
inner
.pairings
.values()
.find(|p| p.tokens.accepts(token))
.map(|p| p.remote.id)
}
}