//! 压缩文件解压模块
//!
//! 支持 ZIP、TAR（及其 GZ/BZ2/XZ 变体）格式的解压。
//! 7Z 和 RAR 格式暂不支持。

use std::{
    io::{Read, Write}, path::Path
};

use encoding_rs::GB18030;
use serde::Serialize;
use tempfile::NamedTempFile;
use utoipa::ToSchema;

/// 智能解码文件名：先尝试 UTF-8，发现乱码时回退到 GB18030（兼容 GBK/GB2312）
fn decode_filename(raw: &[u8]) -> String {
    // 先尝试 UTF-8
    if let Ok(utf8) = std::str::from_utf8(raw) {
        // 如果 UTF-8 解码成功且不包含替换字符，直接使用
        if !utf8.contains('\u{FFFD}') {
            return utf8.to_string();
        }
    }

    // 尝试 GB18030（兼容 GBK/GB2312）
    let (decoded, _, had_errors) = GB18030.decode(raw);
    if !had_errors {
        return decoded.to_string();
    }

    // 回退：UTF-8 lossy
    String::from_utf8_lossy(raw).to_string()
}

/// 判断原始文件名是否表示目录（以 / 或 \ 结尾）
fn is_dir_from_raw(raw: &[u8]) -> bool {
    raw.ends_with(b"/") || raw.ends_with(b"\\")
}

/// 压缩包内单个文件条目
#[derive(Debug, Clone, Serialize, sqlx::FromRow, ToSchema)]
pub struct ArchiveEntry {
    pub id: Option<i64>,
    pub file_id: i64,
    pub entry_path: String,
    pub size: Option<i64>,
    pub is_directory: bool,
}

/// 解压结果
#[derive(Debug, Serialize, ToSchema)]
pub struct ExtractResult {
    pub entries: Vec<ArchiveEntry>,
    pub needs_password: bool,
}

/// 压缩文件处理错误
#[derive(Debug, thiserror::Error)]
pub enum ArchiveError {
    #[error("密码错误或需要密码")]
    PasswordRequired,
    #[error("无效的密码")]
    InvalidPassword,
    #[error("不支持的压缩格式: {0}")]
    UnsupportedFormat(String),
    #[error("IO 错误: {0}")]
    Io(#[from] std::io::Error),
    #[error("ZIP 错误: {0}")]
    Zip(String),
    #[error("解压大小超过限制: 最大 {max_mb}MB, 实际约 {actual_mb}MB")]
    SizeLimitExceeded { max_mb: u64, actual_mb: u64 },
    #[error("文件数量超过限制: 最大 {max}, 实际 {actual}")]
    FileCountExceeded { max: usize, actual: usize },
    #[error("{0}")]
    Other(String),
}

/// 解压安全限制
pub struct ExtractLimits {
    /// 最大解压后总大小（字节），默认 1GB
    pub max_total_size: u64,
    /// 最大文件数量，默认 10000
    pub max_file_count: usize,
    /// 单个文件最大大小（字节），默认 100MB
    pub max_file_size: u64,
}

impl Default for ExtractLimits {
    fn default() -> Self {
        Self {
            max_total_size: 1_073_741_824, // 1GB
            max_file_count: 10_000,
            max_file_size: 104_857_600, // 100MB
        }
    }
}

/// 支持的压缩格式
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ArchiveFormat {
    Zip,
    SevenZ,
    Tar,
    TarGz,
    Tgz,
    TarBz2,
    TarXz,
    Unknown,
}

impl ArchiveFormat {
    /// 根据文件名识别压缩格式（大小写不敏感）
    pub fn from_filename(filename: &str) -> Self {
        let lower = filename.to_lowercase();
        if lower.ends_with(".zip") {
            ArchiveFormat::Zip
        } else if lower.ends_with(".7z") {
            ArchiveFormat::SevenZ
        } else if lower.ends_with(".tar.gz") {
            ArchiveFormat::TarGz
        } else if lower.ends_with(".tgz") {
            ArchiveFormat::Tgz
        } else if lower.ends_with(".tar.bz2") {
            ArchiveFormat::TarBz2
        } else if lower.ends_with(".tar.xz") {
            ArchiveFormat::TarXz
        } else if lower.ends_with(".tar") {
            ArchiveFormat::Tar
        } else {
            ArchiveFormat::Unknown
        }
    }

