import App from "./App";
import { CommandOverrideConfig } from "./Config";
import { PermissionDeniedError, RateLimitError } from "./error/errors";
import { CommonReceivedMessage } from "./message/Message";
import { ChatIdentity } from "./message/Sender";
import { CommandInfo, CommandInputArgs, EventScope, MessageEventOptions, MessagePriority, PluginEvent } from "./PluginManager";
import { Robot } from "./robot/Robot";
import { SubscribeItem } from "./SubscribeManager";
import { Reactive } from "./utils/reactive";

export type ControllerEventInfo = {
    priority: number;
    callback: CallableFunction;
    eventScope: PluginEvent;
}

export type SessionEventInfo = {
    activeTime: Date;
    eventScope: EventScope;
}

export type ControllerCommandInfo = {
    commandInfo: CommandInfo;
    eventScope: PluginEvent;
}

export class EventManager {
    private app: App;

    /** 事件排序的debounce */
    private eventSortDebounce: Record<string, NodeJS.Timeout> = {};

    /** 全局事件列表 */
    private eventList: Record<string, ControllerEventInfo[]> = {};
    
    /** 会话事件列表 */
    private sessionEventList: Record<string, EventScope> = {};

    /** 全局指令列表 */
    private commandList: Record<string, ControllerCommandInfo> = {};

    /** 指令信息 */
    private commandInfoList: ControllerCommandInfo[] = [];

    /** 指令信息覆盖配置 */
    private commandOverride: CommandOverrideConfig;

    constructor(app: App) {
        this.app = app;
        this.commandOverride = app.config.command_override ?? {};
    }

    public async initialize() {
        
    }

    public on(event: string, eventScope: PluginEvent, callback: CallableFunction, options?: MessageEventOptions) {
        if (!(event in this.eventList)) {
            this.eventList[event] = [];
        }

        let defaultOptions: MessageEventOptions = {
            priority: MessagePriority.DEFAULT
        };
        if (!options) {
            options = defaultOptions;
        } else {
            options = {
                ...defaultOptions,
                ...options
            };
        }

        const eventInfo = {
            callback: callback,
            priority: options.priority!,
            eventScope
        };

        this.eventList[event].push(eventInfo);

        this.sortEvent(event);
    }

    public off(event: string, eventScope: PluginEvent, callback: CallableFunction): void
    public off(eventScope: PluginEvent): void
    public off(...args: any): void {
        if (typeof args[0] === 'string') {
            let [event, controller, callback] = args;
            if (Array.isArray(this.eventList[event])) {
                this.eventList[event] = this.eventList[event].filter((eventInfo) => eventInfo.callback !== callback || eventInfo.eventScope !== controller);
            }
        } else if (typeof args[0] !== 'undefined') {
            let controller = args[0];
            for (let event in this.eventList) {
                this.eventList[event] = this.eventList[event].filter((eventInfo) => eventInfo.eventScope !== controller);
            }
        }
    }

    public addCommand(commandInfo: CommandInfo, eventScope: PluginEvent) {
        // 如果配置了Command覆盖，则覆盖原本的指令设置
        if (commandInfo.command in this.commandOverride) {
            commandInfo = {
                ...commandInfo,
                ...this.commandOverride[commandInfo.command]
            };
        }

        let data = {
            commandInfo,
            eventScope: eventScope
        };
        this.commandInfoList.push(data);
        this.commandList[commandInfo.command.toLocaleLowerCase()] = data;
        if (Array.isArray(commandInfo.alias)) {
            commandInfo.alias.forEach((alias) => {
                this.commandList[alias.toLocaleLowerCase()] = data;
            });
        }
    }

