use std::path::PathBuf;

use base64::Engine;
use rand::RngCore;
use serde::{Deserialize, Serialize};

use crate::security::is_valid_key;

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileMeta {
    pub id: String,
    pub original_name: String,
    pub size: u64,
    pub mime_type: String,
    pub download_key_hash: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password_hash: Option<String>,
    pub created_at: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
}

pub fn is_expired(meta: &FileMeta, now_ms: i64) -> bool {
    match &meta.expires_at {
        Some(s) => chrono::DateTime::parse_from_rfc3339(s)
            .map(|dt| dt.timestamp_millis() <= now_ms)
            .unwrap_or(false),
        None => false,
    }
}

pub struct Storage {
    root: PathBuf,
    files_dir: PathBuf,
    metadata_dir: PathBuf,
}

impl Storage {
    pub fn new(root: PathBuf) -> Self {
        let files_dir = root.join("files");
        let metadata_dir = root.join("metadata");
        Self {
            root,
            files_dir,
            metadata_dir,
        }
    }

    pub async fn init(&self) -> std::io::Result<()> {
        tokio::fs::create_dir_all(&self.files_dir).await?;
        tokio::fs::create_dir_all(&self.metadata_dir).await?;
        Ok(())
    }

    pub async fn load_secret(&self) -> std::io::Result<String> {
        let path = self.root.join(".secret");
        if let Ok(existing) = tokio::fs::read_to_string(&path).await {
            let existing = existing.trim().to_string();
            if !existing.is_empty() {
                return Ok(existing);
            }
        }

        let mut bytes = [0u8; 32];
        rand::rngs::OsRng.fill_bytes(&mut bytes);
        let secret = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(bytes);

        #[cfg(unix)]
        {
            use std::io::Write;
            use std::os::unix::fs::OpenOptionsExt;
            let mut opts = std::fs::OpenOptions::new();
            opts.write(true).create_new(true).mode(0o600);
            let mut f = opts.open(&path)?;
            f.write_all(secret.as_bytes())?;
        }
        #[cfg(not(unix))]
        {
            tokio::fs::write(&path, &secret).await?;
        }
        Ok(secret)
    }

    pub fn file_path(&self, id: &str) -> PathBuf {
        self.files_dir.join(id)
    }

    pub fn part_path(&self, id: &str) -> PathBuf {
        self.files_dir.join(format!("{id}.part"))
    }

    fn meta_path(&self, id: &str) -> PathBuf {
        self.metadata_dir.join(format!("{id}.json"))
    }

    pub async fn storage_usage_ratio(&self) -> f64 {
        match nix::sys::statvfs::statvfs(&self.root) {
            Ok(stats) => {
                let total = stats.blocks() * stats.fragment_size();
                let avail = stats.blocks_available() * stats.fragment_size();
                if total == 0 {
                    return 0.0;
                }
                let ratio = 1.0 - (avail as f64 / total as f64);
                ratio.clamp(0.0, 1.0)
            }
            Err(_) => 0.0,
        }
    }

    pub async fn write_metadata(&self, meta: &FileMeta) -> std::io::Result<()> {
        let target = self.meta_path(&meta.id);
        let tmp = self.metadata_dir.join(format!("{}.json.tmp", meta.id));
        let body = serde_json::to_string_pretty(meta)
            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
        tokio::fs::write(&tmp, format!("{body}\n")).await?;
        tokio::fs::rename(&tmp, &target).await
    }

    pub async fn read_metadata(&self, id: &str) -> Option<FileMeta> {
        if !is_valid_key(id) {
            return None;
        }
        let raw = tokio::fs::read_to_string(self.meta_path(id)).await.ok()?;
        let meta: FileMeta = serde_json::from_str(&raw).ok()?;
        if meta.id.is_empty() || meta.download_key_hash.is_empty() {
            return None;
        }
        Some(meta)
    }

    pub async fn delete(&self, id: &str) {
        let _ = tokio::fs::remove_file(self.file_path(id)).await;
        let _ = tokio::fs::remove_file(self.meta_path(id)).await;
    }

    pub async fn delete_partial(&self, id: &str) {
        let _ = tokio::fs::remove_file(self.part_path(id)).await;
    }

    pub async fn expire_expired(&self, now_ms: i64) -> usize {
        let mut removed = 0;
        let Ok(mut entries) = tokio::fs::read_dir(&self.metadata_dir).await else {
            return 0;
        };
        while let Ok(Some(entry)) = entries.next_entry().await {
            let name = entry.file_name();
            let name = name.to_string_lossy();
            if !name.ends_with(".json") {
                continue;
            }
            let id = &name[..name.len() - 5];
            if !is_valid_key(id) {
                continue;
            }
            if let Some(meta) = self.read_metadata(id).await {
                if is_expired(&meta, now_ms) {
                    self.delete(id).await;
                    removed += 1;
                }
            }
        }
        removed
    }

    /// Consistency repair: remove orphans (file without metadata, metadata
    /// without file, leftover `.part` files). Never touches valid pairs.
    pub async fn sweep(&self) -> (usize, usize) {
        let mut removed_files = 0;
        let mut removed_metadata = 0;

        if let Ok(mut entries) = tokio::fs::read_dir(&self.files_dir).await {
            while let Ok(Some(entry)) = entries.next_entry().await {
                let name = entry.file_name();
                let name = name.to_string_lossy().to_string();
                if name.ends_with(".part") || !is_valid_key(&name) {
                    let _ = tokio::fs::remove_file(entry.path()).await;
                    removed_files += 1;
                    continue;
                }
                if tokio::fs::metadata(self.metadata_dir.join(format!("{name}.json")))
                    .await
                    .is_err()
                {
                    let _ = tokio::fs::remove_file(entry.path()).await;
                    removed_files += 1;
                }
            }
        }

        if let Ok(mut entries) = tokio::fs::read_dir(&self.metadata_dir).await {
            while let Ok(Some(entry)) = entries.next_entry().await {
                let name = entry.file_name();
                let name = name.to_string_lossy().to_string();
                if !name.ends_with(".json") {
                    let _ = tokio::fs::remove_file(entry.path()).await;
                    removed_metadata += 1;
                    continue;
                }
                let id = &name[..name.len() - 5];
                if !is_valid_key(id) {
                    let _ = tokio::fs::remove_file(entry.path()).await;
                    removed_metadata += 1;
                    continue;
                }
                if tokio::fs::metadata(self.files_dir.join(id)).await.is_err() {
                    let _ = tokio::fs::remove_file(entry.path()).await;
                    removed_metadata += 1;
                }
            }
        }

        (removed_files, removed_metadata)
    }
}