    /// 是否为已识别的压缩格式（含暂不解压的 7Z）
    pub fn is_archive(self) -> bool {
        !matches!(self, ArchiveFormat::Unknown)
    }

    /// 当前是否可直接解压
    pub fn is_supported(self) -> bool {
        matches!(self, ArchiveFormat::Zip) || self.is_tar_variant()
    }

    /// 是否为 tar 变体
    pub fn is_tar_variant(self) -> bool {
        matches!(
            self,
            ArchiveFormat::Tar
                | ArchiveFormat::TarGz
                | ArchiveFormat::Tgz
                | ArchiveFormat::TarBz2
                | ArchiveFormat::TarXz
        )
    }

    /// 格式描述文本
    pub fn desc(self) -> &'static str {
        match self {
            ArchiveFormat::Zip => "ZIP",
            ArchiveFormat::SevenZ => "7Z",
            ArchiveFormat::Tar => "TAR",
            ArchiveFormat::TarGz | ArchiveFormat::Tgz => "TAR.GZ",
            ArchiveFormat::TarBz2 => "TAR.BZ2",
            ArchiveFormat::TarXz => "TAR.XZ",
            ArchiveFormat::Unknown => "未知",
        }
    }
}

/// 判断文件是否为支持的压缩格式
pub fn is_archive_file(filename: &str) -> bool {
    ArchiveFormat::from_filename(filename).is_archive()
}

/// 将压缩文件解压到指定目录
///
/// `filename` 为原始文件名（含扩展名），用于判断压缩格式。
/// 返回解压后的文件列表
pub fn extract_archive(
    src_path: &str, dest_dir: &str, filename: &str, password: Option<&str>, file_id: i64,
) -> Result<Vec<ArchiveEntry>, ArchiveError> {
    let limits = ExtractLimits::default();
    extract_archive_with_limits(src_path, dest_dir, filename, password, file_id, &limits)
}

/// 带限制的解压
pub fn extract_archive_with_limits(
    src_path: &str, dest_dir: &str, filename: &str, password: Option<&str>, file_id: i64, limits: &ExtractLimits,
) -> Result<Vec<ArchiveEntry>, ArchiveError> {
    let format = ArchiveFormat::from_filename(filename);
    if !format.is_archive() {
        return Err(ArchiveError::UnsupportedFormat(format.desc().to_string()));
    }

    // 创建目标目录
    std::fs::create_dir_all(dest_dir)?;

    match format {
        ArchiveFormat::Zip => extract_zip(src_path, dest_dir, password, file_id, limits),
        ArchiveFormat::SevenZ => Err(ArchiveError::UnsupportedFormat("7Z 格式暂不支持".to_string())),
        _ if format.is_tar_variant() => extract_tar(src_path, dest_dir, file_id, limits),
        _ => Err(ArchiveError::UnsupportedFormat(format.desc().to_string())),
    }
}

/// 读取压缩包内单个文件内容到临时文件
///
/// `filename` 为原始文件名（含扩展名），用于判断压缩格式。
/// 返回的 `NamedTempFile` 需要由调用方在合适时机消费/关闭。
pub fn read_archive_entry(
    src_path: &str, filename: &str, entry_path: &str, password: Option<&str>,
) -> Result<NamedTempFile, ArchiveError> {
    let format = ArchiveFormat::from_filename(filename);
    match format {
        ArchiveFormat::Zip => read_zip_entry(src_path, entry_path, password),
        ArchiveFormat::SevenZ => Err(ArchiveError::UnsupportedFormat("7Z 格式暂不支持".to_string())),
        _ if format.is_tar_variant() => read_tar_entry(src_path, entry_path),
        _ => Err(ArchiveError::UnsupportedFormat(format.desc().to_string())),
    }
}

