import { createBot } from "@wp2508/mineflayer";
import type { Bot, BotEvents } from "@wp2508/mineflayer";
import {bot_instance_config, bot_status} from "../../types/bot/instance/bot_runtime.ts";
import {
    validate_host,
    validate_port,
    validate_proxy,
    validate_username,
    validate_version
} from "../../utils/validate.ts";
import {type bot_operation_code, type validate_code, validate_code_map} from "../../utils/validate_code_map.ts";
import { EventEmitter } from "node:events";
import { Mutex } from "async-mutex";
import {Logger} from "../../utils/logger.ts";
import {get_project_root_path} from "../../utils/path_utils.ts";
import * as path from 'path';
import {log} from "../../types/utils/logger.ts";
import {MinecraftJsonParser} from "../../utils/message_json_parser.ts";
import {remember_command_tree} from '../../utils/command_completion.ts';
import {create_info_manager, type InfoManager, type InfoUpdate} from '../info/init.ts';
import {create_function_manager, type FunctionManager} from '../function/init.ts';
import {PluginManager} from '../plugins/init.ts';
import type {WorkflowManager, WorkflowRunEvent} from '../../types/bot/workflow/runtime.ts';

// 深度清理的最大递归深度与最大节点数，避免遍历无关的深层对象图
const CLEANUP_MAX_DEPTH = 8;
const CLEANUP_MAX_VISITED = 2000;
// 共享 / 全局对象，禁止递归进入，避免误清理缓存或全局状态
const CLEANUP_SKIP_KEYS = new Set(['registry', 'supportFeature', 'constructor']);
// 需要显式清理的定时器与待发队列字段名
const CLEANUP_TIMER_KEYS = ['closeTimer', '_keepAliveTimer', 'keepAliveTimer', 'doPhysicsTimer'];
const CLEANUP_QUEUE_KEYS = ['_writeQueue', '_priorityWriteQueue', '_mcBundle'];
// 全局对象，绝不能被遍历清理
const CLEANUP_PROTECTED: unknown[] = [globalThis, process, console];
// 'end' 事件未按时派发时的兜底清理延时（毫秒）
const CLEANUP_FALLBACK_DELAY = 1000;

// 事件表：mineflayer 的全部事件 + 实例自有的 log 事件
export interface bot_instance_event extends BotEvents {
    log: (log: log[]) => void;
    status_update: (status: bot_status) => void;
    instance_created: (instance: Bot) => void;
    info_update: (event: InfoUpdate) => void;
    connection_lost: () => void;
    connection_requested: () => void;
    reconnect_attempt: () => void;
    workflow_update: (event: WorkflowRunEvent) => void;
}

export type bot_event_name = keyof bot_instance_event;
// 单个事件的回调参数元组，例如 chat -> [username, message, translate, jsonMsg, matches]
export type bot_event_args<E extends bot_event_name> = Parameters<bot_instance_event[E]>;
export type bot_event_handler<E extends bot_event_name> = (...args: bot_event_args<E>) => void;
// onAny / onceAny 在事件名之后接收对应事件的全部参数；
// 事件名受联合类型约束，参数保持宽松以便统一处理任意事件
export type bot_event_any_handler = (event: bot_event_name, ...args: any[]) => void;

