use async_trait::async_trait;

pub mod file;

#[derive(Debug, Clone, Copy)]
pub enum ErrorKind {
    Backend,
    Permission,
    Conflict,
    Other,
}

#[derive(Debug)]
pub struct MediaStoreError {
    kind: ErrorKind,
    source: Option<Box<dyn std::error::Error + Send + Sync>>,
    msg: String,
}

impl std::error::Error for MediaStoreError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        self.source
            .as_ref()
            .map(|i| i.as_ref() as &dyn std::error::Error)
    }
}

impl std::fmt::Display for MediaStoreError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}: {}",
            match self.kind {
                ErrorKind::Backend => "media storage backend error",
                ErrorKind::Permission => "permission denied",
                ErrorKind::Conflict => "conflict with existing data",
                ErrorKind::Other => "unknown media storage error",
            },
            self.msg
        )
    }
}

pub type Result<T> = std::result::Result<T, MediaStoreError>;

#[async_trait]
pub trait MediaStore: 'static + Send + Sync + Clone {
    async fn write_streaming(
        &self,
        domain: url::Host,
        filename: &str,
        content: axum::extract::multipart::Field<'_>,
    ) -> Result<()>;
    async fn write(&self, domain: url::Host, filename: &str, content: &[u8]) -> Result<()>;
    async fn read_streaming(
        &self,
        domain: url::Host,
        filename: &str,
    ) -> Result<tokio_util::io::ReaderStream<Box<dyn tokio::io::AsyncRead>>>;
    async fn read(&self, domain: url::Host, filename: &str) -> Result<Vec<u8>>;
    async fn delete(&self, domain: url::Host, filename: &str) -> Result<()>;
}