// ============================================================================
// ZIP 解压
// ============================================================================

fn extract_zip(
    src_path: &str, dest_dir: &str, password: Option<&str>, file_id: i64, limits: &ExtractLimits,
) -> Result<Vec<ArchiveEntry>, ArchiveError> {
    let file = std::fs::File::open(src_path)?;
    let mut archive = match zip::ZipArchive::new(file) {
        Ok(a) => a,
        Err(e) => return Err(ArchiveError::Zip(e.to_string())),
    };

    let mut entries = Vec::new();
    let mut total_size: u64 = 0;
    let password_bytes = password.map(|p| p.as_bytes());

    log::info!("ZIP archive has {} entries, file_id={}", archive.len(), file_id);

    for i in 0..archive.len() {
        // 先检查文件是否加密
        let is_encrypted = {
            let file = archive.by_index(i).map_err(|e| ArchiveError::Zip(e.to_string()))?;
            file.encrypted()
        };

        let mut file_entry = if is_encrypted {
            if let Some(pw) = password_bytes {
                archive.by_index_decrypt(i, pw).map_err(|e| ArchiveError::Zip(e.to_string()))?
            } else {
                return Err(ArchiveError::PasswordRequired);
            }
        } else {
            archive.by_index(i).map_err(|e| ArchiveError::Zip(e.to_string()))?
        };

        let raw_bytes = file_entry.name_raw();
        let raw_name = decode_filename(raw_bytes);
        // 统一路径分隔符为 /，并处理连续分隔符和首尾分隔符
        let name: String =
            raw_name.replace('\\', "/").split('/').filter(|s| !s.is_empty()).collect::<Vec<_>>().join("/");
        if name.is_empty() {
            log::info!(
                "ZIP entry {}: raw={:?} utf8={:?} -> skipped (empty after normalization)",
                i,
                raw_bytes,
                raw_name
            );
            continue;
        }
        let is_dir = is_dir_from_raw(raw_bytes);
        let name = if is_dir && name.ends_with('/') { name.trim_end_matches('/').to_string() } else { name };
        let size = file_entry.size();

        log::info!(
            "ZIP entry {}: raw={:?} decoded={:?} -> normalized={}, is_dir={}, size={}",
            i,
            raw_bytes,
            raw_name,
            name,
            is_dir,
            size
        );

        // 安全检查：路径遍历
        if name.contains("..") {
            log::warn!("Skipping ZIP entry with path traversal: {}", name);
            continue;
        }

        // 大小限制检查
        if !is_dir {
            if size > limits.max_file_size {
                return Err(ArchiveError::SizeLimitExceeded {
                    max_mb: limits.max_file_size / 1_048_576,
                    actual_mb: size / 1_048_576,
                });
            }
            total_size += size;
            if total_size > limits.max_total_size {
                return Err(ArchiveError::SizeLimitExceeded {
                    max_mb: limits.max_total_size / 1_048_576,
                    actual_mb: total_size / 1_048_576,
                });
            }
        }

        // 数量限制检查
        if entries.len() >= limits.max_file_count {
            return Err(ArchiveError::FileCountExceeded { max: limits.max_file_count, actual: entries.len() });
        }

        let out_path = Path::new(dest_dir).join(&name);

        if is_dir {
            std::fs::create_dir_all(&out_path)?;
        } else {
            if let Some(parent) = out_path.parent() {
                std::fs::create_dir_all(parent)?;
            }
            let mut out_file = std::fs::File::create(&out_path)?;
            std::io::copy(&mut file_entry, &mut out_file)?;
        }

        entries.push(ArchiveEntry {
            id: None,
            file_id,
            entry_path: name,
            size: Some(size as i64),
            is_directory: is_dir,
        });
    }

    log::info!("ZIP extraction completed: {} entries, file_id={}", entries.len(), file_id);
    Ok(entries)
}