export type bot_instance_context<T> = {
    readonly bot_instance: Bot | null,
    readonly info_manager: InfoManager | null,
    readonly function_manager: FunctionManager | null,
    workflow_manager: WorkflowManager | null,
    bot_config: bot_instance_config,
    readonly bot_status: bot_status,
    readonly plugin_manager: PluginManager,
    event_emitter: EventEmitter,
    logger: Logger | null,
    action_lock: boolean,
    instance_lock: Mutex,
    validate_config: (config: bot_instance_config) => validate_code,
    log: (log: log[]) => void,
    on: <E extends bot_event_name>(event: E, callback: bot_event_handler<E>) => void,
    onAny: (callback: bot_event_any_handler) => void,
    once: <E extends bot_event_name>(event: E, callback: bot_event_handler<E>) => void,
    onceAny: (callback: bot_event_any_handler) => void,
    off: <E extends bot_event_name>(event: E, callback: bot_event_handler<E>) => void,
    emit: <E extends bot_event_name>(event: E, ...args: bot_event_args<E>) => void,

    connect: () => Promise<bot_operation_code>,
    create_instance: () => Promise<bot_operation_code>,
    disconnect: () => Promise<bot_operation_code>,
    schedule_reconnect: (delay: number) => Promise<void>,
    cancel_reconnect: () => void,
    inject: (callback: (context: bot_instance_context<T>) => void) => void,
    clear_this_context: () => Promise<void>
}

export class BotContext implements bot_instance_context<any> {
    get is_disposed(): boolean {return this.disposal_requested;}
    public workflow_manager: WorkflowManager | null = null;
    private bot_instance_origin: Bot | null = null;
    public get bot_instance(): Bot | null {
        return this.bot_instance_origin;
    }
    private info_manager_origin: InfoManager | null = null;
    public get info_manager(): InfoManager | null {
        return this.info_manager_origin;
    }
    private info_unsubscribe: (() => void) | undefined;
    private function_manager_origin: FunctionManager | null = null;
    public get function_manager(): FunctionManager | null {
        return this.function_manager_origin;
    }
    private cleanup_task: Promise<void> | undefined;
    private dispose_task: Promise<void> | undefined;
    private disposal_requested = false;
    private operation_sequence = 0;
    private reconnect_timer: ReturnType<typeof setTimeout> | undefined;
    public readonly bot_config: bot_instance_config = {
        username: '',
        host: '',
        port: 0,
        version: '',
        user_id: 0,
        bot_id: 0,
        proxy: null
    };
    private bot_status_origin: bot_status = 'offline';
    public get bot_status(): bot_status {
        return this.bot_status_origin;
    }

    private set_status(value: bot_status) {
        if (this.bot_status_origin === value) {
            return;
        }
        const transitions: Record<bot_status, readonly bot_status[]> = {
            offline: ['ready', 'reconnecting'],
            ready: ['connecting', 'disconnecting'],
            connecting: ['online', 'disconnecting'],
            online: ['disconnecting'],
            disconnecting: ['offline'],
            reconnecting: ['ready', 'offline'],
        };
        if (!transitions[this.bot_status_origin].includes(value)) {
            throw new Error(`无效的机器人状态转换: ${this.bot_status_origin} -> ${value}`);
        }
        this.bot_status_origin = value;
        this.notify('status_update', value);
    }

    private notify<E extends bot_event_name>(event: E, ...args: bot_event_args<E>) {
        try {
            this.emit(event, ...args);
        } catch (error) {
            this.logger?.log([this.logger.error(`生命周期事件 ${String(event)} 处理失败: ${String(error)}`)]);
        }
    }
    public readonly plugin_manager: PluginManager;
    public event_emitter = new EventEmitter()
    // 记录每个原始回调对应的包装函数，off 时才能找回并移除同一个监听器
    private readonly event_wrappers = new Map<
        string,
        Map<(...args: any[]) => void, ((...args: any[]) => void)[]>
    >();
    public logger: Logger | null = null;
    public action_lock: boolean = false;
    // 串行化 create_instance / connect / disconnect，防止并发操作实例
    public readonly instance_lock : Mutex = new Mutex();

    constructor(config: bot_instance_config) {
        this.bot_config = config;
        const log_path = path.join(get_project_root_path(), 'data/bot/', this.bot_config.bot_id.toString(), '/log');
        this.logger = new Logger(log_path);
        this.plugin_manager = new PluginManager(this);
    }

    public log(log: log[]) {
        this.logger.log(log);
        this.notify('log', log);
    }

