.maximumSize(fessConfig.getSuggestPopularWordCacheSizeAsInteger().longValue())
                        .expireAfterWrite(fessConfig.getSuggestPopularWordCacheExpireAsInteger().longValue(), TimeUnit.MINUTES)
                        .build();
            }
        };
        popularWordHelper.init();
    }

    @Test
    public void test_getCacheKey_allParameters() {
        String seed = "test_seed";

        assertNotNull(helper.userInfoCache);
        assertNotNull(helper.searchLogLogger);
    }

    @Test
    public void test_setUserCheckInterval() {
        long interval = 5 * 60 * 1000L; // 5 minutes
        searchLogHelper.setUserCheckInterval(interval);
        assertEquals(interval, searchLogHelper.userCheckInterval);
    }

    @Test
    public void test_setUserInfoCacheSize() {
        int cacheSize = 5000;

        if (config != null) {
            final Integer timeToLive = config.getTimeToLive();
            if (timeToLive != null) {
                // timeToLive minutes
                final long now = ComponentUtil.getSystemHelper().getCurrentTimeAsLong();
                return new Date(now + timeToLive.longValue() * 1000 * 60);
            }
        }

     * The cache is configured with a maximum size of 100 entries and expires after 10 minutes.
     */
    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initializing {}", this.getClass().getSimpleName());
        }
        crawlingConfigCache = CacheBuilder.newBuilder().maximumSize(100).expireAfterWrite(10, TimeUnit.MINUTES).build();
    }

    /**

        testBoundaryValue(1L);
        testBoundaryValue(-1L);

        // Test one second boundaries
        testBoundaryValue(1000L);
        testBoundaryValue(-1000L);

        // Test one minute boundaries
        testBoundaryValue(60000L);
        testBoundaryValue(-60000L);

        // Test one hour boundaries
        testBoundaryValue(3600000L);
        testBoundaryValue(-3600000L);

    /**
     * Cache for storing available artifacts by type.
     * The cache expires after 5 minutes and has a maximum size of 10 entries.
     */
    protected LoadingCache<ArtifactType, Artifact[]> availableArtifacts = CacheBuilder.newBuilder()
            .maximumSize(10)
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .build(new CacheLoader<ArtifactType, Artifact[]>() {
                @Override

            popularWordHelper.clearCache();
        }
    }

    /**
     * Sets the interval for storing search logs.
     *
     * @param searchStoreInterval The search store interval in minutes.
     */
    public void setSearchStoreInterval(final long searchStoreInterval) {
        this.searchStoreInterval = searchStoreInterval;
    }

    protected final Set<String> inlineMimeTypeSet = new HashSet<>();

    /** Cache for facet responses */
    protected Cache<String, FacetResponse> facetCache;

    /** Duration for facet cache in seconds (10 minutes) */
    protected long facetCacheDuration = 60 * 10L;

    /** Length of text fragment prefix */
    protected int textFragmentPrefixLength;

    /** Length of text fragment suffix */

    /** Default cron expression for general scheduling (daily at midnight). */
    public static final String DEFAULT_CRON_EXPRESSION = "0 0 * * *";

    /** Default cron expression for search log processing (every minute). */
    public static final String DEFAULT_SEARCH_LOG_CRON_EXPRESSION = "* * * * *";

    /** Default cron expression for daily tasks (daily at midnight). */

# Whether RAG chat feature is enabled.
rag.chat.enabled=false


# Chat generation settings.
rag.chat.context.max.documents=5

# Session settings.
rag.chat.session.timeout.minutes=30
rag.chat.session.max.size=10000
rag.chat.history.max.messages=30

# Enhanced RAG flow settings.
# Fields to retrieve for full document content.