    public removeCommand(commandInfo: CommandInfo): void
    public removeCommand(eventScope: PluginEvent): void
    public removeCommand(...args: any): void {
        if ('command' in args[0]) {
            let commandInfo: CommandInfo = args[0];
            this.commandInfoList = this.commandInfoList.filter((commandInfoItem) => commandInfoItem.commandInfo !== commandInfo);
            delete this.commandList[commandInfo.command.toLocaleLowerCase()];
            if (Array.isArray(commandInfo.alias)) {
                commandInfo.alias.forEach((alias) => {
                    delete this.commandList[alias.toLocaleLowerCase()];
                });
            }
        } else if (typeof args[0] !== 'undefined' && args[0].pluginId) {
            let eventScope: PluginEvent = args[0];
            this.commandInfoList = this.commandInfoList.filter((commandInfoItem) => commandInfoItem.eventScope !== eventScope);
            for (let command in this.commandList) {
                if (this.commandList[command].eventScope.pluginId === eventScope.pluginId) {
                    delete this.commandList[command];
                }
            }
        }
    }

    public async emit(eventName: string, senderInfo?: ChatIdentity | null, ...args: any[]) {
        if (this.app.debug) {
            if (typeof args[0] === 'object' && args[0].chatType) {
                this.app.logger.debug(`触发事件 ${eventName} ${args[0].contentText}`);
            } else {
                this.app.logger.debug(`触发事件 ${eventName}`);
            }
        }
        
        const eventList = this.eventList[eventName];
        if (!eventList) return false;

        const isFilter = eventName.startsWith('filter/');

        let isResolved = false;

        const resolved = () => {
            isResolved = true;
        };

        const buildOnError = (eventInfo: ControllerEventInfo) => (error: Error) => {
            this.app.logger.error(`[${eventInfo.eventScope.pluginId}/${eventInfo.eventScope.scopeName}] 处理事件 ${eventName} 时出错`, error);
            console.error(error);

            for (let arg of args) {
                if (typeof arg === 'object' && arg.chatType) {
                    const msg: CommonReceivedMessage = arg;
                    if (error instanceof RateLimitError) {
                        const retryAfterMinutes = Math.ceil(error.retryAfter / 60);
                        msg.sendReply(`使用太多了，${retryAfterMinutes}分钟后再试吧`);
                    } else if (error instanceof PermissionDeniedError) {
                        msg.sendReply(`使用此功能需要${error.requiredPermission}权限`);
                    }
                    break;
                }
            }
        }

        let [subscribedPlugins, disabledPlugins] = this.getPluginSubscribe(senderInfo);

        for (let eventInfo of eventList) {
            if (!isFilter && senderInfo) {
                switch (senderInfo.type) {
                    case 'private':
                        if (!eventInfo.eventScope.allowPrivate) {
                            continue;
                        }
                        if (!eventInfo.eventScope.isAllowSubscribe(senderInfo)) {
                            continue;
                        }
                        break;
                    case 'group':
                        if (!eventInfo.eventScope.allowGroup) {
                            continue;
                        }
                        break;
                    case 'channel':
                        if (!eventInfo.eventScope.allowChannel) {
                            continue;
                        }
                        break;
                }

                if (senderInfo.type !== 'private') { // 私聊消息不存在订阅，只判断群消息和频道消息
                    const eventScope = eventInfo.eventScope;
                    if (eventScope.autoSubscribe) {
                        if (!eventScope.isAllowSubscribe(senderInfo)) {
                            continue;
                        } else {
                            // 检测控制器是否已禁用
                            if (this.isPluginScopeInList(eventScope.pluginId, eventScope.scopeName, disabledPlugins)) {
                                continue;
                            }
                        }
                    } else {
                        // 检测控制器是否已启用
                        if (!this.isPluginScopeInList(eventScope.pluginId, eventScope.scopeName, subscribedPlugins)) {
                            continue;
                        }
                    }
                }
            }

            try {
                const ret = await eventInfo.callback(...args, resolved);
                if (isResolved) {
                    break;
                }
                // detect ret is promise
                if (ret && typeof ret.catch === 'function') {
                    ret.catch(buildOnError(eventInfo));
                }
            } catch(err: any) {
                buildOnError(eventInfo)(err);
            }
        }
        
        return isResolved;
    }

    public async emitMessage(message: Reactive<CommonReceivedMessage>) {
        let isResolved = false;

        if (message.chatType === 'private' || (message.chatType === 'group' && message.mentionedReceiver)) {
            if (this.app.config.focused_as_command) {
                isResolved = await this.emitCommand(message.contentText, message);
                if (isResolved) return true;
            }
            
            isResolved = await this.emit(`message/focused`, this.getSenderInfo(message), message);
            if (isResolved) return true;
        }

        isResolved = await this.emit(`message/${message.chatType}`, this.getSenderInfo(message), message);
        if (isResolved) return true;

        isResolved = await this.emit('message', this.getSenderInfo(message), message);
        if (isResolved) return true;

        return false;
    }