    public create_instance(): Promise<bot_operation_code> {
        if (this.bot_status === 'reconnecting' || this.reconnect_timer !== undefined) this.cancel_reconnect();
        const sequence = this.operation_sequence;
        return this.instance_lock.runExclusive(async () => {
            await this.cleanup_task;
            if (this.disposal_requested) return validate_code_map.bot_context.disposed;
            if (sequence !== this.operation_sequence) return validate_code_map.bot_context.cancelled;
            if (this.bot_status === 'online') return validate_code_map.bot_context.instance_connected;
            if (this.bot_status === 'connecting') return validate_code_map.bot_context.instance_connecting;
            if (this.bot_instance) return validate_code_map.bot_context.ok;
            const result = await this.create_bot_instance(sequence);
            if (result !== validate_code_map.bot_context.ok) await this.cleanup_task;
            if (this.disposal_requested) return validate_code_map.bot_context.disposed;
            if (sequence !== this.operation_sequence) return validate_code_map.bot_context.cancelled;
            return result;
        });
    }

    private async create_bot_instance(sequence: number): Promise<bot_operation_code> {
        const result = this.validate_config(this.bot_config);
        if (result !== validate_code_map.username.ok) return result;
        let instance: Bot | undefined;
        let pending_manager: InfoManager | undefined;
        let pending_functions: FunctionManager | undefined;
        let initialized = false;
        const failure = (): bot_operation_code | undefined => {
            if (this.disposal_requested) return validate_code_map.bot_context.disposed;
            if (sequence !== this.operation_sequence) return validate_code_map.bot_context.cancelled;
            if (this.bot_instance !== instance) return validate_code_map.bot_context.error;
        };
        try {
            const {port, plugins, workflow, config_revision, ...options} = this.bot_config;
            instance = createBot({...options, ...(port != null ? {port} : {}), autoConnect: false, hideErrors: true});
            (instance as Bot & {server_address: string}).server_address = `${options.host.includes(':') ? `[${options.host}]` : options.host}:${port ?? 25565}`;
            this.bot_instance_origin = instance;
            instance._client.on('declare_commands', packet => remember_command_tree(instance, packet));
            const terminate = <E extends 'end' | 'kicked' | 'error'>(event: E, ...args: bot_event_args<E>) => {
                if (this.bot_instance !== instance || this.disposal_requested) return;
                const reason = args[0];
                if (event === 'error') {
                    this.log([this.logger.error(`连接错误: ${String(reason)}`)]);
                } else if (event === 'kicked') {
                    let kickReason: Parameters<typeof MinecraftJsonParser.toLog>[0] = args[0] as Parameters<typeof MinecraftJsonParser.toLog>[0];
                    if (typeof kickReason === 'string') {
                        try { kickReason = JSON.parse(kickReason); }
                        catch { /* Plain-text disconnect reasons are valid too. */ }
                    }
                    const reasonLog = MinecraftJsonParser.toLog(kickReason);
                    if (!reasonLog.length) {
                        let fallback = '未知原因';
                        try { fallback = JSON.stringify(kickReason) ?? fallback; }
                        catch { /* Keep a readable fallback for malformed data. */ }
                        reasonLog.push(this.logger.error(fallback));
                    }
                    this.log([
                        this.logger.custom('[被踢出] ', '#cf8e8e', ['bold']),
                        ...reasonLog,
                    ]);
                } else {
                    this.log([this.logger.warning(`连接已断开: ${String(reason ?? '未知原因')}`)]);
                }
                const sequence = this.operation_sequence;
                // Initialization failures are handled by the caller, including retry attempts.
                const report_connection_lost = initialized;
                const cleanup = this.clear_bot_instance(event === 'end');
                this.notify(event, ...args);
                void cleanup.then(() => {
                    if (report_connection_lost && !this.disposal_requested && sequence === this.operation_sequence) {
                        this.notify('connection_lost');
                    }
                }).catch(error => {
                    this.logger?.log([this.logger.error(`清理实例失败: ${String(error)}`)]);
                });
            };
            instance.on('end', reason => terminate('end', reason));
            instance.on('kicked', (reason, logged_in) => terminate('kicked', reason, logged_in));
            instance.on('error', (error: Error) => terminate('error', error));
            instance.on('initialLogin', () => {
                if (this.bot_instance !== instance || this.bot_status !== 'connecting' || this.disposal_requested) return;
                this.set_status('online');
            });
            instance.on("message", (jsonMsg, position) => {
                const channel = {
                    chat: {label: '聊天', color: '#8fb0c9'},
                    system: {label: '系统', color: '#d1b478'},
                    game_info: {label: '提示', color: '#8fb98f'},
                }[position] ?? {label: String(position), color: '#8fb0c9'};
                this.log([
                    this.logger.custom(`[${channel.label}] `, channel.color, ['bold']),
                    ...MinecraftJsonParser.parse(jsonMsg).log,
                ]);
            })
            instance.onAny((event: string, ...args: any[]) => {
                if (this.bot_instance === instance && !this.disposal_requested) this.emit(event, ...args);
            });
            this.set_status('ready');
            const before_loading = failure();
            if (before_loading !== undefined) return before_loading;
            const manager = pending_manager = await create_info_manager(instance, {
                bot_id: this.bot_config.bot_id, plugin_source: this.plugin_manager,
                workflow_source: this.workflow_manager,
            });
            const after_loading = failure();
            if (after_loading !== undefined) return after_loading;
            this.info_manager_origin = manager;
            pending_manager = undefined;
            this.info_unsubscribe = manager.on_update(event => {
                if (this.bot_instance === instance && this.info_manager === manager
                    && !this.disposal_requested) {
                    this.notify('info_update', event);
                }
            });
            pending_functions = await create_function_manager(this);
            const after_functions = failure();
            if (after_functions !== undefined) return after_functions;
            this.function_manager_origin = pending_functions;
            pending_functions = undefined;
            this.notify('instance_created', instance);
            const after_notification = failure();
            if (after_notification !== undefined) return after_notification;
            this.log([this.logger.custom('[NODE] 创建机器人实例成功', '#8fb98f', ['bold'])]);
            const after_log = failure();
            if (after_log !== undefined) return after_log;
            initialized = true;
            return validate_code_map.bot_context.ok;
        } catch (error) {
            this.logger?.log([this.logger.error(`创建实例失败: ${String(error)}`)]);
            if (this.disposal_requested) return validate_code_map.bot_context.disposed;
            if (sequence !== this.operation_sequence) return validate_code_map.bot_context.cancelled;
            return validate_code_map.bot_context.error;
        } finally {
            if (!initialized) {
                pending_functions?.dispose();
                try { pending_manager?.dispose(); }
                catch (error) { this.logger?.log([this.logger.error(`清理信息管理器失败: ${String(error)}`)]); }
                if (instance && this.bot_instance === instance) await this.clear_bot_instance();
                else await this.cleanup_task;
            }
        }
    }

