vielpork 0.1.3

//! # 模板渲染模块
//!
//! 提供灵活的模板渲染功能，用于生成动态文件名和目录结构。
//!
//! ## 示例
//!
//! ```ignore
//! let renderer = TemplateRenderer::new();
//! let context = TemplateContext::new(
//!     "https://example.com/file.zip",
//!     "example.com",
//!     "file.zip",
//!     "zip",
//!     &meta,
//!     Utc::now(),
//! );
//! let result = renderer.render_path_template("{{date}}/{{domain}}/{{filename}}", &context)?;
//! ```

use crate::base::structs::DownloadMeta;
use crate::error::Result;
use chrono::{DateTime, Utc};
use handlebars::Handlebars;
use percent_encoding::percent_decode;
use std::collections::HashMap;
use std::path::Path;

/// 模板渲染引擎
///
/// 使用 Handlebars 模板语言，提供文件名和目录路径的动态生成。
/// 支持多个内置 helper 函数，如日期格式化、文件扩展名提取等。
#[derive(Debug, Clone)]
pub struct TemplateRenderer {
    registry: Handlebars<'static>,
}

impl Default for TemplateRenderer {
    fn default() -> Self {
        Self::new()
    }
}

impl TemplateRenderer {
    /// 创建新的模板渲染器
    ///
    /// 初始化 Handlebars 注册表并注册所有内置 helper 函数。
    pub fn new() -> Self {
        let mut registry = Handlebars::new();
        registry.register_escape_fn(|s| s.into()); // 禁用HTML转义

        // 注册自定义 helper
        registry.register_helper("date_format", Box::new(date_format_helper));
        registry.register_helper("file_extension", Box::new(file_extension_helper));
        registry.register_helper("format_size", Box::new(format_size_helper));
        registry.register_helper("url_decode", Box::new(url_decode_helper));
        registry.register_helper("uppercase", Box::new(uppercase_helper));
        registry.register_helper("lowercase", Box::new(lowercase_helper));
        registry.register_helper("filename_stem", Box::new(filename_stem_helper));

        Self { registry }
    }

    /// 渲染路径模板
    ///
    /// # 参数
    ///
    /// * `template` - Handlebars 模板字符串
    /// * `context` - 渲染上下文数据
    ///
    /// # 返回值
    ///
    /// 渲染后的字符串，或渲染错误
    ///
    /// # 支持的模板变量
    ///
    /// - `url` - 完整的下载URL
    /// - `domain` - 域名
    /// - `filename` - 完整文件名
    /// - `ext` - 文件扩展名
    /// - `size` - 文件大小（字节）
    /// - `content_type` - MIME 类型
    /// - `date` - 下载日期（YYYY-MM-DD格式）
    /// - `time` - 下载时间（HH-MM-SS格式）
    /// - 任何自定义元数据字段
    pub fn render_path_template(
        &self,
        template: &str,
        context: &TemplateContext,
    ) -> Result<String> {
        if template.is_empty() {
            return Ok(context.filename.to_string());
        }

        let mut data = serde_json::json!({
            "url": context.url,
            "domain": context.domain.unwrap_or("unknown"),
            "filename": context.filename,
            "ext": context.extension.unwrap_or(""),
            "size": context.meta.expected_size.unwrap_or(0),
            "content_type": context.meta.content_type.as_deref().unwrap_or(""),
            "date": context.download_time.format("%Y-%m-%d").to_string(),
            "time": context.download_time.format("%H-%M-%S").to_string(),
        });

        // 添加自定义元数据
        if let Some(ref custom) = context.custom_data {
            for (k, v) in custom {
                data[k] = serde_json::Value::String(v.clone());
            }
        }

        self.registry
            .render_template(template, &data)
            .map_err(|e| format!("Template rendering error: {}", e).into())
    }

    /// 验证模板是否有效
    ///
    /// # 参数
    ///
    /// * `template` - 要验证的模板字符串
    ///
    /// # 返回值
    ///
    /// 如果模板有效返回 Ok(())，否则返回错误信息
    pub fn validate_template(&self, template: &str) -> Result<()> {
        if template.is_empty() {
            return Ok(());
        }

        // 创建一个空上下文来测试模板编译
        let dummy_data = serde_json::json!({
            "url": "",
            "domain": "",
            "filename": "",
            "ext": "",
            "size": 0,
            "content_type": "",
            "date": "",
            "time": "",
        });

        let context = handlebars::Context::wraps(&dummy_data)
            .map_err(|e| crate::error::Error::from(format!("Template validation failed: {}", e)))?;

        self.registry
            .render_template_with_context(template, &context)
            .map_err(|e| crate::error::Error::from(format!("Invalid template: {}", e)))?;

        Ok(())
    }

