// Example result
{
  detectedLanguage: 'en',
  languageConfidence: 0.95
}

// Example result
{
  sentiment: 'positive',
  sentimentScore: 0.7  // Range: -1 (negative) to +1 (positive)
}

import { getContentClassifier } from '@/lib/moderation/content-classifier'

const classifier = getContentClassifier()

const result = await classifier.classify(
  "Can anyone help me fix this bug? It's really frustrating!",
  'text'
)

console.log(result)
// {
//   primaryCategory: 'support',
//   confidence: 0.8,
//   categories: [
//     { name: 'support', score: 0.8 },
//     { name: 'question', score: 0.6 },
//     { name: 'complaint', score: 0.5 }
//   ],
//   sentiment: 'negative',
//   sentimentScore: -0.4,
//   isInappropriate: false,
//   isSafe: true
// }

classifier.addCategory('legal', ['contract', 'agreement', 'terms', 'liability', 'compliance'], 0.7)

import { getToxicityDetector } from '@/lib/moderation/toxicity-detector'

const detector = getToxicityDetector({
  enablePerspectiveAPI: true,
  perspectiveApiKey: process.env.PERSPECTIVE_API_KEY,
  enableFallback: true,

  // Thresholds (0-1)
  toxicityThreshold: 0.7,
  severeToxicityThreshold: 0.8,
  insultThreshold: 0.7,
  profanityThreshold: 0.5,
  threatThreshold: 0.8,
  identityAttackThreshold: 0.75,

  // Languages to check
  languages: ['en', 'es', 'fr'],

  // Which categories to check
  checkAttributes: [
    'TOXICITY',
    'SEVERE_TOXICITY',
    'INSULT',
    'PROFANITY',
    'THREAT',
    'IDENTITY_ATTACK',
    'SEXUALLY_EXPLICIT',
  ],
})

const analysis = await detector.analyze("You're a complete idiot and I hate you!", 'en')

console.log(analysis)
// {
//   isToxic: true,
//   overallScore: 0.89,
//   scores: {
//     toxicity: 0.92,
//     severeToxicity: 0.45,
//     insult: 0.95,
//     profanity: 0.3,
//     threat: 0.1,
//     identityAttack: 0.05,
//     sexuallyExplicit: 0.02
//   },
//   triggeredCategories: ['toxicity', 'insult'],
//   confidence: 0.85,
//   mostToxicSpans: [
//     {
//       text: "complete idiot",
//       category: 'insult',
//       score: 0.95,
//       begin: 10,
//       end: 24
//     }
//   ],
//   language: 'en',
//   modelVersion: 'v0.7.0-toxicity'
// }

// Pattern examples
const patterns = {
  toxicity: [/\b(hate|stupid|dumb|idiot|moron|loser|pathetic)\b/gi],
  severeToxicity: [/\b(kill|die|hurt|attack|destroy|murder)\b/gi],
  threat: [
    /i will (kill|hurt|attack|destroy|beat|shoot|stab)/gi,
    /going to (kill|hurt|attack|destroy)/gi,
  ],
}

// Detected patterns
- More than 3 links in one message
- Links to non-whitelisted domains
- High link-to-text ratio (few words, many links)
- Shortened URLs (bit.ly, tinyurl, goo.gl, etc.)

// Analyzed metrics
- Message rate (messages per minute)
- Duplicate message count
- Account age
- Trust score (0-100)
- Recent message history

import { getSpamDetectorML } from '@/lib/moderation/spam-detector-ml'

const detector = getSpamDetectorML({
  // Thresholds
  linkSpamThreshold: 0.6,
  promotionalThreshold: 0.7,
  capsRatioThreshold: 0.7,
  punctuationRatioThreshold: 0.3,
  messageRateThreshold: 10, // messages per minute

  // Limits
  maxLinksPerMessage: 3,
  maxConsecutiveMessages: 5,
  maxDuplicateMessages: 3,

  // Feature flags
  enableLinkDetection: true,
  enablePromotionalDetection: true,
  enableFloodDetection: true,
  enableDuplicateDetection: true,

  // Whitelist
  whitelistedDomains: ['github.com', 'yourcompany.com'],
  trustedUsers: ['user-id-1', 'user-id-2'],
})