    public inject(callback: (context: bot_instance_context<any>) => void) {
        callback(this as bot_instance_context<any>);
    }

    public connect(): Promise<bot_operation_code> {
        if (this.bot_status === 'reconnecting' || this.reconnect_timer !== undefined) this.cancel_reconnect();
        const sequence = this.operation_sequence;
        if (!this.disposal_requested) this.notify('connection_requested');
        return this.connect_instance(sequence);
    }

    private connect_instance(sequence: number): Promise<bot_operation_code> {
        return this.instance_lock.runExclusive(async () => {
            await this.cleanup_task;
            if (this.disposal_requested) return validate_code_map.bot_context.disposed;
            if (sequence !== this.operation_sequence) return validate_code_map.bot_context.cancelled;
            if (this.bot_status === 'online') return validate_code_map.bot_context.instance_connected;
            if (this.bot_status === 'connecting') return validate_code_map.bot_context.instance_connecting;
            if (this.bot_status === 'reconnecting') this.set_status('offline');
            if (!this.bot_instance) {
                const result = await this.create_bot_instance(sequence);
                if (result !== validate_code_map.bot_context.ok) {
                    await this.cleanup_task;
                    return result;
                }
            }
            if (this.disposal_requested) return validate_code_map.bot_context.disposed;
            if (sequence !== this.operation_sequence) return validate_code_map.bot_context.cancelled;
            const instance = this.bot_instance;
            if (!instance) return validate_code_map.bot_context.error;
            this.set_status('connecting');
            if (this.disposal_requested || sequence !== this.operation_sequence) {
                await this.clear_bot_instance();
                return validate_code_map.bot_context.cancelled;
            }
            try {
                instance.connect();
                if (this.bot_instance !== instance) {
                    await this.cleanup_task;
                    return validate_code_map.bot_context.error;
                }
                return validate_code_map.bot_context.ok;
            } catch (error) {
                this.logger?.log([this.logger.error(`连接实例失败: ${String(error)}`)]);
                await this.clear_bot_instance();
                return validate_code_map.bot_context.error;
            }
        });
    }

