package com.easyagents.agent.runtime.agentscope;

import com.easyagents.agent.runtime.persistence.AgentPersistencePolicy;
import com.easyagents.agent.runtime.persistence.session.AgentSessionStore;
import io.agentscope.core.session.Session;
import io.agentscope.core.state.SessionKey;
import io.agentscope.core.state.State;
import io.agentscope.core.state.StatePersistence;

import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 将 AgentScope Session 桥接到运行时 AgentSessionStore。
 */
public class AgentScopeSessionAdapter implements Session {

    private final AgentSessionStore sessionStore;

    /**
     * 创建适配器。
     *
     * @param sessionStore 运行时会话存储
     */
    public AgentScopeSessionAdapter(AgentSessionStore sessionStore) {
        this.sessionStore = sessionStore;
    }

    @Override
    public void save(SessionKey sessionKey, String name, State state) {
        sessionStore.save(toKey(sessionKey), name, state);
    }

    /**
     * 将状态列表保存到运行时存储。
     *
     * @param sessionKey 会话键
     * @param name 状态名称
     * @param states 状态列表
     */
    @Override
    public void save(SessionKey sessionKey, String name, List<? extends State> states) {
        sessionStore.saveList(toKey(sessionKey), name, states);
    }

    /**
     * 从运行时存储获取单个指定类型的状态。
     *
     * @param sessionKey 会话键
     * @param name 状态名称
     * @param clazz 状态类型
     * @param <T> 状态类型
     * @return 可选状态
     */
    @Override
    public <T extends State> Optional<T> get(SessionKey sessionKey, String name, Class<T> clazz) {
        return sessionStore.get(toKey(sessionKey), name, clazz);
    }

    /**
     * 从运行时存储获取指定类型的状态列表。
     *
     * @param sessionKey 会话键
     * @param name 状态名称
     * @param clazz 状态类型
     * @param <T> 状态类型
     * @return 状态列表
     */
    @Override
    public <T extends State> List<T> getList(SessionKey sessionKey, String name, Class<T> clazz) {
        return sessionStore.getList(toKey(sessionKey), name, clazz);
    }

    /**
     * 返回会话键是否存在。
     *
     * @param sessionKey 会话键
     * @return 存在时为 true
     */
    @Override
    public boolean exists(SessionKey sessionKey) {
        return sessionStore.exists(toKey(sessionKey));
    }

    /**
     * 删除会话键。
     *
     * @param sessionKey 会话键
     */
    @Override
    public void delete(SessionKey sessionKey) {
        sessionStore.delete(toKey(sessionKey));
    }

    /**
     * 列出已存储的会话键。
     *
     * @return 会话键列表
     */
    @Override
    public Set<SessionKey> listSessionKeys() {
        return sessionStore.listSessionKeys().stream()
                .map(RuntimeSessionKey::new)
                .collect(Collectors.toSet());
    }

    /**
     * 将持久化策略转换为 AgentScope 持久化标记。
     *
     * @param policy 运行时策略
     * @return AgentScope 状态持久化配置
     */
    public static StatePersistence toStatePersistence(AgentPersistencePolicy policy) {
        if (policy == null || !policy.isEnabled()) {
            return StatePersistence.memoryOnly();
        }
        return StatePersistence.builder()
                .memoryManaged(policy.isMemoryManaged())
                .toolkitManaged(policy.isToolkitManaged())
                .planNotebookManaged(policy.isPlanNotebookManaged())
                .statefulToolsManaged(policy.isStatefulToolsManaged())
                .build();
    }

    /**
     * 创建会话键。
     *
     * @param value 键值
     * @return 会话键
     */
    public static SessionKey sessionKey(String value) {
        return new RuntimeSessionKey(value);
    }

    private String toKey(SessionKey sessionKey) {
        return sessionKey == null ? "" : sessionKey.toIdentifier();
    }

    /**
    * 运行时支撑的 AgentScope 会话键。
    */
    private record RuntimeSessionKey(String value) implements SessionKey {
        /**
        * 将键转换为稳定标识符。
         *
         * @return 标识符
         */
        @Override
        public String toIdentifier() {
                return value;
            }
    }
}