    /// 获取内部 Handlebars 实例的不可变引用
    pub fn registry(&self) -> &Handlebars<'static> {
        &self.registry
    }
}

/// 模板上下文数据
///
/// 包含特定下载任务的所有数据，用于填充模板变量。
#[derive(Debug, Clone)]
pub struct TemplateContext<'a> {
    /// 完整的下载URL
    pub url: &'a str,
    /// 域名（如果可用）
    pub domain: Option<&'a str>,
    /// 完整的文件名
    pub filename: &'a str,
    /// 文件扩展名（不包括点）
    pub extension: Option<&'a str>,
    /// 下载元数据
    pub meta: &'a DownloadMeta,
    /// 下载时间戳
    pub download_time: DateTime<Utc>,
    /// 自定义元数据键值对
    pub custom_data: Option<HashMap<String, String>>,
}

impl<'a> TemplateContext<'a> {
    /// 创建新的模板上下文
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        url: &'a str,
        domain: Option<&'a str>,
        filename: &'a str,
        extension: Option<&'a str>,
        meta: &'a DownloadMeta,
        download_time: DateTime<Utc>,
    ) -> Self {
        Self {
            url,
            domain,
            filename,
            extension,
            meta,
            download_time,
            custom_data: None,
        }
    }

    /// 添加自定义元数据
    pub fn with_custom_data(mut self, custom_data: HashMap<String, String>) -> Self {
        self.custom_data = Some(custom_data);
        self
    }

    /// 添加单个自定义元数据项
    pub fn add_custom_data(mut self, key: String, value: String) -> Self {
        self.custom_data
            .get_or_insert_with(HashMap::new)
            .insert(key, value);
        self
    }
}

/// 自定义日期格式化 helper
///
/// 用法: `{{date_format timestamp "%Y-%m-%d"}}`
/// 如果参数不足，使用默认格式 "%Y-%m-%d"
fn date_format_helper(
    h: &handlebars::Helper<'_>,
    _: &Handlebars<'_>,
    _: &handlebars::Context,
    _: &mut handlebars::RenderContext<'_, '_>,
    out: &mut dyn handlebars::Output,
) -> handlebars::HelperResult {
    let format = h
        .param(1)
        .and_then(|v| v.value().as_str())
        .unwrap_or("%Y-%m-%d");
    let timestamp = h.param(0).and_then(|v| v.value().as_str()).unwrap_or("");

    if timestamp.is_empty() {
        return Ok(out.write("")?);
    }

    let dt = DateTime::parse_from_rfc3339(timestamp)
        .or_else(|_| DateTime::parse_from_str(timestamp, "%Y-%m-%d %H:%M:%S"))
        .unwrap_or_default();

    out.write(&dt.format(format).to_string())?;
    Ok(())
}

/// 文件扩展名提取 helper
///
/// 用法: `{{file_extension filename}}`
/// 从文件名中提取扩展名（不包括点）
fn file_extension_helper(
    h: &handlebars::Helper<'_>,
    _: &Handlebars<'_>,
    _: &handlebars::Context,
    _: &mut handlebars::RenderContext<'_, '_>,
    out: &mut dyn handlebars::Output,
) -> handlebars::HelperResult {
    let filename = h.param(0).and_then(|v| v.value().as_str()).unwrap_or("");
    let ext = Path::new(filename)
        .extension()
        .and_then(|s| s.to_str())
        .unwrap_or("");

    out.write(ext)?;
    Ok(())
}

/// 文件大小格式化 helper
///
/// 用法: `{{format_size size}}`
/// 将字节大小转换为可读的格式（B, KB, MB, GB, TB）
fn format_size_helper(
    h: &handlebars::Helper<'_>,
    _: &Handlebars<'_>,
    _: &handlebars::Context,
    _: &mut handlebars::RenderContext<'_, '_>,
    out: &mut dyn handlebars::Output,
) -> handlebars::HelperResult {
    let size = h.param(0).and_then(|v| v.value().as_u64()).unwrap_or(0);

    let formatted = format_size(size);
    out.write(&formatted)?;
    Ok(())
}

