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

export const listQueueItems = createAction({
  name: 'list_queue_items',
  displayName: 'List Queue Items',
  description: 'Show all queued items for a specific queue',
  props: {
    queueId: Property.Dropdown({
      displayName: 'Select Queue',
      description: 'Select the queue to list 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 list items from'
          };
        } catch (error) {
          console.error('Failed to fetch MCP tools:', error);
          return {
            options: [],
            placeholder: 'Failed to connect to MCP server'
          };
        }
      },
    }),

    includeDetails: Property.Checkbox({
      displayName: 'Include Full Details',
      description: 'Include complete action configuration and parameters for each item',
      required: false,
      defaultValue: false,
    }),
  },

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

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

      // Verify queue exists
      let queue;
      try {
        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.`);
        }
      } catch (error: any) {
        throw new Error(`Failed to get queue configuration: ${error.message}`);
      }

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

      // Get all items in the queue
      let items;
      try {
        items = await QueueManager.listQueueItems(context, queueId as string);
        if (!Array.isArray(items)) {
          throw new Error('Invalid queue items data received');
        }
      } catch (error: any) {
        throw new Error(`Failed to get queue items: ${error.message}`);
      }

      // Format items for output
      let formattedItems;
      try {
        formattedItems = items.map(item => {
          if (!item || !item.id) {
            throw new Error('Invalid item data found in queue');
          }

          const baseInfo = {
            id: item.id,
            status: item.status,
            releaseTime: new Date(item.releaseTime).toISOString(),
            createdAt: new Date(item.createdAt).toISOString(),
            targetAction: item.targetAction,
            lastError: item.lastError || null,
          };

          if (includeDetails) {
            return {
              ...baseInfo,
              actionConfig: item.actionConfig,
            };
          }

          return baseInfo;
        });
      } catch (error: any) {
        throw new Error(`Failed to format queue items: ${error.message}`);
      }

      // Group items by status for summary
      let statusSummary;
      try {
        statusSummary = items.reduce((acc, item) => {
          acc[item.status] = (acc[item.status] || 0) + 1;
          return acc;
        }, {} as Record<string, number>);
      } catch (error: any) {
        throw new Error(`Failed to create status summary: ${error.message}`);
      }

      return {
        success: true,
        queueId: queueId as string,
        queueName: queue.mcpToolName,
        totalItems: items.length,
        statusSummary,
        items: formattedItems,
        queueStatus: status,
        retrievedAt: new Date().toISOString(),
        message: `Successfully retrieved ${items.length} items from queue "${queue.mcpToolName}"`,
      };

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