package tech.easyflow.ai.easyagentsflow.config;

import org.springframework.boot.context.properties.ConfigurationProperties;

import java.time.Duration;

/**
 * 工作流调度运行时配置。
 */
@ConfigurationProperties(prefix = "easyflow.workflow.runtime")
public class WorkflowRuntimeProperties {

    private Duration triggerScanInterval = Duration.ofSeconds(5);
    private int schedulerThreads = 2;
    private int workerCoreSize = 32;
    private int workerMaxSize = 256;
    private int workerQueueCapacity = 256;
    private int childWorkflowLaneMaxDepth = 32;
    private int childWorkflowLaneMaxThreads = 16;
    private int childWorkflowRootPermits = 32;
    private Duration childWorkflowPollInterval =
            Duration.ofMillis(500);
    private int dataWriteBatchSize = 200;
    private long downloadMaxBytes = 2L * 1024L * 1024L * 1024L;
    private int definitionCacheMaxEntries = 512;
    private long definitionCacheMaxBytes =
            256L * 1024L * 1024L;
    private Duration definitionCacheExpireAfterAccess = Duration.ofMinutes(30);

    /**
     * 获取触发器补偿扫描间隔。
     *
     * @return 扫描间隔
     */
    public Duration getTriggerScanInterval() {
        return triggerScanInterval;
    }

    /**
     * 设置触发器补偿扫描间隔。
     *
     * @param triggerScanInterval 扫描间隔
     */
    public void setTriggerScanInterval(Duration triggerScanInterval) {
        this.triggerScanInterval = triggerScanInterval;
    }

    /**
     * 获取调度线程数。
     *
     * @return 调度线程数
     */
    public int getSchedulerThreads() {
        return schedulerThreads;
    }

    /**
     * 设置调度线程数。
     *
     * @param schedulerThreads 调度线程数
     */
    public void setSchedulerThreads(int schedulerThreads) {
        this.schedulerThreads = schedulerThreads;
    }

    /**
     * 获取工作线程核心数。
     *
     * @return 核心线程数
     */
    public int getWorkerCoreSize() {
        return workerCoreSize;
    }

    /**
     * 设置工作线程核心数。
     *
     * @param workerCoreSize 核心线程数
     */
    public void setWorkerCoreSize(int workerCoreSize) {
        this.workerCoreSize = workerCoreSize;
    }

    /**
     * 获取工作线程最大数。
     *
     * @return 最大线程数
     */
    public int getWorkerMaxSize() {
        return workerMaxSize;
    }

    /**
     * 设置工作线程最大数。
     *
     * @param workerMaxSize 最大线程数
     */
    public void setWorkerMaxSize(int workerMaxSize) {
        this.workerMaxSize = workerMaxSize;
    }

    /**
     * 获取工作队列容量。
     *
     * @return 队列容量
     */
    public int getWorkerQueueCapacity() {
        return workerQueueCapacity;
    }

    /**
     * 设置工作队列容量。
     *
     * @param workerQueueCapacity 队列容量
     */
    public void setWorkerQueueCapacity(int workerQueueCapacity) {
        this.workerQueueCapacity = workerQueueCapacity;
    }

    /**
     * 获取子工作流独立通道覆盖的最大嵌套深度。
     *
     * @return 最大深度
     */
    public int getChildWorkflowLaneMaxDepth() {
        return childWorkflowLaneMaxDepth;
    }

    /**
     * 设置子工作流独立通道覆盖的最大嵌套深度。
     *
     * @param childWorkflowLaneMaxDepth 最大深度
     */
    public void setChildWorkflowLaneMaxDepth(
            int childWorkflowLaneMaxDepth) {
        this.childWorkflowLaneMaxDepth =
                childWorkflowLaneMaxDepth;
    }

    /**
     * 获取每个子工作流深度通道的最大线程数。
     *
     * @return 最大线程数
     */
    public int getChildWorkflowLaneMaxThreads() {
        return childWorkflowLaneMaxThreads;
    }