const analysis = await detector.analyze(
  '🔥🔥🔥 CLICK HERE NOW!!! Limited time offer! Buy now and get 50% OFF! Visit bit.ly/amazing-deal',
  {
    userId: 'user-123',
    hasAttachments: false,
    accountAge: 1, // days
    trustScore: 30,
  }
)

console.log(analysis)
// {
//   isSpam: true,
//   spamScore: 0.85,
//   confidence: 0.9,
//   spamTypes: [
//     'promotional',
//     'excessive_caps',
//     'excessive_punctuation',
//     'shortened_urls'
//   ],
//   reasons: [
//     'Spam phrases: click here, buy now, limited time',
//     'Promotional keywords: offer, buy',
//     'Excessive capitalization: 42%',
//     'Excessive punctuation: 18%',
//     'Shortened URLs detected: 1',
//     'New account (< 1 day)',
//     'Low trust score'
//   ],
//   patterns: {
//     linkCount: 1,
//     shortenedUrls: 1,
//     capsRatio: 0.42,
//     punctuationRatio: 0.18,
//     repetitiveChars: 2,
//     spamPhrases: ['click here', 'buy now', 'limited time']
//   },
//   userBehavior: {
//     messageRate: 2.5,
//     duplicateMessages: 0,
//     accountAge: 1,
//     trustScore: 30
//   }
// }

// Add whitelisted domain
detector.updateConfig({
  whitelistedDomains: [...detector.getConfig().whitelistedDomains, 'trusted-partner.com'],
})

// Add trusted user
detector.updateConfig({
  trustedUsers: [...detector.getConfig().trustedUsers, 'trusted-user-id'],
})

// Cleanup old user history periodically
setInterval(
  () => {
    detector.cleanupHistory()
  },
  60 * 60 * 1000
) // Every hour

import { ModerationQueue } from '@/lib/moderation/moderation-queue'
import { getApolloClient } from '@/lib/apollo-client'

const queue = new ModerationQueue(getApolloClient())

// Add item to queue
await queue.addToQueue({
  contentId: 'message-id',
  contentType: 'message',
  userId: 'user-id',
  analysis: {
    // Analysis results from AI moderator
    overallScore: 0.85,
    detectedIssues: [...],
    // ... full analysis object
  }
})

// Get pending items
const items = await queue.getPendingItems({
  priority: 'high',
  limit: 10,
  offset: 0,
})

// Approve content
await queue.approveContent(
  'queue-item-id',
  'moderator-id',
  'False positive - legitimate discussion'
)

// Reject content
await queue.rejectContent('queue-item-id', 'moderator-id', 'Confirmed spam - promotional content')

// User submits appeal
await queue.submitAppeal('queue-item-id', 'I believe this was flagged incorrectly because...')

// Moderator reviews appeal
await queue.reviewAppeal(
  'queue-item-id',
  'moderator-id',
  'approved', // or 'rejected'
  'Appeal accepted - content reinstated'
)

const stats = await queue.getQueueStats()

console.log(stats)
// {
//   total: 142,
//   byStatus: {
//     pending: 45,
//     approved: 87,
//     rejected: 10
//   },
//   byPriority: {
//     critical: 2,
//     high: 15,
//     medium: 23,
//     low: 5
//   },
//   avgReviewTime: 1800000, // 30 minutes in ms
//   pendingOlderThan24h: 3
// }

const thresholds = {
  // Content score thresholds
  toxicity: 0.7,
  nsfw: 0.7,
  spam: 0.6,
  profanity: 0.5,

  // Auto-action thresholds
  flagThreshold: 0.5, // Flag for manual review
  hideThreshold: 0.8, // Auto-hide content
  warnThreshold: 0.7, // Warn user
  muteThreshold: 0.85, // Temporary mute
  banThreshold: 0.95, // Permanent ban

  // User behavior thresholds
  maxViolationsPerDay: 3,
  maxViolationsPerWeek: 5,
  maxViolationsTotal: 10,

  // Minimum confidence for auto-action
  minimumConfidenceForAutoAction: 0.6,
}

// Pseudocode
if (confidence < minimumConfidence) {
  return 'none' // Too uncertain
}

