nostralink 0.2.4

//! RDF Result sets

use super::vars as Vars;
use crate::err::LDError;
use language::Language;
use nostr::{
    event::EventId, types::url::Error as RelayUrlError,
    types::url::ParseError as RelayUrlParseError, PublicKey, RelayUrl,
    Timestamp,
};
use oxigraph::model::{IriParseError, NamedNode};
use oxiri::Iri;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::convert::TryInto;
use std::fmt;
use std::marker::PhantomData;
use std::time::SystemTime;
use url::Url;

// Extracts/converts values from a RdfResultRow
pub trait RowExtractor {
    fn event_id(&self) -> Result<EventId, nostr::event::Error> {
        Err(nostr::event::Error::InvalidId)
    }

    fn event_id_from_var(
        &self,
        _field: &str,
    ) -> Result<EventId, nostr::event::Error> {
        Err(nostr::event::Error::InvalidId)
    }

    fn public_key(&self) -> Result<PublicKey, nostr::key::Error> {
        Err(nostr::key::Error::InvalidPublicKey)
    }

    fn seen_at(&self) -> Option<Timestamp> {
        None
    }

    fn content_type(&self) -> Option<String> {
        None
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum RdfCellValue {
    Int(i32),
    UnsignedInt(u32),
    Float(f64),
    Text(String),
    Node(String),
    Blank(),
}

impl TryInto<i32> for RdfCellValue {
    type Error = ();

    fn try_into(self) -> Result<i32, Self::Error> {
        match self {
            RdfCellValue::Int(value) => Ok(value),
            _ => todo!(),
        }
    }
}

impl TryInto<u64> for RdfCellValue {
    type Error = &'static str;

    fn try_into(self) -> Result<u64, Self::Error> {
        match self {
            RdfCellValue::Int(value) => {
                let v: u64 = value as u64;
                Ok(v)
            }
            _ => todo!(),
        }
    }
}

impl TryInto<PublicKey> for RdfCellValue {
    type Error = nostr::key::Error;

    fn try_into(self) -> Result<PublicKey, Self::Error> {
        match self {
            RdfCellValue::Text(value) => Ok(PublicKey::parse(&value)?),
            _ => Err(Self::Error::InvalidPublicKey),
        }
    }
}

impl fmt::Display for RdfCellValue {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            RdfCellValue::Int(value) => {
                write!(f, "{}", value)
            }
            RdfCellValue::Float(value) => {
                write!(f, "{}", value)
            }
            RdfCellValue::Text(value) => {
                write!(f, "{}", value)
            }
            RdfCellValue::Node(value) => {
                write!(f, "{}", value)
            }
            _ => {
                write!(f, "NA")
            }
        }
    }
}

impl RdfCellValue {
    pub fn to_named_node(&self) -> Result<NamedNode, IriParseError> {
        match self {
            RdfCellValue::Node(value) => {
                Ok(NamedNode::from(Iri::parse(value.to_string())?))
            }
            RdfCellValue::Text(value) => {
                Ok(NamedNode::from(Iri::parse(value.to_string())?))
            }
            _ => todo!(),
        }
    }
    pub fn to_event_id(&self) -> Result<EventId, nostr::event::Error> {
        match self {
            RdfCellValue::Text(value) => Ok(EventId::parse(value)?),
            _ => Err(nostr::event::Error::InvalidId),
        }
    }
    pub fn to_public_key(&self) -> Result<PublicKey, nostr::key::Error> {
        match self {
            RdfCellValue::Text(value) => Ok(PublicKey::parse(value)?),
            _ => Err(nostr::key::Error::InvalidPublicKey),
        }
    }

    pub fn to_language(&self) -> Result<Language, Box<dyn std::error::Error>> {
        match self {
            RdfCellValue::Text(value) => {
                match Language::from_tag(value.as_str()) {
                    Some(lang) => Ok(lang),
                    None => Err(Box::from("No such language")),
                }
            }
            _ => Err(Box::from("Invalid cell")),
        }
    }
}

