scraps 3.7.0

use std::collections::HashMap;

use crate::error::ScrapsResult;
use crate::usecase::scrap::scrap_ref::ScrapRef;
use scraps_libs::markdown::query::body;
use scraps_libs::model::scrap::Scrap;

use scraps_libs::search::engine::{SearchEngine, SearchLogic};
use scraps_libs::search::fuzzy_engine::FuzzySearchEngine;

#[derive(Debug, Clone, PartialEq)]
pub struct SearchResult {
    pub scrap: ScrapRef,
    pub md_text: String,
    pub description: Option<String>,
}

pub struct SearchUsecase;

impl SearchUsecase {
    pub fn new() -> SearchUsecase {
        SearchUsecase
    }

    pub fn execute(
        &self,
        scraps: &[Scrap],
        query: &str,
        num: usize,
        logic: SearchLogic,
    ) -> ScrapsResult<Vec<SearchResult>> {
        // Create key-to-scrap mapping for efficient lookup
        let scrap_map: HashMap<String, &Scrap> = scraps
            .iter()
            .map(|scrap| (scrap.self_key().to_string(), scrap))
            .collect();

        // Create search items in memory: key and body, and the title when the
        // scrap has one of its own
        let lib_items: Vec<scraps_libs::search::result::SearchItem> = scraps
            .iter()
            .map(|scrap| {
                scraps_libs::search::result::SearchItem::new(
                    &scrap.self_key().to_string(),
                    scrap.frontmatter_title(),
                    body(scrap.md_text()),
                )
            })
            .collect();

        // Perform search
        let engine = FuzzySearchEngine::new();
        let search_results = engine.search(&lib_items, query, num, logic);

        // Convert to final results using HashMap lookup
        let results: Vec<SearchResult> = search_results
            .into_iter()
            .filter_map(|result| {
                scrap_map.get(&result.key).map(|scrap| SearchResult {
                    scrap: (*scrap).into(),
                    md_text: scrap.md_text().to_string(),
                    description: scrap.description().map(str::to_string),
                })
            })
            .collect();

        Ok(results)
    }
}

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

    #[test]
    fn it_run() {
        let scraps = vec![
            Scrap::new(
                "test1",
                &None,
                "# Test Document 1\nThis is a test document.",
            ),
            Scrap::new("test2", &None, "# Another Document\nAnother test content."),
        ];

        let usecase = SearchUsecase::new();

        let results = usecase
            .execute(&scraps, "test", 100, SearchLogic::And)
            .unwrap();

        // Should find documents containing "test"
        assert!(!results.is_empty());
        assert!(results.iter().any(|r| r.scrap.title.contains("test")));
        // Verify md_text is present
        assert!(results.iter().all(|r| !r.md_text.is_empty()));
    }

    #[test]
    fn it_does_not_match_the_frontmatter_block() {
        let text = "---\nowner: zebra\n---\n\n# Orders\n";
        let scraps = vec![Scrap::new("orders", &None, text)];
        let usecase = SearchUsecase::new();

        let in_block = usecase
            .execute(&scraps, "zebra", 100, SearchLogic::And)
            .unwrap();
        assert!(in_block.is_empty());

        let in_body = usecase
            .execute(&scraps, "Orders", 100, SearchLogic::And)
            .unwrap();
        assert_eq!(in_body.len(), 1);
        assert_eq!(in_body[0].md_text, text);
    }

    #[test]
    fn it_handles_duplicate_titles() {
        // Two scraps with the same title but different contexts (ctx/ and root)
        let scraps = vec![
            Scrap::new(
                "duplicate",
                &Some("ctx".into()),
                "# Duplicate\nContent in ctx directory.",
            ),
            Scrap::new(
                "duplicate",
                &None,
                "# Duplicate\nContent in root directory.",
            ),
        ];

        let usecase = SearchUsecase::new();

        let results = usecase
            .execute(&scraps, "duplicate", 100, SearchLogic::And)
            .unwrap();

        // Should find both scraps with the same title but different contexts
        assert_eq!(
            results.len(),
            2,
            "Expected 2 results for duplicate titles with different contexts, got {}. \
            This indicates the HashMap is overwriting duplicate titles.",
            results.len()
        );

        // Verify content is different
        let md_texts: std::collections::HashSet<String> =
            results.iter().map(|r| r.md_text.clone()).collect();
        assert_eq!(
            md_texts.len(),
            2,
            "Expected 2 unique content texts, got {}",
            md_texts.len()
        );

        // Verify ctx field separation works correctly
        // One result should have ctx: Some("ctx"), the other should have ctx: None
        let ctx_values: std::collections::HashSet<Option<String>> = results
            .iter()
            .map(|r| r.scrap.ctx().as_ref().map(|c| c.to_string()))
            .collect();
        assert_eq!(
            ctx_values.len(),
            2,
            "Expected 2 different ctx values (Some and None), got {:?}",
            ctx_values
        );

        // Verify that one result has ctx "ctx" and the other has None
        assert!(
            ctx_values.contains(&Some("ctx".to_string())),
            "Expected one result to have ctx 'ctx', but found {:?}",
            ctx_values
        );
        assert!(
            ctx_values.contains(&None),
            "Expected one result to have ctx None, but found {:?}",
            ctx_values
        );

        // Verify that both results have the same title "Duplicate"
        let titles: std::collections::HashSet<String> =
            results.iter().map(|r| r.scrap.title.clone()).collect();
        assert_eq!(
            titles.len(),
            1,
            "Expected all results to have the same title 'Duplicate', but got {:?}",
            titles
        );
        assert!(
            titles.contains("duplicate"),
            "Expected title to be 'duplicate', but got {:?}",
            titles
        );
    }

    /// Test: search matches body content, not just title
    #[test]
    fn it_searches_body_content() {
        let scraps = vec![Scrap::new(
            "mydoc",
            &None,
            "# mydoc\n\nThis body contains uniquekeyword here.",
        )];

        let usecase = SearchUsecase::new();

        // Search by body-only keyword - should match
        let results = usecase
            .execute(&scraps, "uniquekeyword", 100, SearchLogic::And)
            .unwrap();

        assert_eq!(results.len(), 1, "Body keyword should match scrap");
        assert_eq!(results[0].scrap.title, "mydoc");
    }
}