import 'dotenv/config';
import { createDeepAgent, FilesystemBackend } from "deepagents";
import { AIMessageChunk, ToolMessage } from "langchain";
import { HumanMessage } from "@langchain/core/messages";
import { ChatDeepSeek } from "@langchain/deepseek";
import config from '../../conf.json' with { type: 'json' };
import logger from '../../utils/logger.js';
import EscortAdminPrompts from "./prompts.js";
import {
    getEnvTool, webFetchTool, webSearchTool, getCalendarInfoTool,
    getLunarCalendarInfoTool, getYearHolidaysTool, getYearTermsTool, getLatLngTool,
    httpGetTool, httpPostTool, escortRecordQueryTool, escortRecordSetTool
} from "./tools/index.js";

export default class EscortAdminAgent {
    constructor() {
        // 按用户隔离会话：userId -> { agent, messages }
        this.sessions = new Map();
        this.maxSessions = 100;
    }

    clearMessages(userInfo) {
        const userId = userInfo?._id ?? 'default-session';
        this.sessions.delete(userId);
    }

    // msg: { agent: 'escort-admin', type: 'chat', ts: "2023-08-01 10:00:00", content: "你好" }
    async streamChat(userInfo, msgs, callback) {
        if (!msgs.length) {
            return;
        }

        const userId = userInfo?._id ?? 'default-session';

        // LRU：按用户取会话，并更新使用顺序
        let session = this.sessions.get(userId);
        if (session) {
            this.sessions.delete(userId);
        } else {
            session = { agent: null, messages: [] };
        }
        this.sessions.set(userId, session);

        // 超出上限时淘汰最久未使用的会话，避免内存泄漏
        if (this.sessions.size > this.maxSessions) {
            const oldest = this.sessions.keys().next().value;
            this.sessions.delete(oldest);
        }

        msgs.forEach(msg => {
            if (msg.type === "clear") {
                session.messages = [];
                session.agent = null;
            } else {
                session.messages.push(new HumanMessage(`${msg.ts} - ${msg.content}`));
            }
        });

        if (session.messages.length === 0) {
            return;
        }

        const agent = session.agent ?? this._genAgent(userInfo);
        session.agent = agent;

        const INTERESTING_NODES = new Set(["model_request", "tools"]);
        for await (const [namespace, mode, data] of await agent.stream(
            { messages: session.messages },
            {
                recursion_limit: 50,
                streamMode: ["updates", "messages", "custom"], subgraphs: true,
                configurable: {
                    thread_id: userId
                }
            })) {
            const isSubagent = namespace.some(s => s.startsWith("tools:"));
            const source = isSubagent ? "subagent" : "main";
            if (mode === "updates") {
                for (const nodeName of Object.keys(data)) {
                    if (!INTERESTING_NODES.has(nodeName)) continue;
                    // Main agent updates (empty namespace)
                    if (namespace.length === 0) {
                        for (const [nodeName, data_] of Object.entries(data)) {
                            if (nodeName === "tools") {
                                // Subagent results returned to main agent
                                for (const msg of data_.messages ?? []) {
                                    if (msg.type === "tool") {
                                        logger.info(`Subagent complete: ${msg.name}, Result: ${String(msg.content).slice(0, 200)}`);
                                    }
                                }
                            } else if (nodeName === "model_request") {
                                session.messages.push(...data_.messages);
                            }
                        }
                    } else {
                        // Subagent updates (non-empty namespace)
                        for (const [nodeName, data_] of Object.entries(data)) {
                            logger.info(`[${namespace[0]}] step: ${nodeName}`);
                        }
                    }
                }
            } else if (mode === "messages") {
                const [message] = data;
                if (message.tool_call_chunks?.length) {
                    continue;
                }
                if (AIMessageChunk.isInstance(message)) {
                    if (message.text && !message.tool_call_chunks?.length) {
                        callback(source, "ai", message.text, message.id);
                    }
                    if (message.additional_kwargs.reasoning_content && !message.tool_call_chunks?.length) {
                        callback(source, "reasoning", message.additional_kwargs.reasoning_content, message.id);
                    }
                }
                if (ToolMessage.isInstance(message) && message.text) {
                    callback(source, "tool", message.text, message.id);
                }
            } else if (mode === "custom") {
                logger.info("custom: ", data);
            }
        }
    }

    _genAgent(userInfo) {
        const rootDir = process.cwd();
        const backend = new FilesystemBackend({ rootDir });

        this.flashModel = new ChatDeepSeek({
            model: config.agent.deepseek.flashModel,
            apiKey: config.agent.deepseek.apiKey,
            temperature: 0.0
        });
        this.proModel = new ChatDeepSeek({
            model: config.agent.deepseek.proModel,
            apiKey: config.agent.deepseek.apiKey,
            temperature: 0.3
        });

        const escortRecordOperSubagent = {
            name: "escort-record-oper-subagent",
            description: "查询和设置陪诊预约记录",
            systemPrompt: "根据用户指令，调用工具完成查询和设置陪诊记录。",
            model: this.flashModel,
            tools: [escortRecordQueryTool, escortRecordSetTool],
        };

        const escortResearchSubagent = {
            name: "escort-research-subagent",
            description: "陪诊（陪同就医）行业问题研究和解答",
            systemPrompt: "你是陪诊（陪同就医）行业政策、发展趋势、行业知识研究和解答专家。",
            model: this.proModel,
            tools: [webFetchTool, webSearchTool],
        };

        return createDeepAgent({
            name: "deep-agent",
            model: this.flashModel,
            systemPrompt: EscortAdminPrompts.buildSystemPrompt(userInfo),
            backend,
            tools: [getEnvTool, webFetchTool, webSearchTool, getLatLngTool, httpGetTool, httpPostTool,
                getCalendarInfoTool, getLunarCalendarInfoTool, getYearHolidaysTool, getYearTermsTool,
                escortRecordQueryTool, escortRecordSetTool],
            subagents: [escortRecordOperSubagent, escortResearchSubagent]
        });
    }
}

const adminAgent = new EscortAdminAgent();
export { adminAgent };