{
  "_id": "_design/sw360_search",
  "nouveau": {
    "indexes": {
      "projects": {
        "default_analyzer": "standard",
        "field_analyzers": {
          "default": "standard",
          "default_ngram": "whitespace",
          "name_exact": "standard",
          "name_ngram": "whitespace",
          "version_ngram": "keyword",
          "tag_ngram": "whitespace"
        },
        "index": "function(doc) {
          if (doc.type === 'project') {

            // Helper function to generate Edge N-Grams in JavaScript
            function emitEdgeNGrams(fieldName, text, minGram, maxGram) {
              if (!text) return;
              var words = text.toLowerCase().split(/\\s+/);
              for (var i = 0; i < words.length; i++) {
                var word = words[i];
                var limit = Math.min(word.length, maxGram);
                for (var len = minGram; len <= limit; len++) {
                  index('text', fieldName, word.substring(0, len));
                }
              }
            }

            // --- 1. RESERVED 'DEFAULT' FIELD (CATCH-ALL GENERIC SEARCH) ---
            if (doc.name) {
              index('text', 'default', doc.name);
              emitEdgeNGrams('default_ngram', doc.name, 2, MAX_GRAM_BOUND);
            }
            if (doc.description) {
              index('text', 'default', doc.description);
            }
            if (doc.version) {
              index('text', 'default', doc.version);
            }
            if (doc.tag) {
              index('text', 'default', doc.tag);
            }

            // --- 2. SPECIFIC FIELD PREFIX & EXACT FIELDS ---
            if (doc.name) {
              index('text', 'name_exact', doc.name);
              emitEdgeNGrams('name_ngram', doc.name, 2, 25);
              index('string', 'name_sort', doc.name.toLowerCase());
            }

            if (doc.version) {
              var ver = doc.version.toLowerCase();
              emitEdgeNGrams('version_ngram', ver, 1, ver.length);
              index('string', 'version_sort', ver);
            }

            if (doc.tag) {
               emitEdgeNGrams('tag_ngram', doc.tag, 2, 10);
            }

            // --- 3. EXACT MATCH ONLY FIELDS ---
            if (doc.license) {
              index('string', 'license', doc.license);
            }

            // --- 4. SORTABLE NUMERIC / DATE FIELDS ---
            if (doc.createdOn) {
              index('double', 'created_on', doc.createdOn);
            }
          }
        }"
      }
    }
  }
}

