SearchEngine.java

import java.util.*;

/**
 * Handles search queries and ranks documents.
 */
public class SearchEngine {

    private final InvertedIndex index;
    private final TFIDFCalculator tfidf;

    public SearchEngine(InvertedIndex index) {
        this.index = index;
        this.tfidf = new TFIDFCalculator(index);
    }

    /**
     * Searches query and returns ranked document IDs.
     */

    /**
 * Returns TF-IDF scores for each document for a given query.
 */
public Map<Integer, Double> getDocumentScores(String query) {

    List<String> terms = Tokenizer.tokenize(query);
    Map<Integer, Double> scoreMap = new HashMap<>();

    for (String term : terms) {
        Map<Integer, Integer> docs = index.getDocuments(term);

        for (int docId : docs.keySet()) {
            double score = tfidf.computeTFIDF(term, docId);
            scoreMap.put(docId, scoreMap.getOrDefault(docId, 0.0) + score);
        }
    }

    return scoreMap;
}

    public List<Integer> search(String query) {

        List<String> terms = Tokenizer.tokenize(query);
        Map<Integer, Double> scoreMap = new HashMap<>();

        for (String term : terms) {
            Map<Integer, Integer> docs = index.getDocuments(term);

            for (int docId : docs.keySet()) {
                double score = tfidf.computeTFIDF(term, docId);
                scoreMap.put(docId, scoreMap.getOrDefault(docId, 0.0) + score);
            }
        }

        PriorityQueue<Map.Entry<Integer, Double>> pq =
            new PriorityQueue<>((a, b) -> Double.compare(b.getValue(), a.getValue()));

        pq.addAll(scoreMap.entrySet());

        List<Integer> result = new ArrayList<>();
        while (!pq.isEmpty()) {
            result.add(pq.poll().getKey());
        }

        return result;
    }

     public void printTopKPerTerm(
            String query,
            int k,
            Map<Integer, Document> documentStore
    ) {

        List<String> terms = Tokenizer.tokenize(query);

        for (String term : terms) {

            System.out.println("\nTop " + k + " documents for word: \"" + term + "\"");

            Map<Integer, Integer> docs = index.getDocuments(term);

            if (docs.isEmpty()) {
                System.out.println("  No documents found.");
                continue;
            }

            PriorityQueue<Map.Entry<Integer, Double>> pq =
                new PriorityQueue<>((a, b) -> Double.compare(b.getValue(), a.getValue()));

            // Calculate TF-IDF for this term in each document
            for (int docId : docs.keySet()) {
                double score = tfidf.computeTFIDF(term, docId);
                pq.add(Map.entry(docId, score));
            }

            int count = 0;
            while (!pq.isEmpty() && count < k) {
                Map.Entry<Integer, Double> entry = pq.poll();

                Document doc = documentStore.get(entry.getKey());

                System.out.printf(
                    "  • %s (score = %.4f)%n",
                    doc.getContent(),
                    entry.getValue()
                );
                count++;
            }
        }
    }
}