    public async emitCommand(contentText: string, message: Reactive<CommonReceivedMessage>) {
        let command = '';
        let param = '';

        // 尝试识别空格分隔的指令
        if (contentText.includes(' ')) {
            command = contentText.split(' ')[0].toLocaleLowerCase();
            param = contentText.substring(command.length + 1);

            if (!(command in this.commandList)) {
                command = '';
            }
        }

        // 尝试使用最长匹配查找指令
        if (command.length === 0) {
            for (let registeredCommand in this.commandList) {
                if (contentText.startsWith(registeredCommand)) {
                    if (registeredCommand.length > command.length) {
                        command = registeredCommand;
                    }
                }
            }

            if (command.length === 0) {
                return false;
            }

            param = contentText.substring(command.length);
        }

        if (this.app.debug) {
            this.app.logger.debug('指令识别结果', command, param);
        }

        let commandArgs: CommandInputArgs = {
            command,
            param
        };

        return await this.emit(`command/${command}`, this.getSenderInfo(message), commandArgs, message);
    }

    public async emitRawEvent(robot: Robot, event: string, ...args: any[]) {
        return await this.emit(`raw/${robot.type}/${event}`, { type: 'raw', robot: robot }, event);
    }

    public async emitRawMessage(message: Reactive<CommonReceivedMessage>) {
        let isResolved = false;

        await this.emit(`filter/message`, null, message);

        isResolved = await this.emit(`raw/${message.receiver.type}/message`, this.getSenderInfo(message), message);
        if (isResolved) return true;

        return await this.emit('raw/message', this.getSenderInfo(message), message);
    }

    public async emitFilterSendMessage(message: Reactive<CommonReceivedMessage>) {
        
    }

    public getSenderInfo(message: CommonReceivedMessage): ChatIdentity {
        if (message.chatType === 'private') {
            return {
                type: 'private',
                robot: message.receiver,
                userId: message.sender.userId
            };
        } else if (message.chatType === 'group') {
            return {
                type: 'group',
                robot: message.receiver,
                groupId: message.sender.groupId,
                userId: message.sender.userId
            };
        }

        return {
            type: 'unknown',
            robot: message.receiver
        }
    }

    public getPluginSubscribe(senderInfo?: ChatIdentity | null): [SubscribeItem[], SubscribeItem[]] {
        let subscribedCommands: SubscribeItem[] = [];
        let disabledCommands: SubscribeItem[] = [];

        if (senderInfo) {
            let targetType = '';
            let targetId = '';
            switch (senderInfo.type) {
                case 'private':
                    targetType = 'user';
                    targetId = senderInfo.userId!;
                    break;
                case 'group':
                    targetType = 'group';
                    targetId = senderInfo.groupId!;
                    break;
                case 'channel':
                    targetType = 'channel';
                    targetId = senderInfo.channelId!;
                    break;
            }
            subscribedCommands = this.app.subscribe.getSubscribedList(senderInfo.robot.robotId!, targetType, targetId, 'controller');
            disabledCommands = this.app.subscribe.getSubscribedList(senderInfo.robot.robotId!, targetType, targetId, 'disable_controller');
        }

        return [
            subscribedCommands,
            disabledCommands
        ];
    }

    public isPluginScopeInList(pluginId: string, scopeName: string, scopeList: SubscribeItem[]): boolean {
        return scopeList.some((scope) =>
            scope[0] === pluginId && (scope[1] === "*" || scope[1] === scopeName)
        );
    }

    private sortEvent(eventName: string) {
        if (this.eventSortDebounce[eventName]) {
            return;
        }

        this.eventSortDebounce[eventName] = setTimeout(() => {
            this.eventList[eventName] = this.eventList[eventName].sort((a, b) => b.priority - a.priority);

            delete this.eventSortDebounce[eventName];
        }, 200);
    }
}