/// URL 解码 helper
///
/// 用法: `{{url_decode encoded_string}}`
/// 对 URL 编码的字符串进行解码
fn url_decode_helper(
    h: &handlebars::Helper<'_>,
    _: &Handlebars<'_>,
    _: &handlebars::Context,
    _: &mut handlebars::RenderContext<'_, '_>,
    out: &mut dyn handlebars::Output,
) -> handlebars::HelperResult {
    let encoded = h.param(0).and_then(|v| v.value().as_str()).unwrap_or("");

    let decoded = percent_decode(encoded.as_bytes())
        .decode_utf8()
        .unwrap_or(std::borrow::Cow::Borrowed(encoded))
        .to_string();

    out.write(&decoded)?;
    Ok(())
}

/// 大写转换 helper
///
/// 用法: `{{uppercase string}}`
/// 将字符串转换为大写
fn uppercase_helper(
    h: &handlebars::Helper<'_>,
    _: &Handlebars<'_>,
    _: &handlebars::Context,
    _: &mut handlebars::RenderContext<'_, '_>,
    out: &mut dyn handlebars::Output,
) -> handlebars::HelperResult {
    let input = h.param(0).and_then(|v| v.value().as_str()).unwrap_or("");
    let result = input.to_uppercase();

    out.write(&result)?;
    Ok(())
}

/// 小写转换 helper
///
/// 用法: `{{lowercase string}}`
/// 将字符串转换为小写
fn lowercase_helper(
    h: &handlebars::Helper<'_>,
    _: &Handlebars<'_>,
    _: &handlebars::Context,
    _: &mut handlebars::RenderContext<'_, '_>,
    out: &mut dyn handlebars::Output,
) -> handlebars::HelperResult {
    let input = h.param(0).and_then(|v| v.value().as_str()).unwrap_or("");
    let result = input.to_lowercase();

    out.write(&result)?;
    Ok(())
}

/// 文件名干名处理 helper
///
/// 用法: `{{filename_stem filename}}`
/// 提取文件名（去除扩展名）
fn filename_stem_helper(
    h: &handlebars::Helper<'_>,
    _: &Handlebars<'_>,
    _: &handlebars::Context,
    _: &mut handlebars::RenderContext<'_, '_>,
    out: &mut dyn handlebars::Output,
) -> handlebars::HelperResult {
    let filename = h.param(0).and_then(|v| v.value().as_str()).unwrap_or("");
    let path = Path::new(filename);
    let stem = path
        .file_stem()
        .and_then(|s| s.to_str())
        .unwrap_or(filename);

    out.write(stem)?;
    Ok(())
}

