use serde::{Deserialize, Serialize};

pub struct URI {
    protocol: String,
    base_url: String,
}

impl URI {
    pub fn with_protocol(protocol: impl Into<String>, base_url: impl Into<String>) -> Self {
        Self {
            protocol: protocol.into(),
            base_url: base_url.into(),
        }
    }
}

impl From<&str> for URI {
    fn from(value: &str) -> Self {
        Self::with_protocol("https", value)
    }
}

impl Into<String> for URI {
    fn into(self) -> String {
        format!("{}://{}/api/v2", self.protocol, self.base_url)
    }
}

#[derive(Serialize)]
#[allow(non_snake_case)]
pub struct NewShareRequest {
    name: Option<String>,
    validity: u32,
    description: String,
    maxViews: u32,
    password: Option<String>,
}

impl NewShareRequest {
    pub fn new(
        name: Option<impl Into<String>>,
        description: impl Into<String>,
        max_views: u32,
    ) -> Self {
        Self {
            name: name.map(Into::into),
            validity: 0,
            description: description.into(),
            maxViews: max_views,
            password: None,
        }
    }
}

#[derive(Deserialize, Debug)]
pub(super) struct NewShareResponse {
    pub success: bool,
    pub message: String,
    pub id: String,
}

#[derive(Deserialize, Debug)]
#[allow(dead_code)]
pub(super) struct NotifyShareResponse {
    pub success: bool,
    pub message: String,
}