package org.eclipse.sw360.datahandler.search;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class SW360NouveauSearchBuilder {

    private static final int MAX_GRAM_CAP = 25;

    /**
     * Constructs a tiered Lucene query string for a target field.
     */
    public static String buildFieldQuery(String fieldExact, String fieldNgram, String rawInput) {
        if (rawInput == null || rawInput.trim().isEmpty()) {
            return "*:*";
        }

        String trimmed = rawInput.trim();

        // Exact phrase search if quoted
        if (trimmed.startsWith("\"") && trimmed.endsWith("\"") && trimmed.length() > 2) {
            String phrase = trimmed.substring(1, trimmed.length() - 1);
            // + name_exact:"My test project"
            return "+" + fieldExact + ":\"" + sanitizeLuceneChars(phrase) + "\"";
        }

        String[] tokens = Arrays.stream(trimmed.split("\\s+"))
                .map(SW360NouveauSearchBuilder::sanitizeLuceneChars)
                .filter(s -> !s.isEmpty())
                .toArray(String[]::new);

        if (tokens.length == 0) {
            return "*:*";
        }

        // Single-word query pattern
        if (tokens.length == 1) {
            String token = capToken(tokens[0].toLowerCase());
            // (name_exact:my^100 OR name_ngram:my)
            return String.format("(%s:%s^100 OR %s:%s)", fieldExact, token, fieldNgram, token);
        }

        // Multi-word tiered query pattern
        String fullPhrase = String.join(" ", tokens);
        String phraseClause = fieldExact + ":\"" + fullPhrase + "\"^100";

        StringBuilder andClause = new StringBuilder();
        andClause.append("(");
        for (int i = 0; i < tokens.length; i++) {
            if (i > 0) {
                andClause.append(" AND ");
            }
            if (i == tokens.length - 1) {
                // Last token uses n-gram for prefix matching
                andClause.append(fieldNgram).append(":").append(capToken(tokens[i].toLowerCase()));
            } else {
                // Earlier tokens use exact match
                andClause.append(fieldExact).append(":").append(tokens[i].toLowerCase());
            }
        }
        andClause.append(")");

        /*
         * (
         *   name_exact:"My test project"^100
         *   OR
         *   (
         *     name_exact:my AND name_exact:test AND name_ngram:project
         *   )
         * )
         */
        return String.format("(%s OR %s)", phraseClause, andClause.toString());
    }

    /**
     * Constructs generic "search anything" bar queries targeting reserved 'default' fields.
     */
    public static String buildGenericQuery(String genericInput) {
        return buildFieldQuery("default", "default_ngram", genericInput);
    }

    /**
     * Combines multiple explicit field criteria into a composite query.
     */
    public static String buildCompositeQuery(String nameInput, String version, String tag, String vendor) {
        List<String> clauses = new ArrayList<>();

        if (nameInput != null && !nameInput.trim().isEmpty()) {
            clauses.add("+(" + buildFieldQuery("name_exact", "name_ngram", nameInput) + ")");
        }
        if (version != null && !version.trim().isEmpty()) {
            clauses.add("+version_ngram:" + capToken(sanitizeLuceneChars(version.trim().toLowerCase())));
        }
        if (tag != null && !tag.trim().isEmpty()) {
            clauses.add("+tag_ngram:" + capToken(sanitizeLuceneChars(tag.trim().toLowerCase())));
        }
        if (vendor != null && !vendor.trim().isEmpty()) {
            clauses.add("+vendor:\"" + sanitizeLuceneChars(vendor.trim()) + "\"");
        }

        if (clauses.isEmpty()) {
            return "*:*";
        }

        /*
         * +(name_exact:"My test project"^100 OR (name_exact:my AND name_exact:test AND name_ngram:project))
         * AND
         * +version_ngram:1.0.0
         * AND
         * +tag_ngram:department
         * AND
         * +vendor:"eclipse"
         */
        return String.join(" AND ", clauses);
    }

    /**
     * Maps UI column sort requests directly to Nouveau sort parameters.
     * Uses more than 1 tiebreaker field to ensure deterministic sort order for identical values.
     */
    public static List<String> buildSortParameters(String uiColumn, boolean isAscending) {
        String direction = isAscending ? "" : "-";

        if (uiColumn == null || uiColumn.isEmpty() || "score".equalsIgnoreCase(uiColumn)) {
            return List.of("relevance", "name_sort", "version_sort");
        }

        return switch (uiColumn.toLowerCase()) {
            case "name" -> List.of(direction + "name_sort", "relevance", "version_sort");
            case "version" -> List.of(direction + "version_sort", "name_sort", "relevance");
            case "vendor" -> List.of(direction + "vendor_sort", "name_sort", "relevance");
            case "createdon", "date" -> List.of(direction + "created_on", "name_sort");
            default -> List.of(direction + uiColumn, "relevance");
        };
    }

    /**
     * Calculates the top-N limit to fetch from CouchDB Nouveau in a single query.
     */
    public static int calculateFetchLimit(int pageNumber, int pageSize) {
        int page = Math.max(1, pageNumber);
        int size = Math.max(1, pageSize);
        return page * size;
    }

    /**
     * Extracts the requested page sublist in Java memory from the single top-N result set.
     */
    public static <T> List<T> extractPageSublist(List<T> allHits, int pageNumber, int pageSize) {
        if (allHits == null || allHits.isEmpty()) {
            return List.of();
        }
        int page = Math.max(1, pageNumber);
        int size = Math.max(1, pageSize);

        int startIndex = (page - 1) * size;
        if (startIndex >= allHits.size()) {
            return List.of();
        }
        int endIndex = Math.min(startIndex + size, allHits.size());
        return allHits.subList(startIndex, endIndex);
    }

    private static String capToken(String token) {
        return token.length() > MAX_GRAM_CAP ? token.substring(0, MAX_GRAM_CAP) : token;
    }

    private static String sanitizeLuceneChars(String input) {
        if (input == null) return "";
        return input.replaceAll("([+\\-!\\(\\)\\{\\}\\[\\]\\^\"\\~\\*\\?\\:\\\\/])", "\\\\$1")
                .replaceAll("&&", "\\\\&&")
                .replaceAll("\\|\\|", "\\\\||")
        ;
    }
}