@net3/queuer/src/lib/actions/clear-queue.ts

import {
  createAction,
  Property,
  ActionContext,
} from '@activepieces/pieces-framework';
import { QueueManager } from '../common/queue-manager';
import { MCPManager } from '../common/mcp-manager';

export const clearQueue = createAction({
  name: 'clear_queue',
  displayName: 'Clear Queue',
  description: 'Clear all items from a queue',
  props: {
    queueId: Property.Dropdown({
      displayName: 'Select Queue',
      description: 'Select the queue to clear all items from',
      required: true,
      refreshers: [],
      options: async ({ auth }) => {
        const authConfig = auth as { mcpServerUrl?: string };
        if (!authConfig.mcpServerUrl) {
          return { 
            options: [],
            placeholder: 'MCP Server URL required in auth configuration'
          };
        }
        
        try {
          const config = { mcpServerUrl: authConfig.mcpServerUrl };
          const tools = await MCPManager.listMCPTools(config);
          
          if (tools.length === 0) {
            return {
              options: [],
              placeholder: 'No MCP tools found'
            };
          }
          
          // Generate queue options based on available tools
          const queueOptions = tools.map((tool: any) => ({
            label: `Queue: ${tool.name} - ${tool.description || 'No description'}`,
            value: `mcp_${tool.name}_queue`,
          }));
          
          return {
            options: queueOptions,
            placeholder: 'Select a queue to clear'
          };
        } catch (error) {
          console.error('Failed to fetch MCP tools:', error);
          return {
            options: [],
            placeholder: 'Failed to connect to MCP server'
          };
        }
      },
    }),

  },

  async run(context: ActionContext) {
    try {
      const { queueId } = context.propsValue;

      if (!queueId) {
        throw new Error('Queue ID is required');
      }

      // Verify queue exists
      const queue = await QueueManager.getQueueConfiguration(context, queueId as string);
      if (!queue) {
        throw new Error(`Queue "${queueId}" not found. Make sure the queue was created using Create/Update Queue action.`);
      }

      // Get current status before clearing
      let statusBefore;
      try {
        statusBefore = await QueueManager.getQueueStatus(context, queueId as string);
        if (!statusBefore) {
          throw new Error(`Failed to get queue status for "${queueId}"`);
        }
      } catch (error: any) {
        throw new Error(`Failed to get queue status before clearing: ${error.message}`);
      }

      // Clear the queue
      let result;
      try {
        result = await QueueManager.clearQueue(context, queueId as string);
        if (!result) {
          throw new Error('Clear queue operation returned no result');
        }
      } catch (error: any) {
        throw new Error(`Failed to clear queue: ${error.message}`);
      }

      // Get updated status
      let statusAfter;
      try {
        statusAfter = await QueueManager.getQueueStatus(context, queueId as string);
        if (!statusAfter) {
          throw new Error(`Failed to get queue status after clearing`);
        }
      } catch (error: any) {
        throw new Error(`Failed to get queue status after clearing: ${error.message}`);
      }

      // Verify the clear operation was successful
      if (statusAfter.pendingItems > 0) {
        throw new Error(`Clear operation may have failed - ${statusAfter.pendingItems} items still remain in queue`);
      }

      return {
        success: true,
        queueId: result.queueId,
        clearedCount: result.clearedCount,
        queueName: queue.mcpToolName,
        statusBefore,
        statusAfter,
        clearedAt: new Date().toISOString(),
        message: `Successfully cleared ${result.clearedCount} items from queue "${queue.mcpToolName}"`,
      };

    } catch (error: any) {
      throw new Error(`Clear Queue Action Failed: ${error.message}`);
    }
  },
});