fn read_zip_entry(src_path: &str, entry_path: &str, password: Option<&str>) -> Result<NamedTempFile, ArchiveError> {
    let file = std::fs::File::open(src_path)?;
    let mut archive = match zip::ZipArchive::new(file) {
        Ok(a) => a,
        Err(e) => return Err(ArchiveError::Zip(e.to_string())),
    };

    let password_bytes = password.map(|p| p.as_bytes());
    let normalized_target = entry_path.replace('\\', "/").trim_start_matches('/').trim_end_matches('/').to_string();

    // 遍历所有条目，用解码后的文件名匹配（处理 GBK 编码中文文件名）
    for i in 0..archive.len() {
        let file_ref = archive.by_index(i).map_err(|e| ArchiveError::Zip(e.to_string()))?;
        let decoded_name = decode_filename(file_ref.name_raw());
        let normalized_name = decoded_name.replace('\\', "/").trim_start_matches('/').trim_end_matches('/').to_string();

        if normalized_name == normalized_target {
            let is_encrypted = file_ref.encrypted();
            drop(file_ref);

            let mut file_entry = if is_encrypted {
                if let Some(pw) = password_bytes {
                    archive.by_index_decrypt(i, pw).map_err(|e| ArchiveError::Zip(e.to_string()))?
                } else {
                    return Err(ArchiveError::PasswordRequired);
                }
            } else {
                archive.by_index(i).map_err(|e| ArchiveError::Zip(e.to_string()))?
            };

            let mut temp = NamedTempFile::new()?;
            std::io::copy(&mut file_entry, &mut temp)?;
            temp.flush()?;
            return Ok(temp);
        }
    }

    Err(ArchiveError::Other(format!("文件不存在: {}", entry_path)))
}

// ============================================================================
// TAR 解压（含 GZ/BZ2/XZ 变体）
// ============================================================================

fn open_tar_reader(src_path: &str) -> Result<Box<dyn Read>, ArchiveError> {
    let file = std::fs::File::open(src_path)?;
    let lower = src_path.to_lowercase();

    if lower.ends_with(".tar") {
        Ok(Box::new(file))
    } else if lower.ends_with(".tar.gz") || lower.ends_with(".tgz") {
        Ok(Box::new(flate2::read::GzDecoder::new(file)))
    } else if lower.ends_with(".tar.bz2") {
        Ok(Box::new(bzip2::read::BzDecoder::new(file)))
    } else if lower.ends_with(".tar.xz") {
        Ok(Box::new(xz2::read::XzDecoder::new(file)))
    } else {
        Err(ArchiveError::UnsupportedFormat("TAR 变体".to_string()))
    }
}

