path: root/filamento/src/error.rs

use std::{num::TryFromIntError, string::FromUtf8Error, sync::Arc};

use base64::DecodeError;
use image::ImageError;
use jid::JID;
use lampada::error::{ActorError, ReadError, WriteError};
use stanza::client::{Stanza, iq::Query};
use thiserror::Error;

pub use lampada::error::CommandError;
pub use lampada::error::ConnectionError;
use tokio::sync::mpsc::error::SendError;
use tokio::sync::oneshot::error::RecvError;

use crate::db::DbCommand;
use crate::files::FileStore;

// for the client logic impl
#[derive(Debug, Error, Clone)]
pub enum Error<Fs: FileStore> {
    #[error("core error: {0}")]
    Connection(#[from] ConnectionError),
    #[error("received unrecognized/unsupported content")]
    UnrecognizedContent,
    // TODO: include content
    // UnrecognizedContent(peanuts::element::Content),
    #[error("iq receive error: {0}")]
    Iq(#[from] IqProcessError),
    // TODO: change to Connecting(ConnectingError)
    #[error("connecting: {0}")]
    Connecting(#[from] ConnectionJobError),
    #[error("presence: {0}")]
    Presence(#[from] PresenceError),
    #[error("set status: {0}")]
    SetStatus(#[from] StatusError),
    // TODO: have different ones for get/update/set
    #[error("roster: {0}")]
    Roster(#[from] RosterError),
    #[error("stream error: {0}")]
    Stream(#[from] stanza::stream::Error),
    #[error("message send error: {0}")]
    MessageSend(#[from] MessageSendError),
    #[error("message receive error: {0}")]
    MessageRecv(#[from] MessageRecvError<Fs>),
    #[error("subscripbe error: {0}")]
    Subscribe(#[from] SubscribeError),
    #[error("publish error: {0}")]
    Publish(#[from] PEPError),
}

#[derive(Debug, Error, Clone)]
pub enum MessageSendError {
    #[error("could not add to message history: {0}")]
    MessageHistory(#[from] DatabaseError),
    #[error("could not mark chat as chatted: {0}")]
    MarkChatAsChatted(DatabaseError),
    #[error("could not get client user details: {0}")]
    GetUserDetails(DatabaseError),
    #[error("writing message to connection: {0}")]
    Write(#[from] WriteError),
}

#[derive(Debug, Error, Clone)]
pub enum MessageRecvError<Fs: FileStore> {
    #[error("could not add to message history: {0}")]
    MessageHistory(#[from] DatabaseError),
    #[error("missing from")]
    MissingFrom,
    #[error("could not update user nick: {0}")]
    NickUpdate(DatabaseError),
    #[error("could not update user avatar: {0}")]
    AvatarUpdate(#[from] AvatarUpdateError<Fs>),
}

#[derive(Debug, Error, Clone)]
pub enum AvatarUpdateError<Fs: FileStore> {
    #[error("could not save to disk: {0}")]
    FileStore(Fs::Err),
    #[error("could not fetch avatar data: {0}")]
    PEPError(#[from] CommandError<PEPError>),
    #[error("base64 decode: {0}")]
    Base64(#[from] DecodeError),
    #[error("pep node missing avatar data")]
    MissingData,
    #[error("database: {0}")]
    Database(#[from] DatabaseError),
}

#[derive(Debug, Error, Clone)]
pub enum StatusError {
    #[error("cache: {0}")]
    Cache(#[from] DatabaseError),
    #[error("stream write: {0}")]
    Write(#[from] WriteError),
}

#[derive(Debug, Clone, Error)]
pub enum ConnectionJobError {
    // #[error("connection failed: {0}")]
    // ConnectionFailed(#[from] luz::Error),
    #[error("failed roster retreival: {0}")]
    RosterRetreival(#[from] RosterError),
    #[error("failed to send available presence: {0}")]
    SendPresence(#[from] WriteError),
    #[error("cached status: {0}")]
    StatusCacheError(#[from] DatabaseError),
}

#[derive(Debug, Error, Clone)]
pub enum RosterError {
    #[error("cache: {0}")]
    Cache(#[from] DatabaseError),
    #[error("iq response: {0}")]
    IqResponse(#[from] IqRequestError),
    #[error("stream write: {0}")]
    Write(#[from] WriteError),
    // TODO: display for stanza, to show as xml, same for read error types.
    #[error("unexpected reply: {0:?}")]
    UnexpectedStanza(Stanza),
    #[error("stanza error: {0}")]
    StanzaError(#[from] stanza::client::error::Error),
    #[error("could not reply to roster push: {0}")]
    PushReply(WriteError),
    #[error("actor error: {0}")]
    Actor(ActorError),
}

impl From<CommandError<RosterError>> for RosterError {
    fn from(value: CommandError<RosterError>) -> Self {
        match value {
            CommandError::Actor(actor_error) => Self::Actor(actor_error),
            CommandError::Error(e) => e,
        }
    }
}

#[derive(Debug, Error, Clone)]
pub enum DiscoError {
    #[error("write error: {0}")]
    Write(#[from] WriteError),
    #[error("iq response: {0}")]
    IqResponse(#[from] IqRequestError),
    #[error("reply from incorrect entity: {0}")]
    IncorrectEntity(JID),
    #[error("unexpected reply: {0:?}")]
    UnexpectedStanza(Stanza),
    #[error("stanza error: {0}")]
    StanzaError(#[from] stanza::client::error::Error),
    #[error("disco result missing query item")]
    MissingQuery,
    #[error("disco error missing error")]
    MissingError,
    #[error("received mismatched query")]
    MismatchedQuery(Query),
}

#[derive(Debug, Error, Clone)]
pub enum IqRequestError {
    #[error("sending request: {0}")]
    Write(#[from] WriteError),
    #[error("receiving expected response: {0}")]
    Read(#[from] ReadError),
}

#[derive(Debug, Error, Clone)]
pub enum ResponseError {
    #[error("no matching id: {0}")]
    NoMatchingId(String),
}

#[derive(Debug, Error, Clone)]
pub enum DatabaseError {
    #[error("database error: {0}")]
    Database(Serializeable<Arc<rusqlite::Error>>),
    #[error("database command send: {0}")]
    Send(Arc<SendError<DbCommand>>),
    #[error("database result recv: {0}")]
    Recv(#[from] RecvError),
}

impl From<SendError<DbCommand>> for DatabaseError {
    fn from(e: SendError<DbCommand>) -> Self {
        Self::Send(Arc::new(e))
    }
}

pub enum Serializeable<T> {
    String(String),
    Unserialized(T),
}

impl<T: std::fmt::Display> std::fmt::Display for Serializeable<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self {
            Serializeable::String(s) => s.fmt(f),
            Serializeable::Unserialized(t) => t.fmt(f),
        }
    }
}

impl<T: std::fmt::Debug> std::fmt::Debug for Serializeable<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self {
            Serializeable::String(s) => s.fmt(f),
            Serializeable::Unserialized(t) => t.fmt(f),
        }
    }
}

impl<T: Clone> Clone for Serializeable<T> {
    fn clone(&self) -> Self {
        match self {
            Serializeable::String(s) => Self::String(s.clone()),
            Serializeable::Unserialized(t) => Self::Unserialized(t.clone()),
        }
    }
}

#[cfg(feature = "serde")]
struct StringVisitor;

#[cfg(feature = "serde")]
impl<'de> serde::de::Visitor<'de> for StringVisitor {
    type Value = String;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("a string")
    }

    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        Ok(v)
    }
}

#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for DatabaseError {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let string = deserializer.deserialize_string(StringVisitor)?;
        Ok(Self::Database(Serializeable::String(string)))
    }
}

#[cfg(feature = "serde")]
impl serde::Serialize for DatabaseError {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match &self.0 {
            Serializeable::String(s) => serializer.serialize_str(s),
            Serializeable::Unserialized(u) => serializer.serialize_str(&u.to_string()),
        }
    }
}

impl From<rusqlite::Error> for DatabaseError {
    fn from(e: rusqlite::Error) -> Self {
        Self::Database(Serializeable::Unserialized(Arc::new(e)))
    }
}

impl From<rusqlite::Error> for DatabaseOpenError {
    fn from(e: rusqlite::Error) -> Self {
        Self::Error(Arc::new(e))
    }
}

#[derive(Debug, Error, Clone)]
// TODO: should probably have all iq query related errors here, including read, write, stanza error, etc.
pub enum IqError {
    #[error("writing response: {0}")]
    WriteError(#[from] WriteError),
    #[error("receiving response: `{0}`")]
    ReceivedResponse(#[from] ResponseError),
    #[error("incorrect addressee: {0}")]
    IncorrectAddressee(jid::JID),
}

#[derive(Debug, Error, Clone)]
pub enum IqProcessError {
    #[error("iq error")]
    Iq(#[from] IqError),
    #[error("roster push")]
    Roster(#[from] RosterError),
}

#[derive(Debug, Error, Clone)]
pub enum DatabaseOpenError {
    #[error("error: {0}")]
    Error(Arc<rusqlite::Error>),
    // #[error("migration: {0}")]
    // Migration(Arc<rusqlite::migrate::MigrateError>),
    #[error("io: {0}")]
    Io(Arc<tokio::io::Error>),
    #[error("invalid path")]
    InvalidPath,
    #[error("tokio oneshot recv error: {0}")]
    Recv(#[from] tokio::sync::oneshot::error::RecvError),
}

// impl From<sqlx::migrate::MigrateError> for DatabaseOpenError {
//     fn from(e: sqlx::migrate::MigrateError) -> Self {
//         Self::Migration(Arc::new(e))
//     }
// }

impl From<tokio::io::Error> for DatabaseOpenError {
    fn from(e: tokio::io::Error) -> Self {
        Self::Io(Arc::new(e))
    }
}

#[derive(Debug, Error, Clone)]
pub enum SubscribeError {
    #[error("write: {0}")]
    Write(#[from] WriteError),
    #[error("fetching client user details: {0}")]
    Database(#[from] DatabaseError),
}

#[derive(Debug, Error, Clone)]
pub enum PresenceError {
    #[error("unsupported")]
    Unsupported,
    #[error("missing from")]
    MissingFrom,
    #[error("stanza error: {0}")]
    StanzaError(#[from] stanza::client::error::Error),
}

#[derive(Debug, Error, Clone)]
pub enum PEPError {
    #[error("received mismatched query")]
    MismatchedQuery(Query),
    #[error("missing query")]
    MissingQuery,
    #[error("stanza errors: {0:?}")]
    StanzaErrors(Vec<stanza::client::error::Error>),
    #[error("reply from incorrect entity: {0}")]
    IncorrectEntity(JID),
    #[error("unexpected stanza: {0:?}")]
    UnexpectedStanza(Stanza),
    #[error("iq response: {0}")]
    IqResponse(#[from] IqRequestError),
    #[error("missing pep item")]
    MissingItem,
    #[error("incorrect item id: expected {0}, got {1}")]
    IncorrectItemID(String, String),
    #[error("unsupported pep item")]
    UnsupportedItem,
    // TODO: should the item be in the error?
}

#[derive(Debug, Error, Clone)]
pub enum NickError {
    #[error("publishing nick: {0}")]
    Publish(#[from] CommandError<PEPError>),
    #[error("updating database: {0}")]
    Database(#[from] DatabaseError),
    #[error("disconnected")]
    Disconnected,
}

#[derive(Debug, Error, Clone)]
pub enum CapsDecodeError {
    #[error("base64 decode: {0}")]
    Base64Decode(#[from] base64::DecodeError),
    #[error("utf8: {0}")]
    UTF8(#[from] FromUtf8Error),
    #[error("missing features")]
    MissingFeatures,
    #[error("missing identities")]
    MissingIdentities,
    #[error("missing identity category")]
    MissingIdentityCategory,
    #[error("missing identity type")]
    MissingIdentityType,
    #[error("missing identity language")]
    MissingIdentityLang,
    #[error("missing identity name")]
    MissingIdentityName,
}

#[derive(Debug, Error, Clone)]
pub enum CapsEncodeError {
    #[error("invalid data form in disco extensions")]
    InvalidDataForm,
}

#[derive(Debug, Error, Clone)]
pub enum HashNodeConversionError {
    #[error("no prefix")]
    NoPrefix,
    #[error("missing period")]
    MissingPeriod,
}

#[derive(Debug, Error, Clone)]
pub enum CapsNodeConversionError {
    #[error("missing hashtag")]
    MissingHashtag,
}

#[derive(Debug, Error, Clone)]
pub enum AvatarPublishError<Fs: FileStore> {
    #[error("disconnected")]
    Disconnected,
    #[error("image read: {0}")]
    Read(Arc<std::io::Error>),
    #[error("image: {0}")]
    Image(Arc<ImageError>),
    #[error("pep publish: {0}")]
    Publish(#[from] CommandError<PEPError>),
    #[error("bytes number conversion: {0}")]
    FromInt(#[from] TryFromIntError),
    #[error("could not save to disk")]
    FileStore(Fs::Err),
}

impl<Fs: FileStore> From<std::io::Error> for AvatarPublishError<Fs> {
    fn from(value: std::io::Error) -> Self {
        Self::Read(Arc::new(value))
    }
}

impl<Fs: FileStore> From<ImageError> for AvatarPublishError<Fs> {
    fn from(value: ImageError) -> Self {
        Self::Image(Arc::new(value))
    }
}