//! RSS 2.0 feed generation
//!
//! Simple XML builder for creator and project RSS feeds.
//! No external dependency needed — just format strings.
//!
//! See also: `/docs/guide/rss`

use chrono::{DateTime, Utc};

/// A single item in an RSS feed.
pub struct FeedItem {
    pub title: String,
    pub link: String,
    pub description: String,
    pub pub_date: DateTime<Utc>,
    pub guid: String,
}

/// Escape XML special characters.
fn xml_escape(s: &str) -> String {
    s.replace('&', "&amp;")
        .replace('<', "&lt;")
        .replace('>', "&gt;")
        .replace('"', "&quot;")
        .replace('\'', "&apos;")
}

/// Core RSS 2.0 renderer. All public feed functions delegate here.
fn render_feed(title: &str, link: &str, description: &str, items: &[FeedItem]) -> String {
    let last_build = items
        .first()
        .map(|i| i.pub_date)
        .unwrap_or_else(Utc::now);

    let mut xml = String::with_capacity(4096);
    xml.push_str(r#"<?xml version="1.0" encoding="UTF-8"?>"#);
    xml.push('\n');
    xml.push_str(r#"<rss version="2.0">"#);
    xml.push_str("\n<channel>\n");
    xml.push_str(&format!("  <title>{}</title>\n", xml_escape(title)));
    xml.push_str(&format!("  <link>{}</link>\n", xml_escape(link)));
    xml.push_str(&format!(
        "  <description>{}</description>\n",
        xml_escape(description)
    ));
    xml.push_str(&format!(
        "  <lastBuildDate>{}</lastBuildDate>\n",
        last_build.to_rfc2822()
    ));
    xml.push_str("  <generator>Makenot.work</generator>\n");

    for item in items {
        xml.push_str("  <item>\n");
        xml.push_str(&format!("    <title>{}</title>\n", xml_escape(&item.title)));
        xml.push_str(&format!("    <link>{}</link>\n", xml_escape(&item.link)));
        xml.push_str(&format!(
            "    <description>{}</description>\n",
            xml_escape(&item.description)
        ));
        xml.push_str(&format!(
            "    <pubDate>{}</pubDate>\n",
            item.pub_date.to_rfc2822()
        ));
        xml.push_str(&format!(
            "    <guid isPermaLink=\"false\">{}</guid>\n",
            xml_escape(&item.guid)
        ));
        xml.push_str("  </item>\n");
    }

    xml.push_str("</channel>\n</rss>\n");
    xml
}

/// Render an RSS 2.0 feed with custom title, link, and description.
pub fn render_feed_custom(
    title: &str,
    link: &str,
    description: &str,
    items: &[FeedItem],
) -> String {
    render_feed(title, link, description, items)
}

/// Render an RSS 2.0 feed for a single project's items.
pub fn render_project_feed(
    project_title: &str,
    project_slug: &str,
    project_description: &str,
    creator_username: &str,
    items: &[FeedItem],
    base_url: &str,
) -> String {
    let link = format!("{}/p/{}", base_url, project_slug);
    let description = format!("{} by {}", project_description, creator_username);
    render_feed(project_title, &link, &description, items)
}

/// Render an RSS 2.0 feed for all of a creator's public items across projects.
pub fn render_creator_feed(
    display_name: &str,
    username: &str,
    bio: &str,
    items: &[FeedItem],
    base_url: &str,
) -> String {
    let link = format!("{}/u/{}", base_url, username);
    render_feed(display_name, &link, bio, items)
}

/// Render an RSS 2.0 feed for a project's blog posts.
pub fn render_blog_feed(
    project_title: &str,
    project_slug: &str,
    project_description: &str,
    creator_username: &str,
    items: &[FeedItem],
    base_url: &str,
) -> String {
    let title = format!("{} - Blog", project_title);
    let link = format!("{}/p/{}/blog", base_url, project_slug);
    let description = format!(
        "Blog posts from {} by {}",
        project_description, creator_username
    );
    render_feed(&title, &link, &description, items)
}

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

    fn sample_items(base_url: &str) -> Vec<FeedItem> {
        vec![
            FeedItem {
                title: "Test Item".to_string(),
                link: format!("{}/i/00000000-0000-0000-0000-000000000001", base_url),
                description: "A test item".to_string(),
                pub_date: Utc.with_ymd_and_hms(2026, 1, 15, 12, 0, 0).unwrap(),
                guid: "00000000-0000-0000-0000-000000000001".to_string(),
            },
            FeedItem {
                title: "Item with <special> & chars".to_string(),
                link: format!("{}/i/00000000-0000-0000-0000-000000000002", base_url),
                description: "Description with \"quotes\"".to_string(),
                pub_date: Utc.with_ymd_and_hms(2026, 1, 10, 12, 0, 0).unwrap(),
                guid: "00000000-0000-0000-0000-000000000002".to_string(),
            },
        ]
    }

    #[test]
    fn project_feed_is_valid_xml_structure() {
        let items = sample_items("https://makenot.work");
        let xml = render_project_feed(
            "My Project",
            "my-project",
            "A cool project",
            "creator",
            &items,
            "https://makenot.work",
        );

        assert!(xml.starts_with(r#"<?xml version="1.0" encoding="UTF-8"?>"#));
        assert!(xml.contains("<rss version=\"2.0\">"));
        assert!(xml.contains("<channel>"));
        assert!(xml.contains("<title>My Project</title>"));
        assert!(xml.contains("<generator>Makenot.work</generator>"));
        assert!(xml.contains("</rss>"));
    }

    #[test]
    fn creator_feed_is_valid_xml_structure() {
        let items = sample_items("https://makenot.work");
        let xml = render_creator_feed(
            "Creator Name",
            "creator",
            "I make things",
            &items,
            "https://makenot.work",
        );

        assert!(xml.contains("<title>Creator Name</title>"));
        assert!(xml.contains("<link>https://makenot.work/u/creator</link>"));
    }

    #[test]
    fn xml_special_chars_are_escaped() {
        let items = sample_items("https://makenot.work");
        let xml = render_project_feed(
            "Test",
            "test",
            "desc",
            "user",
            &items,
            "https://makenot.work",
        );

        assert!(xml.contains("&lt;special&gt;"));
        assert!(xml.contains("&amp; chars"));
        assert!(xml.contains("&quot;quotes&quot;"));
    }

    #[test]
    fn empty_feed_is_valid() {
        let xml = render_project_feed(
            "Empty",
            "empty",
            "No items",
            "user",
            &[],
            "https://makenot.work",
        );

        assert!(xml.contains("<title>Empty</title>"));
        assert!(!xml.contains("<item>"));
    }

    #[test]
    fn blog_feed_is_valid_xml_structure() {
        let items = sample_items("https://makenot.work");
        let xml = render_blog_feed(
            "My Project",
            "my-project",
            "A cool project",
            "creator",
            &items,
            "https://makenot.work",
        );

        assert!(xml.starts_with(r#"<?xml version="1.0" encoding="UTF-8"?>"#));
        assert!(xml.contains("<title>My Project - Blog</title>"));
        assert!(xml.contains("<link>https://makenot.work/p/my-project/blog</link>"));
        assert!(xml.contains("creator"));
        assert!(xml.contains("<item>"));
    }

    #[test]
    fn xml_escape_all_special_chars() {
        assert_eq!(xml_escape("&"), "&amp;");
        assert_eq!(xml_escape("<"), "&lt;");
        assert_eq!(xml_escape(">"), "&gt;");
        assert_eq!(xml_escape("\""), "&quot;");
        assert_eq!(xml_escape("'"), "&apos;");
    }

    #[test]
    fn xml_escape_combined() {
        assert_eq!(
            xml_escape("Tom & Jerry <\"friends\">"),
            "Tom &amp; Jerry &lt;&quot;friends&quot;&gt;"
        );
    }

    #[test]
    fn xml_escape_no_special_chars() {
        assert_eq!(xml_escape("plain text 123"), "plain text 123");
    }

    #[test]
    fn xml_escape_empty_string() {
        assert_eq!(xml_escape(""), "");
    }

    #[test]
    fn xml_escape_double_ampersand() {
        // Ensure & is not double-escaped
        assert_eq!(xml_escape("&amp;"), "&amp;amp;");
    }

    #[test]
    fn pub_date_is_rfc2822() {
        let date = Utc.with_ymd_and_hms(2026, 3, 15, 14, 30, 0).unwrap();
        let item = FeedItem {
            title: "Test".to_string(),
            link: "https://example.com".to_string(),
            description: "desc".to_string(),
            pub_date: date,
            guid: "guid-1".to_string(),
        };
        let xml = render_feed("T", "https://example.com", "D", &[item]);
        // RFC 2822 format: "Sun, 15 Mar 2026 14:30:00 +0000"
        assert!(xml.contains("<pubDate>Sun, 15 Mar 2026 14:30:00 +0000</pubDate>"));
    }

    #[test]
    fn last_build_date_uses_first_item() {
        let items = sample_items("https://example.com");
        let xml = render_feed("T", "https://example.com", "D", &items);
        // First item is 2026-01-15
        assert!(xml.contains("<lastBuildDate>Thu, 15 Jan 2026 12:00:00 +0000</lastBuildDate>"));
    }

    #[test]
    fn empty_feed_still_has_last_build_date() {
        let xml = render_feed("T", "https://example.com", "D", &[]);
        assert!(xml.contains("<lastBuildDate>"));
    }

    #[test]
    fn feed_with_many_items() {
        let items: Vec<FeedItem> = (0..50)
            .map(|i| FeedItem {
                title: format!("Item {}", i),
                link: format!("https://example.com/{}", i),
                description: format!("Description {}", i),
                pub_date: Utc.with_ymd_and_hms(2026, 1, 1, 0, 0, 0).unwrap(),
                guid: format!("guid-{}", i),
            })
            .collect();
        let xml = render_feed("Bulk", "https://example.com", "50 items", &items);
        // Count <item> occurrences
        let count = xml.matches("<item>").count();
        assert_eq!(count, 50);
    }

    #[test]
    fn render_feed_custom_passes_through() {
        let xml = render_feed_custom("Custom", "https://custom.com", "Custom desc", &[]);
        assert!(xml.contains("<title>Custom</title>"));
        assert!(xml.contains("<link>https://custom.com</link>"));
        assert!(xml.contains("<description>Custom desc</description>"));
    }

    #[test]
    fn project_feed_link_format() {
        let xml = render_project_feed(
            "Proj",
            "my-slug",
            "desc",
            "alice",
            &[],
            "https://makenot.work",
        );
        assert!(xml.contains("<link>https://makenot.work/p/my-slug</link>"));
        assert!(xml.contains("<description>desc by alice</description>"));
    }

    #[test]
    fn creator_feed_link_format() {
        let xml = render_creator_feed(
            "Alice",
            "alice",
            "Makes things",
            &[],
            "https://makenot.work",
        );
        assert!(xml.contains("<link>https://makenot.work/u/alice</link>"));
    }

    #[test]
    fn blog_feed_link_and_title_format() {
        let xml = render_blog_feed(
            "My Project",
            "my-proj",
            "A project",
            "bob",
            &[],
            "https://makenot.work",
        );
        assert!(xml.contains("<title>My Project - Blog</title>"));
        assert!(xml.contains("<link>https://makenot.work/p/my-proj/blog</link>"));
        assert!(xml.contains("Blog posts from A project by bob"));
    }

    #[test]
    fn guid_is_not_permalink() {
        let items = vec![FeedItem {
            title: "T".to_string(),
            link: "https://example.com".to_string(),
            description: "D".to_string(),
            pub_date: Utc::now(),
            guid: "unique-id".to_string(),
        }];
        let xml = render_feed("T", "https://example.com", "D", &items);
        assert!(xml.contains("<guid isPermaLink=\"false\">unique-id</guid>"));
    }

    #[test]
    fn special_chars_in_title_and_description_escaped_in_channel() {
        let xml = render_feed(
            "Tom & Jerry's <Show>",
            "https://example.com?a=1&b=2",
            "A \"great\" show",
            &[],
        );
        assert!(xml.contains("<title>Tom &amp; Jerry&apos;s &lt;Show&gt;</title>"));
        assert!(xml.contains("<link>https://example.com?a=1&amp;b=2</link>"));
        assert!(xml.contains("<description>A &quot;great&quot; show</description>"));
    }
}