    public disconnect(): Promise<bot_operation_code> {
        this.cancel_reconnect();
        return this.instance_lock.runExclusive(async () => {
            if (this.disposal_requested) return validate_code_map.bot_context.disposed;
            await this.clear_bot_instance();
            return validate_code_map.bot_context.ok;
        });
    }

    public cancel_reconnect(): void {
        this.operation_sequence++;
        clearTimeout(this.reconnect_timer);
        this.reconnect_timer = undefined;
        if (this.bot_status === 'reconnecting') this.set_status('offline');
    }

    public async schedule_reconnect(delay: number): Promise<void> {
        if (!Number.isInteger(delay) || delay < 0 || delay > 2_147_483_647) {
            throw new Error('重连延时必须是有效的毫秒整数');
        }
        const sequence = this.operation_sequence;
        await this.instance_lock.runExclusive(() => {
            if (this.disposal_requested || sequence !== this.operation_sequence || this.bot_status !== 'offline') return;
            this.reconnect_timer = setTimeout(() => {
                this.reconnect_timer = undefined;
                if (this.disposal_requested || sequence !== this.operation_sequence) return;
                this.notify('reconnect_attempt');
                void this.connect_instance(sequence).then(result => {
                    if (result !== validate_code_map.bot_context.ok && !this.disposal_requested
                        && sequence === this.operation_sequence && this.bot_status === 'offline') {
                        this.notify('connection_lost');
                    }
                }).catch(error => {
                    this.logger?.log([this.logger.error(`自动重连失败: ${String(error)}`)]);
                });
            }, delay);
            this.set_status('reconnecting');
        });
    }

    public on<E extends bot_event_name>(event: E, callback: bot_event_handler<E>) {
        const wrapper: bot_event_handler<E> = (...args) => callback(...args);
        this.remember_wrapper(event, callback, wrapper);
        this.event_emitter.on(event, wrapper);
    }

    public onAny(callback: bot_event_any_handler) {
        const wrapper = (event: string, ...args: any[]) => callback(event as bot_event_name, ...args);
        this.remember_wrapper('any', callback, wrapper);
        this.event_emitter.on('any', wrapper);
    }

    public once<E extends bot_event_name>(event: E, callback: bot_event_handler<E>) {
        const wrapper: bot_event_handler<E> = (...args) => callback(...args);
        this.remember_wrapper(event, callback, wrapper);
        this.event_emitter.once(event, wrapper);
    }

    public onceAny(callback: bot_event_any_handler) {
        const wrapper = (event: string, ...args: any[]) => callback(event as bot_event_name, ...args);
        this.remember_wrapper('any', callback, wrapper);
        this.event_emitter.once('any', wrapper);
    }