impl TryInto<i32> for RdfCell {
    type Error = ();

    fn try_into(self) -> Result<i32, Self::Error> {
        self.value.try_into()
    }
}

impl TryInto<u64> for RdfCell {
    type Error = &'static str;

    fn try_into(self) -> Result<u64, Self::Error> {
        self.value.try_into()
    }
}

impl TryInto<String> for &RdfCell {
    type Error = &'static str;

    fn try_into(self) -> Result<String, Self::Error> {
        Ok(format!("{}", self.value))
    }
}

impl TryInto<Timestamp> for &RdfCell {
    type Error = LDError;

    fn try_into(self) -> Result<Timestamp, Self::Error> {
        match self.value {
            RdfCellValue::Int(value) => Ok(Timestamp::from_secs(
                value
                    .try_into()
                    .map_err(|_| LDError::InvalidTimestampError)?,
            )),
            _ => Err(LDError::CellValueError),
        }
    }
}

impl TryInto<PublicKey> for &RdfCell {
    type Error = nostr::key::Error;

    fn try_into(self) -> Result<PublicKey, Self::Error> {
        match &self.value {
            RdfCellValue::Text(value) => Ok(PublicKey::parse(value)?),
            _ => Err(Self::Error::InvalidPublicKey),
        }
    }
}

impl TryInto<RelayUrl> for &RdfCell {
    type Error = RelayUrlError;

    fn try_into(self) -> Result<RelayUrl, Self::Error> {
        match &self.value {
            RdfCellValue::Text(value) => {
                let vals = value.to_string();
                Ok(RelayUrl::parse(vals.as_str())?)
            }
            _ => Err(RelayUrlError::Url(RelayUrlParseError::EmptyHost)),
        }
    }
}

impl RdfCell {
    pub fn new(name: String, value: RdfCellValue) -> Self {
        Self { name, value }
    }

    pub fn new_text(name: &str, s: String) -> Self {
        Self {
            name: name.to_string(),
            value: RdfCellValue::Text(s),
        }
    }

    pub fn to_string(&self) -> String {
        format!("{}", self.value)
    }

    pub fn to_int(&self) -> Option<i32> {
        match self.value {
            RdfCellValue::Int(value) => Some(value),
            _ => None,
        }
    }

    pub fn to_float(&self) -> Option<f64> {
        match self.value {
            RdfCellValue::Float(value) => Some(value),
            _ => None,
        }
    }

    pub fn to_unsigned_int(&self) -> Option<u32> {
        match self.value {
            RdfCellValue::Int(value) => Some(value as u32),
            RdfCellValue::UnsignedInt(value) => Some(value),
            _ => None,
        }
    }