    /**
     * 设置每个子工作流深度通道的最大线程数。
     *
     * @param childWorkflowLaneMaxThreads 最大线程数
     */
    public void setChildWorkflowLaneMaxThreads(
            int childWorkflowLaneMaxThreads) {
        this.childWorkflowLaneMaxThreads =
                childWorkflowLaneMaxThreads;
    }

    /**
     * 获取根级同步子工作流并发许可数。
     *
     * @return 并发许可数
     */
    public int getChildWorkflowRootPermits() {
        return childWorkflowRootPermits;
    }

    /**
     * 设置根级同步子工作流并发许可数。
     *
     * @param childWorkflowRootPermits 并发许可数
     */
    public void setChildWorkflowRootPermits(
            int childWorkflowRootPermits) {
        this.childWorkflowRootPermits =
                childWorkflowRootPermits;
    }

    /**
     * 获取同步等待持久终态的轮询间隔。
     *
     * @return 轮询间隔
     */
    public Duration getChildWorkflowPollInterval() {
        return childWorkflowPollInterval;
    }

    /**
     * 设置同步等待持久终态的轮询间隔。
     *
     * @param childWorkflowPollInterval 轮询间隔
     */
    public void setChildWorkflowPollInterval(
            Duration childWorkflowPollInterval) {
        this.childWorkflowPollInterval =
                childWorkflowPollInterval;
    }

    /**
     * 获取数据写入节点单批最大行数。
     *
     * @return 单批最大行数
     */
    public int getDataWriteBatchSize() {
        return dataWriteBatchSize;
    }

    /**
     * 设置数据写入节点单批最大行数。
     *
     * @param dataWriteBatchSize 单批最大行数
     */
    public void setDataWriteBatchSize(int dataWriteBatchSize) {
        this.dataWriteBatchSize = dataWriteBatchSize;
    }

    /**
     * 获取下载节点允许的最大文件字节数。
     *
     * @return 最大文件字节数，小于等于 0 表示不限制
     */
    public long getDownloadMaxBytes() {
        return downloadMaxBytes;
    }

    /**
     * 设置下载节点允许的最大文件字节数。
     *
     * @param downloadMaxBytes 最大文件字节数，小于等于 0 表示不限制
     */
    public void setDownloadMaxBytes(long downloadMaxBytes) {
        this.downloadMaxBytes = downloadMaxBytes;
    }

    /**
     * 获取本地编译定义缓存最大条目数。
     *
     * @return 最大条目数
     */
    public int getDefinitionCacheMaxEntries() {
        return definitionCacheMaxEntries;
    }

    /**
     * 设置本地编译定义缓存最大条目数。
     *
     * @param definitionCacheMaxEntries 最大条目数
     */
    public void setDefinitionCacheMaxEntries(int definitionCacheMaxEntries) {
        this.definitionCacheMaxEntries = definitionCacheMaxEntries;
    }

    /**
     * 获取本地编译定义缓存的最大估算字节数。
     *
     * @return 最大字节数
     */
    public long getDefinitionCacheMaxBytes() {
        return definitionCacheMaxBytes;
    }

    /**
     * 设置本地编译定义缓存的最大估算字节数。
     *
     * @param definitionCacheMaxBytes 最大字节数
     */
    public void setDefinitionCacheMaxBytes(
            long definitionCacheMaxBytes) {
        this.definitionCacheMaxBytes =
                definitionCacheMaxBytes;
    }

    /**
     * 获取编译定义缓存访问过期时间。
     *
     * @return 访问过期时间
     */
    public Duration getDefinitionCacheExpireAfterAccess() {
        return definitionCacheExpireAfterAccess;
    }

    /**
     * 设置编译定义缓存访问过期时间。
     *
     * @param definitionCacheExpireAfterAccess 访问过期时间
     */
    public void setDefinitionCacheExpireAfterAccess(Duration definitionCacheExpireAfterAccess) {
        this.definitionCacheExpireAfterAccess = definitionCacheExpireAfterAccess;
    }
}
