package tech.easyflow.ai.easyagentsflow.config;

import com.easyagents.flow.core.chain.runtime.ExecutionBudget;
import org.springframework.boot.context.properties.ConfigurationProperties;

import java.time.Duration;

/**
 * 工作流执行资源保护预算配置。
 */
@ConfigurationProperties(prefix = "easyflow.workflow.execution-budget")
public class WorkflowExecutionBudgetProperties {

    private long maxIterations = ExecutionBudget.DEFAULT_MAX_ITERATIONS;
    private Duration maxDuration = Duration.ofMillis(ExecutionBudget.DEFAULT_MAX_DURATION_MILLIS);
    private long maxChildExecutions = ExecutionBudget.DEFAULT_MAX_CHILD_EXECUTIONS;
    private long maxAccumulatedBytes = ExecutionBudget.DEFAULT_MAX_ACCUMULATED_BYTES;
    private int maxNestedDepth = ExecutionBudget.DEFAULT_MAX_NESTED_DEPTH;
    private long maxHotStateBytes = ExecutionBudget.DEFAULT_MAX_HOT_STATE_BYTES;

    /**
     * 转换为工作流引擎使用的不可变执行预算。
     *
     * @return 执行预算
     */
    public ExecutionBudget toExecutionBudget() {
        long maxDurationMillis = maxDuration == null ? 0L : maxDuration.toMillis();
        return new ExecutionBudget(
                maxIterations,
                maxDurationMillis,
                maxChildExecutions,
                maxAccumulatedBytes,
                maxNestedDepth,
                maxHotStateBytes);
    }

    /**
     * 获取单个执行实例允许的最大循环次数。
     *
     * @return 最大循环次数
     */
    public long getMaxIterations() {
        return maxIterations;
    }

    /**
     * 设置单个执行实例允许的最大循环次数。
     *
     * @param maxIterations 最大循环次数；小于等于零表示不限制
     */
    public void setMaxIterations(long maxIterations) {
        this.maxIterations = maxIterations;
    }

    /**
     * 获取单个执行实例允许的最大运行时间。
     *
     * @return 最大运行时间
     */
    public Duration getMaxDuration() {
        return maxDuration;
    }

    /**
     * 设置单个执行实例允许的最大运行时间。
     *
     * @param maxDuration 最大运行时间
     */
    public void setMaxDuration(Duration maxDuration) {
        this.maxDuration = maxDuration;
    }

    /**
     * 获取允许调度的最大子节点执行次数。
     *
     * @return 最大子节点执行次数
     */
    public long getMaxChildExecutions() {
        return maxChildExecutions;
    }

    /**
     * 设置允许调度的最大子节点执行次数。
     *
     * @param maxChildExecutions 最大子节点执行次数；小于等于零表示不限制
     */
    public void setMaxChildExecutions(long maxChildExecutions) {
        this.maxChildExecutions = maxChildExecutions;
    }

    /**
     * 获取允许累计的结果估算字节数。
     *
     * @return 最大累计结果字节数
     */
    public long getMaxAccumulatedBytes() {
        return maxAccumulatedBytes;
    }

    /**
     * 设置允许累计的结果估算字节数。
     *
     * @param maxAccumulatedBytes 最大累计结果字节数；小于等于零表示不限制
     */
    public void setMaxAccumulatedBytes(long maxAccumulatedBytes) {
        this.maxAccumulatedBytes = maxAccumulatedBytes;
    }

    /**
     * 获取循环允许的最大嵌套深度。
     *
     * @return 最大嵌套深度
     */
    public int getMaxNestedDepth() {
        return maxNestedDepth;
    }

    /**
     * 设置循环允许的最大嵌套深度。
     *
     * @param maxNestedDepth 最大嵌套深度；小于等于零表示不限制
     */
    public void setMaxNestedDepth(int maxNestedDepth) {
        this.maxNestedDepth = maxNestedDepth;
    }

    /**
     * 获取单个热状态允许的最大估算字节数。
     *
     * @return 最大热状态字节数
     */
    public long getMaxHotStateBytes() {
        return maxHotStateBytes;
    }

    /**
     * 设置单个热状态允许的最大估算字节数。
     *
     * @param maxHotStateBytes 最大热状态字节数；小于等于零表示不限制
     */
    public void setMaxHotStateBytes(long maxHotStateBytes) {
        this.maxHotStateBytes = maxHotStateBytes;
    }
}
