import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryBuilders;

/**
 * Query command for handling wildcard queries.
 * Converts Lucene WildcardQuery objects to OpenSearch QueryBuilder objects,
 * supporting wildcard pattern matching with configurable case sensitivity.
 */
public class WildcardQueryCommand extends QueryCommand {

    /**
     * Default constructor.
     */

# Test robots.txt for wildcard (*) and end-of-path ($) support
# Based on RFC 9309 specification

# Test wildcard patterns
User-agent: WildcardBot
Disallow: /*.pdf$
Disallow: /admin/*.php
Disallow: /*/private/
Allow: /public/*.html

# Test end-of-path ($) patterns
User-agent: EndPathBot
Disallow: /fish$
Disallow: /temp$
Allow: /fishing

# Test complex patterns
User-agent: ComplexBot
Disallow: /
Allow: /$

 *   <li>Manages crawl delay settings per user agent</li>
 *   <li>Stores sitemap URLs listed in robots.txt</li>
 * </ul>
 *
 * <p>The class uses case-insensitive pattern matching for user agents and supports
 * wildcard characters (*) in user agent strings. When multiple directives match a user agent,
 * the most specific (longest) match is used.</p>
 *
 */
public class RobotsTxt {
    private static final String ALL_BOTS = "*";

        }
        return value;
    }

    /**
     * Sets the lowercase wildcard flag.
     *
     * @param lowercaseWildcard the lowercase wildcard flag
     */
    public void setLowercaseWildcard(final boolean lowercaseWildcard) {
        this.lowercaseWildcard = lowercaseWildcard;
    }

     */
    protected Map<String, CorsHandler> handerMap = new HashMap<>();

    /**
     * Adds a CORS handler for the specified origin.
     *
     * @param origin the origin pattern (can be "*" for wildcard)
     * @param handler the CORS handler to associate with the origin
     */
    public void add(final String origin, final CorsHandler handler) {
        if (logger.isDebugEnabled()) {

        try {
            robotsTxt = robotsTxtHelper.parse(in);
        } finally {
            CloseableUtil.closeQuietly(in);
        }

        // Test WildcardBot - wildcard patterns
        // Disallow: /*.pdf$ - should block .pdf files but not .pdf with query params
        assertFalse(robotsTxt.allows("/document.pdf", "WildcardBot"));

/**
 * Robots.txt Parser following RFC 9309 specification.
 *
 * <p>This implementation supports the following features:</p>
 * <ul>
 * <li>User-agent directive with wildcard (*) matching</li>
 * <li>Disallow and Allow directives with pattern matching</li>
 * <li>Wildcard (*) in paths - matches any sequence of characters</li>
 * <li>End-of-path ($) matching - matches the end of URL path</li>
 * <li>Crawl-delay directive</li>

        }
    }

    /**
     * Escapes wildcard characters in the given query string.
     *
     * This method replaces all occurrences of '*' with '\*' and
     * all occurrences of '?' with '\?' to ensure that these characters
     * are treated as literals rather than wildcard characters in queries.
     *
     * @param query the query string to escape

        context.addFieldLog(field, text);
        context.addHighlightedQuery(text);
        return QueryBuilders.termQuery(field, text).boost(boost);
    }

    /**
     * Converts a term query to a wildcard query for URL field matching.
     *
     * @param fessConfig the Fess configuration
     * @param context the query context
     * @param termQuery the term query to convert
     * @param boost the boost value to apply

        assertNotNull(matched);
        assertEquals("MyBot", matched.getUserAgent());
    }

    public void test_getMatchedDirectiveWithWildcard() {
        // Test getMatchedDirective with wildcard
        RobotsTxt robotsTxt = new RobotsTxt();

        Directive directive = new Directive("*");
        directive.addDisallow("/private/");
        robotsTxt.addDirective(directive);