    public off<E extends bot_event_name>(event: E, callback: bot_event_handler<E>) {
        const callbacks = this.event_wrappers.get(event);
        const wrappers = callbacks?.get(callback);
        if (!callbacks || !wrappers) return;
        const wrapper = wrappers.pop();
        if (!wrapper) return;
        this.event_emitter.off(event, wrapper);
        if (wrappers.length === 0) {
            callbacks.delete(callback);
        }
    }

    // 记录原始回调 -> 包装函数栈，off 时才能找回并移除同一个监听器；
    // 同一回调可多次注册，off 从栈顶移除最近一次
    private remember_wrapper(
        event: string,
        callback: (...args: any[]) => void,
        wrapper: (...args: any[]) => void,
    ) {
        let callbacks = this.event_wrappers.get(event);
        if (!callbacks) {
            callbacks = new Map();
            this.event_wrappers.set(event, callbacks);
        }
        let wrappers = callbacks.get(callback);
        if (!wrappers) {
            wrappers = [];
            callbacks.set(callback, wrappers);
        }
        wrappers.push(wrapper);
    }

    public emit<E extends bot_event_name>(event: E, ...args: bot_event_args<E>): void;
    public emit(event: string, ...args: any[]): void;
    public emit(event: string, ...args: any[]) {
        // 'error' 无监听器时 EventEmitter 会抛出；转发前先兜底，避免 bot 的错误
        // 变成未捕获异常，同时保证 'any' / onAny 仍能观察到该事件
        if (event !== 'error' || this.event_emitter.listenerCount('error') > 0) {
            this.event_emitter.emit(event, ...args);
        }
        this.event_emitter.emit('any', event, ...args);
    }

    private clear_bot_instance(ended = false): Promise<void> {
        if (this.cleanup_task) return this.cleanup_task;
        const instance = this.bot_instance;
        if (!instance) return Promise.resolve();
        this.bot_instance_origin = null;
        const manager = this.info_manager_origin;
        const functions = this.function_manager_origin;
        this.function_manager_origin = null;
        const unsubscribe = this.info_unsubscribe;
        this.info_manager_origin = null;
        this.info_unsubscribe = undefined;
        let cleaned = false;
        let finish!: () => void;
        const task = new Promise<void>(resolve => { finish = resolve; });
        this.cleanup_task = task.then(() => {
            this.cleanup_task = undefined;
            if (!this.disposal_requested) this.set_status('offline');
        });
        const cleanup_task = this.cleanup_task;
        const run_cleanup = () => {
            if (cleaned) return;
            cleaned = true;
            clearTimeout(fallback_timer);
            try {
                this.deep_cleanup(instance, new Set(), 0);
                this.log([this.logger.custom('[NODE] 机器人实例已关闭', '#cf8e8e', ['bold'])]);
            } catch (error) {
                this.logger?.log([this.logger.error(`清理实例资源失败: ${String(error)}`)]);
            } finally {
                finish();
            }
        };
        // 等 end 的所有监听器执行完毕后再摘除监听器，保留 mineflayer 的内部资源清理。
        const on_end = () => { queueMicrotask(run_cleanup); };
        const fallback_timer = setTimeout(run_cleanup, CLEANUP_FALLBACK_DELAY);
        for (const cleanup of [unsubscribe, manager ? () => manager.dispose() : undefined, functions ? () => functions.dispose() : undefined]) {
            try { cleanup?.(); }
            catch (error) { this.logger?.log([this.logger.error(`清理信息管理器失败: ${String(error)}`)]); }
        }
        this.set_status('disconnecting');
        if (ended) {
            on_end();
        } else {
            instance.once('end', on_end);
            try {
                instance.end(validate_code_map.bot_context.instance_end_by_user.toString());
            } catch {
                on_end();
            }
        }
        return cleanup_task;
    }

