scraps 2.1.0

use std::collections::HashMap;

use crate::error::ScrapsResult;
use scraps_libs::model::context::Ctx;
use scraps_libs::model::scrap::Scrap;
use scraps_libs::model::title::Title;
use scraps_libs::search::engine::{SearchEngine, SearchLogic};
use scraps_libs::search::fuzzy_engine::FuzzySearchEngine;

#[derive(Debug, Clone, PartialEq)]
pub struct SearchResult {
    pub title: Title,
    pub ctx: Option<Ctx>,
    pub md_text: 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 title-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 (title + body for search)
        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.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| {
                // Find the corresponding scrap by title using HashMap
                scrap_map.get(&result.title).map(|scrap| {
                    let scrap_key = &scrap.self_key();
                    let title: Title = scrap_key.into();
                    let ctx: Option<Ctx> = scrap_key.into();

                    SearchResult {
                        title,
                        ctx,
                        md_text: scrap.md_text().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.title.to_string().contains("test")));
        // Verify md_text is present
        assert!(results.iter().all(|r| !r.md_text.is_empty()));
    }

    #[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.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.title.to_string()).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].title.to_string(), "mydoc");
    }
}