export type QuickActionContext = {
    streamId: string;
    tokenId: string;
    sessionId: string | null;
    args: string[];
};

export type QuickActionDefinition = {
    id: string;
    label: string;
    description?: string;
    run: (context: QuickActionContext) => void | Promise<void>;
};

export type RegisteredQuickAction = {
    id: string;
    label: string;
    description: string | null;
    extensionId: string;
};

type StoredQuickAction = {
    extensionId: string;
    action: QuickActionDefinition;
};

export class QuickActionRegistry {
    private readonly actions = new Map<string, StoredQuickAction>();

    public register(extensionId: string, action: QuickActionDefinition): () => void {
        const normalizedId = action.id.trim().toLowerCase();
        if (!normalizedId) {
            throw new Error("Quick action id cannot be empty.");
        }
        if (this.actions.has(normalizedId)) {
            throw new Error(`Duplicate quick action id detected: ${normalizedId}`);
        }

        this.actions.set(normalizedId, {
            extensionId,
            action: {
                ...action,
                id: normalizedId
            }
        });

        return () => {
            this.actions.delete(normalizedId);
        };
    }

    public list(): RegisteredQuickAction[] {
        return Array.from(this.actions.values())
            .map((item) => ({
                id: item.action.id,
                label: item.action.label,
                description: item.action.description ?? null,
                extensionId: item.extensionId
            }))
            .sort((a, b) => a.id.localeCompare(b.id));
    }

    public has(actionId: string): boolean {
        return this.actions.has(actionId.trim().toLowerCase());
    }

    public async run(actionId: string, context: QuickActionContext): Promise<void> {
        const normalizedId = actionId.trim().toLowerCase();
        const stored = this.actions.get(normalizedId);
        if (!stored) {
            throw new Error(`Unknown quick action: ${normalizedId}`);
        }
        await stored.action.run(context);
    }
}