# 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: /$
Allow: /index.html$
Allow: /public/

/**
 * A factory class for managing and creating crawler clients based on URL patterns.
 * This class implements AutoCloseable to properly handle resource cleanup.
 *
 * <p>The factory maintains a map of regular expression patterns to crawler clients,
 * allowing for URL-based client selection. Clients can be added with specific patterns
 * and optionally at specific positions in the processing order.</p>
 *

        private final int priorityLength;

        /**
         * Constructs a new PathPattern from the given robots.txt path pattern.
         * @param pattern the path pattern string from robots.txt (may contain * and $)
         */
        public PathPattern(final String pattern) {
            this.pattern = pattern;

    /**
     * Retrieves a list of URL patterns to include for a given session.
     *
     * @param sessionId the ID of the session for which to retrieve the include URL patterns
     * @return a list of compiled regular expression patterns representing the URLs to include
     */
    List<Pattern> getIncludeUrlPatternList(String sessionId);

    /**
     * Retrieves a list of URL patterns to be excluded for a given session.
     *

    }

    /**
     * Gets the list of include URL patterns for the specified session.
     *
     * @param sessionId The session ID.
     * @return The list of compiled include patterns.
     * @throws CrawlerSystemException if the patterns cannot be loaded.
     */
    @Override
    public List<Pattern> getIncludeUrlPatternList(final String sessionId) {
        try {

    /** Map of session IDs to include URL patterns for filtering URLs. */
    protected volatile Map<String, List<Pattern>> includeUrlPatternMap = new HashMap<>();

    /** Map of session IDs to exclude URL patterns for filtering URLs. */
    protected volatile Map<String, List<Pattern>> excludeUrlPatternMap = new HashMap<>();

    /**
     * Creates a new MemoryDataHelper instance.

                .getTotalHits()
                .value() > 0);

        // Verify pattern can be retrieved
        final List<Pattern> patterns = urlFilterService.getIncludeUrlPatternList(sessionId);
        assertEquals(1, patterns.size());
        assertTrue(patterns.get(0).matcher("http://example.com/page1").matches());
        assertFalse(patterns.get(0).matcher("http://other.com/page1").matches());

    }

    /**
     * Converts a GSA URL pattern into a regular expression pattern suitable for Fess.
     * Handles various GSA pattern formats including regexp, contains, and URL-based patterns.
     *
     * @param s the input GSA pattern string
     * @return a regular expression pattern string, or empty string for comments/invalid patterns
     */
    protected String getFilterPath(final String s) {

     * @param regex the regular expression pattern
     */
    public void addRule(final String key, final String regex) {
        regexMap.put(key, Pattern.compile(regex));
    }

    /**
     * Adds a compiled regular expression rule for the specified field.
     * @param key the field name to match against
     * @param pattern the compiled regular expression pattern
     */

        String sessionId = "test-session-024";
        urlFilter.init(sessionId);

        // Test empty pattern
        urlFilter.addInclude("");
        urlFilter.addExclude("");

        // Test single character pattern
        urlFilter.addInclude(".");
        urlFilter.addExclude("*");

        // Test patterns with only special characters
        urlFilter.addInclude("^$");
        urlFilter.addExclude(".*");