/// 将字节大小格式化为可读的字符串
fn format_size(bytes: u64) -> String {
    const UNITS: &[&str] = &["B", "KB", "MB", "GB", "TB"];
    const THRESHOLD: f64 = 1024.0;

    let mut size = bytes as f64;
    let mut unit_index = 0;

    while size >= THRESHOLD && unit_index < UNITS.len() - 1 {
        size /= THRESHOLD;
        unit_index += 1;
    }

    if unit_index == 0 {
        format!("{} {}", bytes, UNITS[unit_index])
    } else {
        format!("{:.2} {}", size, UNITS[unit_index])
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::Utc;

    /// 创建测试用的 DownloadMeta
    fn create_test_meta() -> DownloadMeta {
        DownloadMeta {
            expected_size: Some(1024 * 1024), // 1 MB
            content_type: Some("application/octet-stream".to_string()),
            suggested_filename: Some("test.zip".to_string()),
            etag: None,
            last_modified: None,
            download_start: Some(Utc::now()),
            checksum: None,
        }
    }

    #[test]
    fn test_template_renderer_new() {
        let renderer = TemplateRenderer::new();
        // 验证渲染器创建成功
        assert!(renderer.validate_template("{{filename}}").is_ok());
    }

    #[test]
    fn test_template_renderer_default() {
        let renderer1 = TemplateRenderer::new();
        let renderer2 = TemplateRenderer::default();
        // 两者都应该正常工作
        assert!(renderer1.validate_template("{{filename}}").is_ok());
        assert!(renderer2.validate_template("{{filename}}").is_ok());
    }

    #[test]
    fn test_validate_template() {
        let renderer = TemplateRenderer::new();

        // 有效的模板
        assert!(renderer.validate_template("{{filename}}").is_ok());
        assert!(renderer.validate_template("{{date}}/{{filename}}").is_ok());
        assert!(renderer.validate_template("").is_ok()); // 空模板有效

        // 无效的模板（未闭合的括号）
        assert!(renderer.validate_template("{{filename").is_err());
    }

    #[test]
    fn test_render_path_template_empty() {
        let renderer = TemplateRenderer::new();
        let meta = create_test_meta();
        let now = Utc::now();
        let context = TemplateContext::new(
            "https://example.com/file.zip",
            Some("example.com"),
            "file.zip",
            Some("zip"),
            &meta,
            now,
        );

        // 空模板应返回原始文件名
        let result = renderer.render_path_template("", &context);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), "file.zip");
    }

    #[test]
    fn test_render_path_template_basic() {
        let renderer = TemplateRenderer::new();
        let meta = create_test_meta();
        let now = Utc::now();
        let context = TemplateContext::new(
            "https://example.com/file.zip",
            Some("example.com"),
            "file.zip",
            Some("zip"),
            &meta,
            now,
        );

        // 测试基础变量
        let result = renderer.render_path_template("{{filename}}", &context);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), "file.zip");

        let result = renderer.render_path_template("{{domain}}", &context);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), "example.com");

        let result = renderer.render_path_template("{{ext}}", &context);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), "zip");
    }

    #[test]
    fn test_render_path_template_complex() {
        let renderer = TemplateRenderer::new();
        let meta = create_test_meta();
        let now = Utc::now();
        let context = TemplateContext::new(
            "https://example.com/file.zip",
            Some("example.com"),
            "file.zip",
            Some("zip"),
            &meta,
            now,
        );

        // 使用日期和文件名
        let template = "{{date}}/{{domain}}/{{filename}}";
        let result = renderer.render_path_template(template, &context);
        assert!(result.is_ok());

        let rendered = result.unwrap();
        assert!(rendered.contains("example.com"));
        assert!(rendered.contains("file.zip"));
    }

    #[test]
    fn test_template_context_builder() {
        let meta = create_test_meta();
        let now = Utc::now();

        let context = TemplateContext::new(
            "https://example.com/file.zip",
            Some("example.com"),
            "file.zip",
            Some("zip"),
            &meta,
            now,
        )
        .add_custom_data("resource_id".to_string(), "12345".to_string());

        assert_eq!(context.url, "https://example.com/file.zip");
        assert_eq!(context.domain, Some("example.com"));
        assert_eq!(context.filename, "file.zip");
        assert!(context.custom_data.is_some());
        assert_eq!(
            context.custom_data.unwrap().get("resource_id"),
            Some(&"12345".to_string())
        );
    }

    #[test]
    fn test_format_size() {
        assert_eq!(format_size(512), "512 B");
        assert_eq!(format_size(1024), "1.00 KB");
        assert_eq!(format_size(1024 * 1024), "1.00 MB");
        assert_eq!(format_size(1024 * 1024 * 100), "100.00 MB");
        assert_eq!(format_size(1024 * 1024 * 1024), "1.00 GB");
    }

    #[test]
    fn test_render_with_custom_data() {
        let renderer = TemplateRenderer::new();
        let meta = create_test_meta();
        let now = Utc::now();

        let mut custom_data = HashMap::new();
        custom_data.insert("category".to_string(), "documents".to_string());

        let context = TemplateContext::new(
            "https://example.com/file.pdf",
            Some("example.com"),
            "file.pdf",
            Some("pdf"),
            &meta,
            now,
        )
        .with_custom_data(custom_data);

        let result = renderer.render_path_template("{{category}}/{{filename}}", &context);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), "documents/file.pdf");
    }

    #[test]
    fn test_render_missing_domain() {
        let renderer = TemplateRenderer::new();
        let meta = create_test_meta();
        let now = Utc::now();
        let context = TemplateContext::new(
            "https://example.com/file.zip",
            None, // 没有域名
            "file.zip",
            Some("zip"),
            &meta,
            now,
        );

        // 应该使用默认值 "unknown"
        let result = renderer.render_path_template("{{domain}}", &context);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), "unknown");
    }
}