if (shouldBan && autoBan) {
  return 'ban'
} else if (shouldMute && autoMute) {
  return 'mute'
} else if (shouldHide && autoHide) {
  return 'hide'
} else if (shouldWarn && autoWarn) {
  return 'warn'
} else if (shouldFlag && autoFlag) {
  return 'flag'
} else {
  return 'none'
}

interface UserViolationHistory {
  userId: string
  totalViolations: number
  violationsToday: number
  violationsThisWeek: number
  lastViolationAt: Date
  trustScore: number // 0-100, decreases with violations
  isMuted: boolean
  mutedUntil?: Date
  isBanned: boolean
  bannedUntil?: Date
  warnings: number
}

import { getAIModerator } from '@/lib/moderation/ai-moderator'

const moderator = getAIModerator({
  // Feature flags
  enableToxicityDetection: true,
  enableNSFWDetection: true,
  enableSpamDetection: true,
  enableProfanityFilter: true,

  // Auto-action toggles
  autoFlag: true,
  autoHide: false, // Disabled by default
  autoWarn: false, // Disabled by default
  autoMute: false, // Disabled by default
  autoBan: false, // Disabled by default

  // Thresholds
  thresholds: {
    toxicity: 0.7,
    nsfw: 0.7,
    spam: 0.6,
    profanity: 0.5,

    flagThreshold: 0.5,
    hideThreshold: 0.8,
    warnThreshold: 0.7,
    muteThreshold: 0.85,
    banThreshold: 0.95,

    maxViolationsPerDay: 3,
    maxViolationsPerWeek: 5,
    maxViolationsTotal: 10,
  },

  // Custom word lists
  customBlockedWords: ['custom-blocked-word'],
  customAllowedWords: ['custom-allowed-word'],

  // User lists
  whitelistedUsers: ['trusted-user-id'],
  blacklistedUsers: ['banned-user-id'],

  // Learning
  enableFalsePositiveLearning: true,
  minimumConfidenceForAutoAction: 0.6,
})

// Analyze content
const analysis = await moderator.analyzeContent(
  'content-id',
  'message',
  'This is the message content',
  {
    userId: 'user-id',
    channelId: 'channel-id',
    hasLinks: true,
    linkCount: 2,
  }
)

// Execute auto-action
if (analysis.autoAction !== 'none') {
  await executeAction(analysis.autoAction, analysis)
}

import { ModerationActions } from '@/lib/moderation/actions'

const actions = new ModerationActions(apolloClient)

// Mute for 24 hours
await actions.muteUser(
  'user-id',
  'moderator-id',
  'Repeated spam',
  1440 // minutes (24 hours)
)

// Ban for 7 days
await actions.banUser(
  'user-id',
  'moderator-id',
  'Severe toxicity',
  10080 // minutes (7 days)
)

await actions.bulkAction(
  'hide', // action type
  [
    { targetType: 'message', targetId: 'msg-1', targetUserId: 'user-1' },
    { targetType: 'message', targetId: 'msg-2', targetUserId: 'user-1' },
    { targetType: 'message', targetId: 'msg-3', targetUserId: 'user-1' },
  ],
  'moderator-id',
  'Spam campaign detected',
  { isAutomated: true }
)

await moderator.recordFalsePositive(
  'content-id',
  'toxicity',
  0.2, // actual score (should be low)
  0.8 // predicted score (was high)
)

// Example metrics
{
  totalDetections: 1000,
  falsePositives: 50,
  falsePositiveRate: 0.05, // 5%

  byCategory: {
    toxicity: { total: 300, fp: 15, rate: 0.05 },
    spam: { total: 400, fp: 20, rate: 0.05 },
    profanity: { total: 200, fp: 10, rate: 0.05 },
    nsfw: { total: 100, fp: 5, rate: 0.05 }
  },

  byConfidence: {
    high: { total: 500, fp: 10, rate: 0.02 },
    medium: { total: 300, fp: 20, rate: 0.067 },
    low: { total: 200, fp: 20, rate: 0.1 }
  }
}

// Add allowed word
moderator.updatePolicy({
  customAllowedWords: [
    ...moderator.getPolicy().customAllowedWords,
    'scunthorpe', // Known false positive for profanity filter
    'arsenal', // Sports team name
  ],
})