fn extract_tar(
    src_path: &str, dest_dir: &str, file_id: i64, limits: &ExtractLimits,
) -> Result<Vec<ArchiveEntry>, ArchiveError> {
    let reader = open_tar_reader(src_path)?;
    let mut archive = tar::Archive::new(reader);

    let mut entries = Vec::new();
    let mut total_size: u64 = 0;

    for entry_result in archive.entries()? {
        let mut entry = entry_result?;
        let raw_path = entry.path_bytes();
        let decoded = decode_filename(&raw_path);
        let name = decoded.replace('\\', "/").trim_start_matches('/').trim_end_matches('/').to_string();
        if name.is_empty() {
            continue;
        }
        let is_dir = entry.header().entry_type().is_dir() || decoded.ends_with('/') || decoded.ends_with('\\');
        let name = if is_dir && name.ends_with('/') { name.trim_end_matches('/').to_string() } else { name };
        let size = entry.size();

        // 安全检查
        if name.contains("..") {
            log::warn!("Skipping TAR entry with path traversal: {}", name);
            continue;
        }

        // 大小限制
        if !is_dir {
            if size > limits.max_file_size {
                return Err(ArchiveError::SizeLimitExceeded {
                    max_mb: limits.max_file_size / 1_048_576,
                    actual_mb: size / 1_048_576,
                });
            }
            total_size += size;
            if total_size > limits.max_total_size {
                return Err(ArchiveError::SizeLimitExceeded {
                    max_mb: limits.max_total_size / 1_048_576,
                    actual_mb: total_size / 1_048_576,
                });
            }
        }

        if entries.len() >= limits.max_file_count {
            return Err(ArchiveError::FileCountExceeded { max: limits.max_file_count, actual: entries.len() });
        }

        let out_path = Path::new(dest_dir).join(&name);

        if is_dir {
            std::fs::create_dir_all(&out_path)?;
        } else {
            if let Some(parent) = out_path.parent() {
                std::fs::create_dir_all(parent)?;
            }
            let mut out_file = std::fs::File::create(&out_path)?;
            std::io::copy(&mut entry, &mut out_file)?;
        }

        entries.push(ArchiveEntry {
            id: None,
            file_id,
            entry_path: name,
            size: Some(size as i64),
            is_directory: is_dir,
        });
    }

    Ok(entries)
}

fn read_tar_entry(src_path: &str, entry_path: &str) -> Result<NamedTempFile, ArchiveError> {
    let reader = open_tar_reader(src_path)?;
    let mut archive = tar::Archive::new(reader);

    let normalized_target = entry_path.replace('\\', "/").trim_start_matches('/').trim_end_matches('/').to_string();

    for entry_result in archive.entries()? {
        let mut entry = entry_result?;
        let raw_path = entry.path_bytes();
        let decoded = decode_filename(&raw_path);
        let name = decoded.replace('\\', "/").trim_start_matches('/').trim_end_matches('/').to_string();

        if name == normalized_target {
            let mut temp = NamedTempFile::new()?;
            std::io::copy(&mut entry, &mut temp)?;
            temp.flush()?;
            return Ok(temp);
        }
    }

    Err(ArchiveError::Other(format!("文件不存在: {}", entry_path)))
}

// ============================================================================
// 辅助函数
// ============================================================================

/// 清理压缩文件解压目录
pub fn cleanup_archive_dir(archives_path: &str, file_id: i64) -> std::io::Result<()> {
    let dir = Path::new(archives_path).join(file_id.to_string());
    if dir.exists() {
        std::fs::remove_dir_all(&dir)?;
    }
    Ok(())
}

/// 获取压缩文件条目的本地文件系统路径
pub fn resolve_archive_entry_path(archives_path: &str, file_id: i64, entry_path: &str) -> Option<std::path::PathBuf> {
    let base = Path::new(archives_path).join(file_id.to_string());
    let resolved = base.join(entry_path);

    // 安全检查：确保解析后的路径在 base 目录下
    let canonical_base = base.canonicalize().unwrap_or(base.clone());
    let canonical_resolved = match resolved.canonicalize() {
        Ok(p) => p,
        Err(_) => resolved.clone(),
    };

    if !canonical_resolved.starts_with(&canonical_base) {
        return None;
    }

    Some(resolved)
}

#[cfg(test)]
mod tests {
    use std::io::Write;

    use super::*;

    #[test]
    fn test_is_archive_file() {
        assert!(is_archive_file("test.zip"));
        assert!(is_archive_file("test.ZIP"));
        assert!(is_archive_file("test.tar.gz"));
        assert!(is_archive_file("test.tgz"));
        assert!(is_archive_file("test.tar.bz2"));
        assert!(is_archive_file("test.tar.xz"));
        assert!(is_archive_file("test.7z"));
        assert!(!is_archive_file("test.pdf"));
        assert!(!is_archive_file("test.txt"));
    }

