/**
 * Reputation Alert Webhook Handler
 * Handles reputation degradation alerts and sends notifications
 */

import express from 'express';
import { notifyOwner } from '../_core/notification.ts';
import { calculateReputationScore, isReputationDegrading } from '../_core/reputationMonitoring.ts';
import type { ReputationScore, ReputationMetrics } from '../_core/reputationMonitoring.ts';

const router = express.Router();

// Store previous reputation scores for degradation detection
const reputationHistory = new Map<string, ReputationScore>();

/**
 * POST /api/reputation-alerts
 * Webhook endpoint for reputation monitoring alerts
 */
router.post('/', async (req, res) => {
  try {
    const { domain, metrics } = req.body;

    if (!domain || !metrics) {
      return res.status(400).json({ error: 'Missing domain or metrics' });
    }

    // Calculate current reputation score
    const currentScore = calculateReputationScore(metrics as ReputationMetrics);

    // Get previous score for comparison
    const previousScore = reputationHistory.get(domain);

    // Check for degradation
    let alertTriggered = false;
    let alertMessage = '';
    let alertDetails: string[] = [];

    if (previousScore) {
      const { isDegrading, changes } = isReputationDegrading(currentScore, previousScore);

      if (isDegrading) {
        alertTriggered = true;
        alertMessage = `⚠️ Email Reputation Alert: ${domain}`;
        alertDetails = changes;
      }
    }

    // Check for critical thresholds
    if (currentScore.status === 'critical') {
      alertTriggered = true;
      alertMessage = `🚨 CRITICAL: Email Reputation for ${domain}`;
      alertDetails.push(`Reputation score: ${currentScore.score}/100`);
      alertDetails.push(`Status: ${currentScore.status}`);
      alertDetails.push(`Alerts: ${currentScore.alerts.length}`);
    } else if (currentScore.status === 'poor') {
      alertTriggered = true;
      alertMessage = `⚠️ Poor Email Reputation: ${domain}`;
      alertDetails.push(`Reputation score: ${currentScore.score}/100`);
      alertDetails.push(`Status: ${currentScore.status}`);
    }

    // Check for blacklist status change
    if (previousScore && currentScore.metrics.blacklistStatus === 'listed' && previousScore.metrics.blacklistStatus !== 'listed') {
      alertTriggered = true;
      alertMessage = `🚨 CRITICAL: Domain Blacklisted - ${domain}`;
      alertDetails.push(`Domain is now listed on: ${currentScore.metrics.listedOn.join(', ')}`);
      alertDetails.push('Action Required: Submit delisting request immediately');
    }

    // Send notification if alert triggered
    if (alertTriggered) {
      const content = `
Domain: ${domain}
Score: ${currentScore.score}/100 (Grade: ${currentScore.grade})
Status: ${currentScore.status}

${alertDetails.join('\n')}

Key Metrics:
- Bounce Rate: ${currentScore.metrics.bounceRate.toFixed(2)}%
- Complaint Rate: ${currentScore.metrics.complaintRate.toFixed(3)}%
- Spam Trap Hits: ${currentScore.metrics.spamTrapHits}
- Blacklist Status: ${currentScore.metrics.blacklistStatus}

Recommendations:
${currentScore.recommendations.map((r) => `- ${r}`).join('\n')}

Check your admin dashboard for more details.
      `.trim();

      await notifyOwner({
        title: alertMessage,
        content,
      });
    }

    // Update history
    reputationHistory.set(domain, currentScore);

    res.json({
      success: true,
      domain,
      score: currentScore.score,
      status: currentScore.status,
      alertTriggered,
      alertMessage: alertTriggered ? alertMessage : 'No alert',
    });
  } catch (error) {
    console.error('[Reputation Alert] Error:', error);
    res.status(500).json({ error: 'Failed to process reputation alert' });
  }
});

/**
 * GET /api/reputation-alerts/:domain
 * Get reputation alert history for a domain
 */
router.get('/:domain', async (req, res) => {
  try {
    const { domain } = req.params;
    const score = reputationHistory.get(domain);

    if (!score) {
      return res.status(404).json({ error: 'No reputation data found for domain' });
    }

    res.json({
      domain,
      score: score.score,
      grade: score.grade,
      status: score.status,
      metrics: score.metrics,
      alerts: score.alerts,
      recommendations: score.recommendations,
      lastUpdated: score.metrics.lastUpdated,
    });
  } catch (error) {
    console.error('[Reputation Alert] Error:', error);
    res.status(500).json({ error: 'Failed to retrieve reputation data' });
  }
});

/**
 * POST /api/reputation-alerts/:domain/acknowledge
 * Acknowledge an alert
 */
router.post('/:domain/acknowledge', async (req, res) => {
  try {
    const { domain } = req.params;
    const { action, notes } = req.body;

    // Log acknowledgment
    console.log(`[Reputation Alert] Acknowledged for ${domain}: ${action} - ${notes}`);

    res.json({
      success: true,
      domain,
      acknowledged: true,
      action,
      notes,
    });
  } catch (error) {
    console.error('[Reputation Alert] Error:', error);
    res.status(500).json({ error: 'Failed to acknowledge alert' });
  }
});

/**
 * POST /api/reputation-alerts/:domain/remediate
 * Trigger automatic remediation
 */
router.post('/:domain/remediate', async (req, res) => {
  try {
    const { domain } = req.params;
    const { action } = req.body;

    const remediationActions: Record<string, string> = {
      clean_list: 'Cleaning email list and removing invalid addresses',
      reduce_volume: 'Reducing sending volume to restore reputation',
      pause_sends: 'Pausing all sends until reputation improves',
      verify_auth: 'Verifying SPF/DKIM/DMARC configuration',
      request_delisting: 'Submitting delisting requests to blacklists',
    };

    const actionDescription = remediationActions[action] || 'Unknown action';

    // Log remediation
    console.log(`[Reputation Alert] Remediation triggered for ${domain}: ${actionDescription}`);

    // Send notification
    await notifyOwner({
      title: `Remediation Started: ${domain}`,
      content: `Automatic remediation has been triggered for ${domain}.\n\nAction: ${actionDescription}\n\nPlease monitor your reputation dashboard for updates.`,
    });

    res.json({
      success: true,
      domain,
      action,
      description: actionDescription,
      status: 'remediation_started',
    });
  } catch (error) {
    console.error('[Reputation Alert] Error:', error);
    res.status(500).json({ error: 'Failed to trigger remediation' });
  }
});

export default router;