// Example: Technical discussions may trigger profanity filter
const analysis = await moderator.analyzeContent(
  'content-id',
  'message',
  'The server is damn slow today', // Contains profanity but technical context
  {
    userId: 'user-id',
    channelId: 'tech-support-channel', // Channel context
    messageCount: 50, // User has history
    timeWindow: 3600,
  }
)

// User contests action
await queue.submitAppeal(
  'moderation-item-id',
  'This was flagged incorrectly. I was discussing historical events, not promoting violence.'
)

// System learns from appeal decisions
if (appealApproved) {
  await moderator.recordFalsePositive(
    contentId,
    'threat',
    actualScore: 0.1,
    predictedScore: 0.8
  )
}

interface ModerationMetrics {
  // Volume
  totalAnalyzed: number
  totalFlagged: number
  totalActioned: number

  // Rates
  flagRate: number // Percentage of content flagged
  actionRate: number // Percentage requiring action
  falsePositiveRate: number

  // By Category
  toxicityDetections: number
  spamDetections: number
  profanityDetections: number
  nsfwDetections: number

  // By Action
  actionBreakdown: {
    flag: number
    hide: number
    warn: number
    mute: number
    ban: number
    delete: number
  }

  // Performance
  avgProcessingTime: number // milliseconds
  avgReviewTime: number // time to moderator review

  // User Impact
  uniqueUsersAffected: number
  repeatOffenders: number
  accountsBanned: number
}

{
  daily: [
    { date: '2026-01-31', flagged: 45, actioned: 12 },
    { date: '2026-01-30', flagged: 38, actioned: 10 },
    // ...
  ],
  weekly: [...],
  monthly: [...]
}

// Export analytics to CSV
const analytics = await getAnalytics({
  startDate: '2026-01-01',
  endDate: '2026-01-31',
  format: 'csv',
})

// Download report
downloadFile(analytics, 'moderation-report-jan-2026.csv')

const initialConfig = {
  autoFlag: true, // ✅ Enable
  autoHide: false, // ❌ Disable
  autoWarn: false, // ❌ Disable
  autoMute: false, // ❌ Disable
  autoBan: false, // ❌ Disable

  thresholds: {
    flagThreshold: 0.6, // Higher threshold = less aggressive
    hideThreshold: 0.9, // Very high
    warnThreshold: 0.85,
    muteThreshold: 0.9,
    banThreshold: 0.95,
  },
}

const hybridConfig = {
  // Auto-action for obvious violations
  autoHide: true,
  hideThreshold: 0.9, // Very high confidence

  // Flag borderline cases
  autoFlag: true,
  flagThreshold: 0.5, // Catch potential issues

  // Manual review in between
  // 0.5-0.9 = Queue for moderator review

  // Progressive discipline
  autoWarn: true,
  warnThreshold: 0.75,

  // Severe actions require high confidence
  autoMute: false, // Manual only
  autoBan: false, // Manual only
}

const professionalConfig = {
  thresholds: {
    toxicity: 0.6, // Lower (stricter)
    spam: 0.5, // Lower (stricter)
    profanity: 0.7, // Higher (more lenient)
  },
}

const gamingConfig = {
  thresholds: {
    toxicity: 0.8, // Higher (more lenient)
    severeToxicity: 0.6, // Lower (stricter)
    identityAttack: 0.6, // Lower (stricter)
    nsfw: 0.6, // Lower (stricter)
  },
}

const educationalConfig = {
  thresholds: {
    toxicity: 0.5,
    severeToxicity: 0.4,
    threat: 0.5,
    identityAttack: 0.5,
    nsfw: 0.3,
  },
  customAllowedWords: [
    // Educational terms that might trigger false positives
  ],
}

interface ModerationDataPolicy {
  // What data is collected
  dataCollected: [
    'Message content (temporary)',
    'User ID',
    'Timestamps',
    'Analysis scores',
    'Moderator actions',
  ]

  // Legal basis
  legalBasis: 'Legitimate interest (platform safety)'

  // Data retention
  retention: {
    analyzedContent: '24 hours' // Then deleted
    moderationActions: '2 years'
    auditLogs: '7 years'
    userViolationHistory: 'While account active'
  }

