Task Functions

export const handler = async (event) => {
  try {
    const today = new Date();
    const yesterday = new Date(today);
    yesterday.setDate(yesterday.getDate() - 1);
    
    // Generate comprehensive sales report
    const salesData = await generateSalesReport(yesterday);
    
    // Calculate key metrics
    const metrics = {
      totalRevenue: salesData.orders.reduce((sum, order) => sum + order.total, 0),
      totalOrders: salesData.orders.length,
      averageOrderValue: salesData.orders.length > 0 
        ? salesData.totalRevenue / salesData.orders.length 
        : 0,
      newCustomers: salesData.orders.filter(o => o.isNewCustomer).length,
      returningCustomers: salesData.orders.filter(o => !o.isNewCustomer).length
    };
    
    // Generate report content
    const reportData = {
      date: yesterday.toISOString().split('T')[0],
      metrics,
      topProducts: await getTopProducts(yesterday),
      customerInsights: await getCustomerInsights(yesterday),
      comparisonWithPreviousDay: await getComparison(yesterday)
    };
    
    // Create HTML email report
    const emailHTML = await generateReportHTML(reportData);
    
    // Send to management team
    const recipients = await getReportRecipients('daily-sales');
    
    await sendEmail({
      to: recipients,
      subject: `Daily Sales Report - ${reportData.date}`,
      html: emailHTML,
      attachments: [
        {
          filename: `sales-report-${reportData.date}.pdf`,
          content: await generateReportPDF(reportData)
        }
      ]
    });
    
    // Store report in database for historical tracking
    await storeDailySalesReport(reportData);
    
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: 'Daily sales report generated and sent',
        date: reportData.date,
        metrics
      })
    };
    
  } catch (error) {
    console.error('Daily sales report failed:', error);
    
    // Send error notification to admin
    await sendErrorNotification('daily-sales-report', error);
    
    return {
      statusCode: 500,
      body: JSON.stringify({
        error: 'Report generation failed'
      })
    };
  }
};

export const handler = async (event) => {
  try {
    const results = {
      expiredSessions: 0,
      temporaryFiles: 0,
      oldLogs: 0,
      failedUploads: 0,
      totalSpaceFreed: 0
    };
    
    // Clean expired user sessions (older than 24 hours)
    const expiredSessions = await cleanupExpiredSessions(24);
    results.expiredSessions = expiredSessions.count;
    
    // Remove temporary files (older than 1 hour)
    const tempFiles = await cleanupTemporaryFiles(1);
    results.temporaryFiles = tempFiles.count;
    results.totalSpaceFreed += tempFiles.spaceFreed;
    
    // Archive old application logs (older than 30 days)
    const oldLogs = await archiveOldLogs(30);
    results.oldLogs = oldLogs.count;
    results.totalSpaceFreed += oldLogs.spaceFreed;
    
    // Clean up failed upload attempts (older than 1 day)
    const failedUploads = await cleanupFailedUploads(1);
    results.failedUploads = failedUploads.count;
    results.totalSpaceFreed += failedUploads.spaceFreed;
    
    // Update system health metrics
    await updateSystemHealthMetrics({
      lastCleanup: new Date().toISOString(),
      itemsProcessed: Object.values(results).reduce((sum, val) => 
        typeof val === 'number' ? sum + val : sum, 0),
      spaceFreedMB: Math.round(results.totalSpaceFreed / 1024 / 1024)
    });
    
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: 'Data cleanup completed successfully',
        timestamp: new Date().toISOString(),
        results
      })
    };
    
  } catch (error) {
    console.error('Data cleanup failed:', error);
    return {
      statusCode: 500,
      body: JSON.stringify({
        error: 'Cleanup task failed'
      })
    };
  }
};

export const handler = async (event) => {
  try {
    // Get all active newsletter subscribers
    const subscribers = await getNewsletterSubscribers();
    console.log(`Processing newsletter for ${subscribers.length} subscribers`);
    
    const results = {
      emailsSent: 0,
      errors: 0,
      unsubscribes: 0,
      bounces: 0
    };
    
    // Get content for the week
    const weeklyContent = await generateWeeklyContent();
    
    // Process subscribers in batches to avoid overwhelming the email service
    const batchSize = 100;
    for (let i = 0; i < subscribers.length; i += batchSize) {
      const batch = subscribers.slice(i, i + batchSize);
      
      const batchPromises = batch.map(async (subscriber) => {
        try {
          // Personalize content for this subscriber
          const personalizedContent = await personalizeNewsletter(
            weeklyContent, 
            subscriber
          );
          
          // Send personalized email
          await sendEmail({
            to: subscriber.email,
            subject: `Your Weekly Update - Week of ${weeklyContent.weekOf}`,
            html: personalizedContent.html,
            text: personalizedContent.text,
            unsubscribeLink: `https://myapp.com/unsubscribe?token=${subscriber.unsubscribeToken}`
          });
          
          // Track successful send
          await trackNewsletterSent(subscriber.id, weeklyContent.id);
          results.emailsSent++;
          
        } catch (error) {
          console.error(`Failed to send newsletter to ${subscriber.email}:`, error);
          results.errors++;
        }
      });
      
      // Wait for batch to complete before processing next batch
      await Promise.all(batchPromises);
      
      // Brief pause between batches
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
    
    // Update newsletter campaign stats
    await updateCampaignStats(weeklyContent.id, results);
    
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: 'Weekly newsletter campaign completed',
        campaignId: weeklyContent.id,
        results
      })
    };
    
  } catch (error) {
    console.error('Newsletter campaign failed:', error);
    return {
      statusCode: 500,
      body: JSON.stringify({
        error: 'Newsletter campaign failed'
      })
    };
  }
};