    pub fn to_ts(&self) -> Result<Timestamp, LDError> {
        match self.value {
            RdfCellValue::Int(value) => Ok(Timestamp::from_secs(
                value
                    .try_into()
                    .map_err(|_| LDError::InvalidTimestampError)?,
            )),
            _ => Err(LDError::CellValueError),
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RdfCell {
    pub name: String,
    pub value: RdfCellValue,
}

pub type RdfResultRow = HashMap<String, RdfCell>;

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TRdfResultRow<T>(pub HashMap<String, RdfCell>, pub PhantomData<T>)
where
    T: std::clone::Clone;

impl<T: std::clone::Clone> From<TRdfResultRow<T>> for RdfResultRow {
    fn from(row: TRdfResultRow<T>) -> Self {
        row.0
    }
}

pub const CONCAT_SEP: &str = ",";

impl<T: std::clone::Clone> TRdfResultRow<T> {
    // Commonly used SparQL variable names

    pub fn get(&self, key: &str) -> Option<&RdfCell> {
        self.0.get(key)
    }

    pub fn get_string(&self, key: &str) -> Option<String> {
        self.0.get(key).map(|cell| cell.to_string())
    }

    pub fn get_i32(&self, key: &str) -> Option<i32> {
        self.0.get(key).and_then(|cell| cell.to_int())
    }

    pub fn get_u32(&self, key: &str) -> Option<u32> {
        self.0.get(key).and_then(|cell| cell.to_unsigned_int())
    }

    pub fn get_float(&self, key: &str) -> Option<f64> {
        self.0.get(key).and_then(|cell| cell.to_float())
    }

    pub fn get_ts(&self, key: &str) -> Option<Timestamp> {
        self.0.get(key).and_then(|cell| cell.try_into().ok())
    }

    pub fn get_node(&self, key: &str) -> Option<NamedNode> {
        self.0
            .get(key)
            .and_then(|cell| cell.value.to_named_node().ok())
    }

    pub fn get_url(&self, key: &str) -> Option<Url> {
        self.0
            .get(key)
            .and_then(|cell| Url::parse(&cell.to_string()).ok())
    }

    /// Deconcat a key to a vec of strings
    pub fn deconcat(
        &self,
        key: &str,
        sep: Option<&str>,
        dedup: bool,
    ) -> Option<Vec<String>> {
        if let Some(cell) = self.0.get(key) {
            let mut values: Vec<String> = cell
                .to_string()
                .split(sep.unwrap_or(CONCAT_SEP))
                .map(str::to_string)
                .collect();

            if dedup {
                values.sort_unstable();
                values.dedup();
            }
            Some(values)
        } else {
            None
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RdfResultSet {
    pub when: SystemTime,
    pub column_headings: Vec<String>,
    pub rows: Vec<RdfResultRow>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TRdfResultSet<T: std::clone::Clone> {
    pub when: SystemTime,
    pub rows: Vec<TRdfResultRow<T>>,
}

impl<T: std::clone::Clone> From<RdfResultRow> for TRdfResultRow<T> {
    fn from(val: RdfResultRow) -> Self {
        TRdfResultRow::<T>(val, PhantomData)
    }
}

impl<T: std::clone::Clone> From<RdfResultSet> for TRdfResultSet<T> {
    fn from(val: RdfResultSet) -> Self {
        TRdfResultSet::<T> {
            when: val.when,
            rows: val.rows.iter().map(|r| r.clone().into()).collect(),
        }
    }
}

impl<T: std::clone::Clone> TRdfResultSet<T> {
    pub fn count(&self) -> usize {
        self.rows.len()
    }

    /// Returns the first row
    pub fn first(&self) -> Option<TRdfResultRow<T>> {
        if self.count() > 0 {
            return Some(self.rows[0].clone());
        }

        None
    }
}

impl RdfResultSet {
    pub fn count(&self) -> usize {
        self.rows.len()
    }

    /// Returns the first row
    pub fn first(&self) -> Option<RdfResultRow> {
        if self.count() > 0 {
            return Some(self.rows[0].clone());
        }

        None
    }
}

impl<T: std::clone::Clone> RowExtractor for TRdfResultRow<T> {
    fn event_id(&self) -> Result<EventId, nostr::event::Error> {
        self.event_id_from_var(Vars::RP_EVENT_ID)
            .or(self.event_id_from_var(Vars::EVENT_ID))
    }

    fn event_id_from_var(
        &self,
        var: &str,
    ) -> Result<EventId, nostr::event::Error> {
        match self.get(var) {
            Some(ev_id) => Ok(ev_id.value.to_event_id()?),
            None => Err(nostr::event::Error::InvalidId),
        }
    }

    fn public_key(&self) -> Result<PublicKey, nostr::key::Error> {
        match self.get(Vars::PUBK) {
            Some(pubk) => Ok(pubk.value.to_public_key()?),
            None => Err(nostr::key::Error::InvalidPublicKey),
        }
    }

    /// Returns the timestamp of the time this event was seen
    fn seen_at(&self) -> Option<Timestamp> {
        match self.get(Vars::EVENT_SEEN_AT) {
            Some(cell) => cell.try_into().ok(),
            None => None,
        }
    }

    fn content_type(&self) -> Option<String> {
        self.get(Vars::CONTENT_TYPE).map(|cell| cell.to_string())
    }
}