  // User rights
  userRights: {
    accessData: true // Export moderation history
    rectification: true // Contest decisions
    erasure: true // Delete after account closure
    portability: true // Export in machine-readable format
    objectAutomated: true // Appeal automated decisions
  }
}

// Enable user consent
const privacyConfig = {
  requireConsent: true,
  consentMessage: 'We use AI to analyze content for safety. View our privacy policy.',
  allowOptOut: false, // Cannot opt out of safety features

  // Data minimization
  analyzeOnlyPublicContent: true,
  excludeDirectMessages: true,

  // Anonymization
  anonymizeInReports: true,
  hashUserIds: true,
}

// Scheduled cleanup job
async function cleanupModeration() {
  // Delete old analyzed content
  await db.deleteWhere({
    table: 'analyzed_content',
    where: { created_at: { olderThan: '24 hours' } },
  })

  // Anonymize old audit logs
  await db.update({
    table: 'moderation_actions',
    where: { created_at: { olderThan: '2 years' } },
    set: { user_id: 'ANONYMIZED' },
  })
}

// Run daily
schedule.daily(cleanupModeration)

interface AuditLog {
  // Action details
  id: string
  timestamp: Date
  actionType: string

  // Who
  moderatorId: string
  moderatorRole: string
  isAutomated: boolean

  // What
  targetType: string
  targetId: string
  targetUserId: string

  // Why
  reason: string
  analysisScore: number
  detectedIssues: string[]

  // Outcome
  decision: string
  reversible: boolean
  reversedBy?: string
  reversedAt?: Date

  // Impact
  affectedUsers: number
  affectedContent: number
}

// Get all actions for a user
const userAudit = await getAuditLog({
  targetUserId: 'user-id',
  startDate: '2026-01-01',
  endDate: '2026-01-31',
})

// Get automated actions
const automatedAudit = await getAuditLog({
  isAutomated: true,
  actionType: 'ban',
})

// Export for compliance
const complianceReport = await exportAuditLog({
  format: 'json',
  includePersonalData: false, // GDPR-safe export
  startDate: '2025-01-01',
  endDate: '2025-12-31',
})

// Increase thresholds
moderator.updatePolicy({
  thresholds: {
    flagThreshold: 0.6, // Was 0.5
    hideThreshold: 0.85, // Was 0.8
  },
})

// Add allowed words
moderator.updatePolicy({
  customAllowedWords: ['commonly-flagged-word'],
})

// Whitelist trusted users
moderator.updatePolicy({
  whitelistedUsers: ['trusted-user-id'],
})

// Enable caching (built-in)
const detector = getToxicityDetector({
  enableCache: true,
  cacheTTL: 300000, // 5 minutes
})

// Use fallback detection
const detector = getToxicityDetector({
  enableFallback: true, // Use rule-based if API fails
})

// Optimize analysis
const moderator = getAIModerator({
  // Disable NSFW for text-only
  enableNSFWDetection: false,

  // Skip profanity for technical channels
  enableProfanityFilter: false,
})

// Batch processing
const results = await Promise.all(
  messages.map((msg) => moderator.analyzeContent(msg.id, 'message', msg.content))
)

import { getAIModerator } from '@/lib/moderation/ai-moderator'

const moderator = getAIModerator(customPolicy)

// Analyze content
const analysis = await moderator.analyzeContent(contentId, contentType, content, metadata)

// Record violation
await moderator.recordViolation(userId, severity)

// Update policy
moderator.updatePolicy(updates)

import { ModerationActions } from '@/lib/moderation/actions'

const actions = new ModerationActions(apolloClient)

// Flag content
await actions.flagContent(targetType, targetId, targetUserId, moderatorId, reason)

// Hide content
await actions.hideContent(targetType, targetId, targetUserId, moderatorId, reason)

// Warn user
await actions.warnUser(userId, moderatorId, reason)

// Mute user
await actions.muteUser(userId, moderatorId, reason, durationMinutes)

// Ban user
await actions.banUser(userId, moderatorId, reason, durationMinutes)

// Bulk actions
await actions.bulkAction(actionType, targets, moderatorId, reason, options)