import { serve } from "https://deno.land/std@0.168.0/http/server.ts";
import { createClient } from "https://esm.sh/@supabase/supabase-js@2.57.4";

const corsHeaders = {
  'Access-Control-Allow-Origin': '*',
  'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type',
};

interface NotificationPayload {
  submission_id: string;
  submission_type: string;
  submitter_name: string;
  action: string;
  content_preview: string;
  submitted_at: string;
  has_photos: boolean;
  item_count: number;
  is_escalated: boolean;
}

serve(async (req) => {
  if (req.method === 'OPTIONS') {
    return new Response(null, { headers: corsHeaders });
  }

  try {
    const supabaseUrl = Deno.env.get('SUPABASE_URL')!;
    const supabaseServiceKey = Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!;
    
    const supabase = createClient(supabaseUrl, supabaseServiceKey);

    const payload: NotificationPayload = await req.json();
    const { 
      submission_id, 
      submission_type, 
      submitter_name, 
      action,
      content_preview,
      submitted_at,
      has_photos,
      item_count,
      is_escalated
    } = payload;

    console.log('Notifying moderators about submission via topic:', { 
      submission_id, 
      submission_type,
      content_preview 
    });

    // Calculate relative time and priority
    const submittedDate = new Date(submitted_at);
    const now = new Date();
    const waitTimeMs = now.getTime() - submittedDate.getTime();
    const waitTimeHours = waitTimeMs / (1000 * 60 * 60);
    
    // Format relative time
    const relativeTime = (() => {
      const minutes = Math.floor(waitTimeMs / (1000 * 60));
      const hours = Math.floor(waitTimeMs / (1000 * 60 * 60));
      const days = Math.floor(waitTimeMs / (1000 * 60 * 60 * 24));
      
      if (minutes < 1) return 'just now';
      if (minutes < 60) return `${minutes} minute${minutes !== 1 ? 's' : ''} ago`;
      if (hours < 24) return `${hours} hour${hours !== 1 ? 's' : ''} ago`;
      return `${days} day${days !== 1 ? 's' : ''} ago`;
    })();
    
    // Determine priority based on wait time
    const priority = waitTimeHours >= 24 ? 'urgent' : 'normal';

    // Get the moderation-alert workflow
    const { data: workflow, error: workflowError } = await supabase
      .from('notification_templates')
      .select('workflow_id')
      .eq('category', 'moderation')
      .eq('is_active', true)
      .single();

    if (workflowError || !workflow) {
      console.error('Error fetching workflow:', workflowError);
      return new Response(
        JSON.stringify({ 
          success: false, 
          error: 'Workflow not found or not active' 
        }),
        {
          headers: { ...corsHeaders, 'Content-Type': 'application/json' },
          status: 500,
        }
      );
    }

    // Prepare enhanced notification payload
    const notificationPayload = {
      // Basic info
      itemType: submission_type,
      submitterName: submitter_name,
      submissionId: submission_id,
      action: action || 'create',
      moderationUrl: `https://ydvtmnrszybqnbcqbdcy.supabase.co/admin/moderation`,
      
      // Enhanced content
      contentPreview: content_preview,
      
      // Timing information
      submittedAt: submitted_at,
      relativeTime: relativeTime,
      priority: priority,
      
      // Additional metadata
      hasPhotos: has_photos,
      itemCount: item_count,
      isEscalated: is_escalated,
    };

    // Send ONE notification to the moderation-submissions topic
    // All subscribers (moderators) will receive it automatically
    const { data, error } = await supabase.functions.invoke('trigger-notification', {
      body: {
        workflowId: workflow.workflow_id,
        topicKey: 'moderation-submissions',
        payload: notificationPayload,
      },
    });

    if (error) {
      console.error('Failed to notify moderators via topic:', error);
      return new Response(
        JSON.stringify({ 
          success: false, 
          error: 'Failed to send notification to topic',
          details: error.message 
        }),
        {
          headers: { ...corsHeaders, 'Content-Type': 'application/json' },
          status: 500,
        }
      );
    }

    console.log('Successfully notified all moderators via topic:', data);

    return new Response(
      JSON.stringify({
        success: true,
        message: 'Moderator notifications sent via topic',
        topicKey: 'moderation-submissions',
        transactionId: data?.transactionId,
      }),
      {
        headers: { ...corsHeaders, 'Content-Type': 'application/json' },
        status: 200,
      }
    );
  } catch (error: any) {
    console.error('Error in notify-moderators-submission:', error);
    
    return new Response(
      JSON.stringify({
        success: false,
        error: error.message,
      }),
      {
        headers: { ...corsHeaders, 'Content-Type': 'application/json' },
        status: 500,
      }
    );
  }
});