    #[test]
    fn test_extract_zip_with_backslash_paths() {
        // 创建测试 ZIP（Windows 风格路径）
        let zip_path = "/tmp/test_htknow_zip.zip";
        let extract_dir = "/tmp/test_htknow_extract";

        // 清理
        let _ = std::fs::remove_file(zip_path);
        let _ = std::fs::remove_dir_all(extract_dir);

        {
            let file = std::fs::File::create(zip_path).unwrap();
            let mut zip = zip::ZipWriter::new(file);
            let options = zip::write::SimpleFileOptions::default();
            zip.start_file("folder\\file1.txt", options).unwrap();
            zip.write_all(b"hello world 1").unwrap();
            zip.start_file("folder\\sub\\file2.txt", options).unwrap();
            zip.write_all(b"hello world 2").unwrap();
            zip.start_file("root.txt", options).unwrap();
            zip.write_all(b"hello root").unwrap();
            zip.finish().unwrap();
        }

        let entries = extract_archive(zip_path, extract_dir, "test.zip", None, 1).unwrap();

        // 应该解压出 3 个文件条目（目录条目会自动从路径推断）
        assert!(
            entries.len() >= 3,
            "Expected at least 3 entries, got {}: {:?}",
            entries.len(),
            entries.iter().map(|e| &e.entry_path).collect::<Vec<_>>()
        );

        // 检查路径统一使用了 /
        let paths: Vec<String> = entries.iter().map(|e| e.entry_path.clone()).collect();
        assert!(paths.iter().any(|p| p == "folder/file1.txt"), "Missing folder/file1.txt in {:?}", paths);
        assert!(paths.iter().any(|p| p == "folder/sub/file2.txt"), "Missing folder/sub/file2.txt in {:?}", paths);
        assert!(paths.iter().any(|p| p == "root.txt"), "Missing root.txt in {:?}", paths);

        // 没有路径应该包含反斜杠
        for p in &paths {
            assert!(!p.contains('\\'), "Path should not contain backslash: {}", p);
        }

        // 检查文件内容
        let content1 = std::fs::read_to_string(format!("{}/folder/file1.txt", extract_dir)).unwrap();
        assert_eq!(content1, "hello world 1");

        let content2 = std::fs::read_to_string(format!("{}/folder/sub/file2.txt", extract_dir)).unwrap();
        assert_eq!(content2, "hello world 2");

        // 清理
        let _ = std::fs::remove_file(zip_path);
        let _ = std::fs::remove_dir_all(extract_dir);
    }

    #[test]
    fn test_extract_zip_with_forward_slash_paths() {
        let zip_path = "/tmp/test_htknow_zip2.zip";
        let extract_dir = "/tmp/test_htknow_extract2";

        let _ = std::fs::remove_file(zip_path);
        let _ = std::fs::remove_dir_all(extract_dir);

        {
            let file = std::fs::File::create(zip_path).unwrap();
            let mut zip = zip::ZipWriter::new(file);
            let options = zip::write::SimpleFileOptions::default();
            zip.start_file("docs/report.pdf", options).unwrap();
            zip.write_all(b"fake pdf").unwrap();
            zip.start_file("data/info.txt", options).unwrap();
            zip.write_all(b"info").unwrap();
            zip.finish().unwrap();
        }

        let entries = extract_archive(zip_path, extract_dir, "test.zip", None, 2).unwrap();
        assert!(entries.len() >= 2, "Expected at least 2 entries, got {}", entries.len());

        let paths: Vec<String> = entries.iter().map(|e| e.entry_path.clone()).collect();
        assert!(paths.iter().any(|p| p == "docs/report.pdf"));
        assert!(paths.iter().any(|p| p == "data/info.txt"));

        let _ = std::fs::remove_file(zip_path);
        let _ = std::fs::remove_dir_all(extract_dir);
    }
}