Gemention/src/models/mentions.rs

use async_trait::async_trait;
use fluffer::{Client, GemBytes};
use std::fmt::Display;

use crate::error::GementionError;

macro_rules! titan {
    ($self:expr) => {
        $self.client.titan.as_ref().unwrap()
    };
}

/// Wraps an incoming Titan request and provides handy methods for
/// extracting the expected information.
pub(crate) struct MentionUpload<'a> {
    client: &'a Client,
}

impl<'a> MentionUpload<'a> {
    pub fn from_client(client: &'a Client) -> Result<MentionUpload, GementionError> {
        if let Some(_) = client.titan {
            Ok(Self { client: &client })
        } else {
            Err(GementionError::NotTitanResource)
        }
    }

    pub fn content(&self) -> &[u8] {
        titan!(self).content.as_slice()
    }

    pub fn mime(&self) -> &str {
        titan!(self).mime.as_ref()
    }

    pub fn token(&self) -> Option<&str> {
        titan!(self).token.as_deref()
    }

    pub fn size(&self) -> usize {
        titan!(self).size
    }

    pub fn fingerprint(&self) -> Option<String> {
        self.client.fingerprint()
    }

    pub fn username(&self) -> Option<String> {
        self.client.name()
    }

    pub fn target(&self) -> Option<&str> {
        self.client.parameter("target")
    }
}

impl<'a> TryFrom<&'a Client> for MentionUpload<'a> {
    type Error = GementionError;

    fn try_from(client: &'a Client) -> Result<Self, Self::Error> {
        MentionUpload::from_client(client)
    }
}

#[derive(Debug)]
pub(crate) enum MentionType {
    Reply,
    Like,
}

#[derive(Debug)]
pub(crate) struct Mention {
    mention_type: MentionType,
    target: String,
    user: String,
    content: Option<String>,
}

// This is for converting an incoming Titan request into a mention. It
// is very flexible: If the incoming value matches a specific format,
// it'll accurately convert the stringi nto a proper mention.
// Otherwise, it just assumes comment. An error is returned only if
// input is not utf8.
impl TryFrom<&[u8]> for MentionType {
    type Error = GementionError;

    fn try_from(content: &[u8]) -> Result<Self, Self::Error> {
        let content = std::str::from_utf8(&content)?;
        //TODO 1st line = type (reply, like, etc) rest = comment
        // content. user should be yoinked from the incoming
        // connection. so we cannot do from &[u8]
        let content_type = content
            .lines()
            .next()
            .map(|line| line.trim().to_lowercase());

        Ok(match content_type {
            Some(value) if value == "reply" => Self::Reply,
            Some(value) if value == "like" => Self::Like,
            _ => Self::Reply,
        })
    }
}

impl<'a> TryFrom<MentionUpload<'a>> for Mention {
    type Error = GementionError;

    fn try_from(resource: MentionUpload<'a>) -> Result<Self, Self::Error> {
        if resource.mime() == "text/plain" {
            let mention_type = MentionType::try_from(resource.content())?;
            let target = resource.target().ok_or(GementionError::TargetNotProvided)?;

            Ok(Mention {
                mention_type,
                target: target.to_owned(),
                user: "".to_string(),
                content: None,
            })
        } else {
            Err(GementionError::InvalidBody)
        }
    }
}

impl Display for MentionType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Reply => write!(f, "Reply"),
            Self::Like => write!(f, "Like"),
        }
    }
}

#[async_trait]
impl GemBytes for Mention {
    async fn gem_bytes(self) -> Vec<u8> {
        // TODO change output based on mention type:
        // Reply/comment = current format.
        // Like = "<user> liked this"

        let headline = format!("## {} from {}", self.mention_type, self.user);
        let content = self.content.unwrap_or(String::from("[no content]"));

        format!("20 text/gemini\r\n{}\n\n{}", headline, content).into_bytes()
    }
}

pub(crate) struct MentionResponse {
    status: String,
}

impl MentionResponse {
    pub fn not_titan() -> MentionResponse {
        Self {
            status: "not a titan request".to_string(),
        }
    }

    pub fn verified(url: &str) -> MentionResponse {
        Self {
            status: format!("verified: {}", url),
        }
    }

    pub fn failure(reason: &str) -> MentionResponse {
        Self {
            status: format!("invalid: {}", reason),
        }
    }
}

#[async_trait]
impl GemBytes for MentionResponse {
    async fn gem_bytes(self) -> Vec<u8> {
        format!("20 text/gemini\r\n{}", self.status).into_bytes()
    }
}