use anyhow::Result;
use base64::Engine;
use log::info;
use nostr_sdk::{serde_json, EventBuilder, JsonUtil, Kind, NostrSigner, Tag, Timestamp};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::collections::HashMap;
use std::io::SeekFrom;
use std::ops::Add;
use std::path::PathBuf;
use tokio::fs::File;
use tokio::io::{AsyncReadExt, AsyncSeekExt};
use url::Url;

#[derive(Debug, Clone)]
pub struct Blossom {
    url: Url,
    client: reqwest::Client,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlobDescriptor {
    pub url: String,
    pub sha256: String,
    pub size: u64,
    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<String>,
    pub uploaded: u64,
    #[serde(rename = "nip94", skip_serializing_if = "Option::is_none")]
    pub nip94: Option<HashMap<String, String>>,
}

impl Blossom {
    pub fn new(url: &str) -> Self {
        Self {
            url: url.parse().unwrap(),
            client: reqwest::Client::new(),
        }
    }

    async fn hash_file(f: &mut File) -> Result<String> {
        let mut hash = Sha256::new();
        let mut buf: [u8; 1024] = [0; 1024];
        f.seek(SeekFrom::Start(0)).await?;
        while let Ok(data) = f.read(&mut buf[..]).await {
            if data == 0 {
                break;
            }
            hash.update(&buf[..data]);
        }
        let hash = hash.finalize();
        f.seek(SeekFrom::Start(0)).await?;
        Ok(hex::encode(hash))
    }

    pub async fn upload<S>(
        &self,
        from_file: &PathBuf,
        keys: &S,
        mime: Option<&str>,
    ) -> Result<BlobDescriptor>
    where
        S: NostrSigner,
    {
        let mut f = File::open(from_file).await?;
        let hash = Self::hash_file(&mut f).await?;
        let auth_event = EventBuilder::new(Kind::Custom(24242), "Upload blob").tags([
            Tag::hashtag("upload"),
            Tag::parse(["x", &hash])?,
            Tag::expiration(Timestamp::now().add(60)),
        ]);

        let auth_event = auth_event.sign(keys).await?;

        let rsp = self
            .client
            .put(self.url.join("/upload").unwrap())
            .header("Content-Type", mime.unwrap_or("application/octet-stream"))
            .header(
                "Authorization",
                &format!(
                    "Nostr {}",
                    base64::engine::general_purpose::STANDARD
                        .encode(auth_event.as_json().as_bytes())
                ),
            )
            .body(f)
            .send()
            .await?
            .text()
            .await?;

        info!("Upload response: {}", rsp);

        Ok(serde_json::from_str::<BlobDescriptor>(&rsp)?)
    }
}