mod api;

pub use api::{NewShareRequest, URI};
use api::{NewShareResponse, NotifyShareResponse};
use log::debug;
use std::{ffi::OsStr, fs, path::Path};
use ureq::{self, RequestBuilder};

#[derive(Debug)]
pub struct Alias {
    uri: URI,
    id: String,
}

impl Alias {
    pub fn new(uri: URI, id: impl Into<String>) -> Self {
        Self { uri, id: id.into() }
    }

    fn add_headers<B>(&self, req: RequestBuilder<B>) -> RequestBuilder<B> {
        req.header("Sharry-Alias", &self.id)
    }

    pub fn create_share(
        &self,
        http: &ureq::Agent,
        data: &NewShareRequest,
    ) -> Result<Share, ureq::Error> {
        let endpoint = self.uri.get_endpoint("alias/upload/new");

        let res = self
            .add_headers(http.post(endpoint))
            .send_json(data)?
            .body_mut()
            .read_json::<NewShareResponse>()?;

        debug!("response: {:?}", res);
        assert!(res.success);
        assert_eq!(res.message, "Share created.");

        Ok(Share {
            alias: self,
            id: res.id,
        })
    }
}

#[derive(Debug)]
pub struct Share<'t> {
    alias: &'t Alias,
    id: String,
}

impl<'t> Share<'t> {
    pub fn create_file(
        &self,
        http: &ureq::Agent,
        path: impl AsRef<OsStr> + AsRef<Path>,
    ) -> Result<(), ureq::Error> {
        let filename = Path::new(&path)
            .file_name()
            .and_then(OsStr::to_str)
            .unwrap_or("file.bin");

        let size = fs::metadata(&path)?.len();

        let endpoint = self
            .alias
            .uri
            .get_endpoint(&format!("alias/upload/{}/files/tus", &self.id));

        let res = self
            .alias
            .add_headers(http.post(endpoint))
            .header("Sharry-File-Name", filename)
            // .header("Sharry-File-Type", "application/octet-stream")
            // .header("Sharry-File-Length", size)
            // .header("Tus-Resumable", "1.0.0")
            .header("Upload-Length", size)
            .send_empty()?;

        assert_eq!(res.status(), ureq::http::StatusCode::CREATED);

        let location = res
            .headers()
            .get("Location")
            .ok_or_else(|| ureq::Error::Other("Location header not found".into()))?
            .to_str()
            .map_err(|_| ureq::Error::Other("Location header invalid".into()))?;

        debug!("location: {}", location);

        // let start = 10;
        // let count = 10;

        // let mut f = File::open(path)?;
        // f.seek(SeekFrom::Start(0));
        // let mut buf = vec![0; count];
        // f.read_exact(&mut buf)?;

        Ok(())
    }

    pub fn notify(&self, http: &ureq::Agent) -> Result<(), ureq::Error> {
        let endpoint = self
            .alias
            .uri
            .get_endpoint(&format!("alias/mail/notify/{}", &self.id));

        let res = self
            .alias
            .add_headers(http.post(endpoint))
            .send_empty()?
            .body_mut()
            .read_json::<NotifyShareResponse>()?;

        debug!("response: {:?}", res);

        Ok(())
    }
}