//! Pre-process and post-process markdown/HTML for media file references.
//!
//! Two-stage pipeline:
//! 1. **Pre-process markdown** — rewrite `![alt](folder/file.png)` to
//!    `![alt](https://cdn.makenot.work/{user_id}/media/folder/file.png)`.
//! 2. **Post-process HTML** — convert `<img src="...file.mp4">` to
//!    `<video controls src="..."></video>`.

use std::sync::LazyLock;

/// Matches markdown image syntax: `![alt text](url)`
/// Captures: group 1 = alt text, group 2 = URL path
static MD_IMAGE_RE: LazyLock<regex_lite::Regex> = LazyLock::new(|| {
    regex_lite::Regex::new(r"!\[([^\]]*)\]\(([^)]+)\)").expect("valid markdown image regex")
});

/// Matches `<img` tags with a src pointing to a video extension.
static IMG_VIDEO_RE: LazyLock<regex_lite::Regex> = LazyLock::new(|| {
    regex_lite::Regex::new(
        r#"<img\s+([^>]*?)src="([^"]*\.(?:mp4|webm|mov))"([^>]*?)\s*/?>"#,
    )
    .expect("valid img video regex")
});

/// Matches `alt="..."` in an img tag's attributes.
static ALT_RE: LazyLock<regex_lite::Regex> = LazyLock::new(|| {
    regex_lite::Regex::new(r#"alt="([^"]*)""#).expect("valid alt regex")
});

/// Rewrite relative image paths in markdown to absolute CDN URLs.
///
/// Skips:
/// - Absolute URLs (`http://`, `https://`, `data:`)
/// - Absolute paths starting with `/`
/// - Paths containing `..` (path traversal)
///
/// Rewrites relative paths to: `{cdn_base}/{user_id}/media/{path}`
pub fn rewrite_media_paths(markdown: &str, cdn_base: &str, user_id: &str) -> String {
    let cdn_base = cdn_base.trim_end_matches('/');

    MD_IMAGE_RE
        .replace_all(markdown, |caps: &regex_lite::Captures| {
            let alt = &caps[1];
            let path = &caps[2];

            // Skip absolute URLs and data URIs
            if path.starts_with("http://")
                || path.starts_with("https://")
                || path.starts_with("data:")
                || path.starts_with('/')
            {
                return caps[0].to_string();
            }

            // Reject path traversal
            if path.contains("..") {
                return caps[0].to_string();
            }

            format!("![{}]({}/{}/media/{})", alt, cdn_base, user_id, path)
        })
        .into_owned()
}

/// Convert `<img>` tags with video extensions (.mp4, .webm, .mov) to `<video>` elements.
///
/// Preserves alt text as fallback content inside the `<video>` tag.
pub fn img_to_video(html: &str) -> String {
    IMG_VIDEO_RE
        .replace_all(html, |caps: &regex_lite::Captures| {
            let before_src = &caps[1];
            let src = &caps[2];
            let after_src = &caps[3];

            // Extract alt text if present
            let attrs = format!("{}{}", before_src, after_src);
            let alt = ALT_RE
                .captures(&attrs)
                .map(|c| c[1].to_string())
                .unwrap_or_default();

            if alt.is_empty() {
                format!(r#"<video controls src="{}">Your browser does not support video.</video>"#, src)
            } else {
                format!(
                    r#"<video controls src="{}">{}</video>"#,
                    src,
                    crate::escape::html_escape(&alt)
                )
            }
        })
        .into_owned()
}

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

    #[test]
    fn relative_path_rewritten() {
        let md = "![Screenshot](screenshots/demo.png)";
        let result = rewrite_media_paths(md, "https://cdn.makenot.work", "user-123");
        assert_eq!(
            result,
            "![Screenshot](https://cdn.makenot.work/user-123/media/screenshots/demo.png)"
        );
    }

    #[test]
    fn absolute_url_unchanged() {
        let md = "![Logo](https://example.com/logo.png)";
        let result = rewrite_media_paths(md, "https://cdn.makenot.work", "user-123");
        assert_eq!(result, md);
    }

    #[test]
    fn http_url_unchanged() {
        let md = "![Logo](http://example.com/logo.png)";
        let result = rewrite_media_paths(md, "https://cdn.makenot.work", "user-123");
        assert_eq!(result, md);
    }

    #[test]
    fn data_uri_unchanged() {
        let md = "![Pixel](data:image/png;base64,abc)";
        let result = rewrite_media_paths(md, "https://cdn.makenot.work", "user-123");
        assert_eq!(result, md);
    }

    #[test]
    fn absolute_path_unchanged() {
        let md = "![Doc](/static/images/docs/setup.png)";
        let result = rewrite_media_paths(md, "https://cdn.makenot.work", "user-123");
        assert_eq!(result, md);
    }

    #[test]
    fn path_traversal_unchanged() {
        let md = "![Hack](../../../etc/passwd)";
        let result = rewrite_media_paths(md, "https://cdn.makenot.work", "user-123");
        assert_eq!(result, md);
    }

    #[test]
    fn root_folder_file() {
        let md = "![Photo](photo.jpg)";
        let result = rewrite_media_paths(md, "https://cdn.makenot.work", "user-123");
        assert_eq!(
            result,
            "![Photo](https://cdn.makenot.work/user-123/media/photo.jpg)"
        );
    }

    #[test]
    fn cdn_base_trailing_slash_stripped() {
        let md = "![Img](img.png)";
        let result = rewrite_media_paths(md, "https://cdn.makenot.work/", "user-123");
        assert_eq!(
            result,
            "![Img](https://cdn.makenot.work/user-123/media/img.png)"
        );
    }

    #[test]
    fn video_extension_to_video_tag() {
        let html = r#"<img src="https://cdn.makenot.work/u/media/demo.mp4" alt="Demo">"#;
        let result = img_to_video(html);
        assert!(result.contains("<video controls"));
        assert!(result.contains(r#"src="https://cdn.makenot.work/u/media/demo.mp4""#));
        assert!(result.contains("Demo"));
        assert!(result.contains("</video>"));
        assert!(!result.contains("<img"));
    }

    #[test]
    fn non_video_image_unchanged() {
        let html = r#"<img src="https://cdn.makenot.work/u/media/photo.png" alt="Photo">"#;
        let result = img_to_video(html);
        assert_eq!(result, html);
    }

    #[test]
    fn webm_converted() {
        let html = r#"<img src="clip.webm">"#;
        let result = img_to_video(html);
        assert!(result.contains("<video controls"));
        assert!(result.contains("</video>"));
    }

    #[test]
    fn mov_converted() {
        let html = r#"<img src="clip.mov" alt="Clip">"#;
        let result = img_to_video(html);
        assert!(result.contains("<video controls"));
        assert!(result.contains("Clip"));
    }

    #[test]
    fn mixed_content() {
        let md = "Text before\n\n![Img](folder/img.png)\n\nMore text\n\n![Vid](folder/vid.mp4)\n\n![External](https://example.com/pic.jpg)";
        let rewritten = rewrite_media_paths(md, "https://cdn.makenot.work", "u1");
        assert!(rewritten.contains("https://cdn.makenot.work/u1/media/folder/img.png"));
        assert!(rewritten.contains("https://cdn.makenot.work/u1/media/folder/vid.mp4"));
        assert!(rewritten.contains("https://example.com/pic.jpg"));
    }

    #[test]
    fn empty_alt_text() {
        let md = "![](photo.jpg)";
        let result = rewrite_media_paths(md, "https://cdn.makenot.work", "u1");
        assert_eq!(
            result,
            "![](https://cdn.makenot.work/u1/media/photo.jpg)"
        );
    }

    #[test]
    fn video_tag_no_alt() {
        let html = r#"<img src="demo.mp4">"#;
        let result = img_to_video(html);
        assert!(result.contains("Your browser does not support video."));
    }

    #[test]
    fn multiple_images_in_html() {
        let html = r#"<img src="a.png" alt="A"><img src="b.mp4" alt="B"><img src="c.webm">"#;
        let result = img_to_video(html);
        // a.png stays as img
        assert!(result.contains(r#"<img src="a.png""#));
        // b.mp4 becomes video
        assert!(result.contains(r#"<video controls src="b.mp4">B</video>"#));
        // c.webm becomes video
        assert!(result.contains(r#"<video controls src="c.webm">"#));
    }
}