    // 深度遍历对象图，释放监听器 / 定时器 / 流句柄等残留状态；
    // seen 去重，depth 限制递归深度，visited 限制遍历规模，避免开销失控
    private deep_cleanup(target: unknown, seen: Set<object>, depth: number, visited = { count: 0 }) {
        if (target === null || typeof target !== 'object') return;
        if (depth > CLEANUP_MAX_DEPTH || visited.count > CLEANUP_MAX_VISITED) return;
        const object = target as Record<string, any>;
        if (CLEANUP_PROTECTED.includes(object)) return;
        if (seen.has(object)) return;
        seen.add(object);
        visited.count++;

        this.release_own_state(object);

        for (const key of Object.keys(object)) {
            if (CLEANUP_SKIP_KEYS.has(key)) continue;
            let value: unknown;
            try {
                value = object[key];
            } catch {
                continue;
            }
            if (value === null || typeof value !== 'object') continue;
            this.deep_cleanup(value, seen, depth + 1, visited);
        }
    }

    // 释放单个对象自身持有的监听器 / 定时器 / 流句柄 / 待发队列
    private release_own_state(object: Record<string, any>) {
        for (const key of CLEANUP_TIMER_KEYS) {
            const timer = object[key];
            if (timer === null || timer === undefined) continue;
            clearInterval(timer as NodeJS.Timeout);
            clearTimeout(timer as NodeJS.Timeout);
            try {
                object[key] = null;
            } catch {
                // 只读 / 冻结对象无法赋值，忽略
            }
        }
        for (const key of CLEANUP_QUEUE_KEYS) {
            if (Array.isArray(object[key])) {
                (object[key] as unknown[]).length = 0;
            }
        }
        // 仅销毁流 / socket 类句柄，避免误调用无关对象的 destroy
        if (typeof object.destroy === 'function' && object.destroyed !== true
            && (typeof object.pipe === 'function' || typeof object.write === 'function')) {
            try {
                object.destroy();
            } catch {
                // 忽略已关闭句柄在销毁时的异常
            }
        }
        if (typeof object.removeAllListeners === 'function') {
            object.removeAllListeners();
        }
    }

    public validate_config(config: bot_instance_config): validate_code {
        const username_validate = validate_username(config.username);
        if (username_validate !== validate_code_map.username.ok) return username_validate;
        const host_validate = validate_host(config.host);
        if (host_validate !== validate_code_map.host.ok) return host_validate;
        if (config.port != null) {
            const port_validate = validate_port(config.port);
            if (port_validate !== validate_code_map.port.ok) return port_validate;
        }
        const version_validate = validate_version(config.version);
        if (version_validate !== validate_code_map.version.ok) return version_validate;
        if (config.proxy != null) {
            const proxy_validate = validate_proxy(config.proxy);
            if (proxy_validate !== validate_code_map.proxy.ok) return proxy_validate;
        }
        return validate_code_map.username.ok;
    }

    public clear_this_context(): Promise<void> {
        if (this.dispose_task) return this.dispose_task;
        this.disposal_requested = true;
        this.cancel_reconnect();
        const plugins_disposed = this.plugin_manager.dispose().catch(error => {
            this.logger?.log([this.logger.error(`插件卸载失败: ${String(error)}`)]);
        });
        const workflow_disposed = this.workflow_manager?.dispose().catch(error => {
            this.logger?.log([this.logger.error(`Workflow cleanup failed: ${String(error)}`)]);
        });
        this.dispose_task = Promise.all([plugins_disposed, workflow_disposed]).then(() => this.instance_lock.runExclusive(async () => {
            await this.clear_bot_instance();
            this.action_lock = false;
            if (this.bot_status === 'offline') {
                this.notify('status_update', 'offline');
            } else {
                this.set_status('offline');
            }
            this.event_emitter.removeAllListeners();
            this.event_wrappers.clear();
            this.workflow_manager = null;
            await this.logger?.close();
        }));
        return this.dispose_task;
    }

}