// backend/functions/send_message.ts
export async function sendMessage(input: SendMessageInput): Promise<Message> {
  // 1. Validate content (length, format, rate limiting)
  await validateMessageContent(input.content)

  // 2. Check permissions
  await checkChannelMembership(input.channelId, input.userId)

  // 3. Parse and sanitize content
  const sanitized = sanitizeMarkdown(input.content)
  const contentHtml = renderMarkdown(sanitized)

  // 4. Extract mentions and notify
  const mentions = extractMentions(sanitized)

  // 5. Insert message
  const message = await db.messages.insert({
    channel_id: input.channelId,
    user_id: input.userId,
    content: sanitized,
    content_html: contentHtml,
    type: input.type,
    reply_to_id: input.replyToId,
    thread_id: input.threadId,
    metadata: input.metadata,
  })

  // 6. Create mention records and trigger notifications
  if (mentions.length > 0) {
    await createMentionRecords(message.id, mentions)
    await triggerMentionNotifications(message, mentions)
  }

  // 7. Update channel activity
  await updateChannelActivity(input.channelId)

  return message
}

// Subscription events for messages
interface MessageEvents {
  'message:created': { channelId: string; message: Message }
  'message:updated': { channelId: string; messageId: string; updates: Partial<Message> }
  'message:deleted': { channelId: string; messageId: string; deletedBy: string }
}

describe('Message CRUD', () => {
  describe('Create', () => {
    it('should create message with valid content')
    it('should reject empty messages')
    it('should reject messages exceeding length limit')
    it('should sanitize HTML/script injection')
    it('should parse markdown correctly')
    it('should extract mentions')
    it('should enforce rate limiting')
    it('should require channel membership')
    it('should handle guest restrictions')
  })

  describe('Read', () => {
    it('should paginate messages correctly')
    it('should enforce visibility rules')
    it('should include user and attachment data')
    it('should filter deleted messages')
    it('should support search')
  })

  describe('Update', () => {
    it('should allow author to edit')
    it('should create edit history record')
    it('should mark message as edited')
    it('should re-parse mentions on edit')
    it('should enforce edit time window')
    it('should allow admin override')
  })

  describe('Delete', () => {
    it('should soft delete by default')
    it('should allow author to delete')
    it('should allow moderator to delete any')
    it('should record who deleted')
    it('should clean up attachments')
  })
})

// backend/functions/thread_notification.ts
async function notifyThreadParticipants(
  threadId: string,
  newMessage: Message,
  excludeUserId: string
) {
  const participants = await db.threadParticipants.find({
    thread_id: threadId,
    user_id: { _neq: excludeUserId },
    notifications_enabled: true,
  })

  for (const participant of participants) {
    await notificationsPlugin.send({
      userId: participant.user_id,
      type: 'thread_reply',
      title: `New reply in thread`,
      body: truncate(newMessage.content, 100),
      data: {
        threadId,
        messageId: newMessage.id,
        channelId: newMessage.channel_id,
      },
    })
  }
}

describe('Threads', () => {
  it('should create thread from message')
  it('should add author as participant')
  it('should track message count')
  it('should update last_reply_at')
  it('should notify participants of new replies')
  it('should allow joining/leaving thread')
  it('should support thread muting')
  it('should enforce thread lock')
  it('should display thread preview in channel')
})

// backend/functions/edit_message.ts
async function editMessage(
  messageId: string,
  newContent: string,
  editedBy: string,
  reason?: string
): Promise<Message> {
  // 1. Get current message
  const message = await db.messages.findById(messageId)

  // 2. Validate permissions
  if (message.user_id !== editedBy) {
    const membership = await getChannelMembership(message.channel_id, editedBy)
    if (!['owner', 'admin'].includes(membership.role)) {
      throw new Error('Not authorized to edit this message')
    }
  }

  // 3. Store edit history
  await db.messageEditHistory.insert({
    message_id: messageId,
    previous_content: message.content,
    previous_content_html: message.content_html,
    edited_by: editedBy,
    edit_reason: reason,
  })

  // 4. Update message
  const sanitized = sanitizeMarkdown(newContent)
  const contentHtml = renderMarkdown(sanitized)

  const updated = await db.messages.update(messageId, {
    content: sanitized,
    content_html: contentHtml,
    is_edited: true,
    edited_at: new Date(),
    updated_at: new Date(),
  })

  // 5. Re-process mentions
  await updateMessageMentions(messageId, sanitized)

  return updated
}

describe('Edit History', () => {
  it('should store previous content on edit')
  it('should record who edited')
  it('should record edit timestamp')
  it('should display edit indicator on message')
  it('should show full history in modal')
  it('should track multiple edits')
  it('should handle moderator edits')
})

describe('Pinning', () => {
  it('should require moderator role')
  it('should limit pins per channel')
  it('should create system message on pin')
  it('should display pinned messages list')
  it('should support pin notes')
})

describe('Bookmarking', () => {
  it('should allow any user to bookmark')
  it('should support notes')
  it('should support tags')
  it('should search bookmarks')
  it('should filter by tag')
})

// backend/functions/forward_message.ts
async function forwardMessage(
  messageId: string,
  targetChannelIds: string[],
  forwardedBy: string,
  comment?: string
): Promise<ForwardResult> {
  // 1. Get original message
  const original = await db.messages.findById(messageId)

  // 2. Check source channel permissions (can user see this message?)
  await checkMessageVisibility(messageId, forwardedBy)

  // 3. Check target channel permissions
  for (const channelId of targetChannelIds) {
    await checkChannelMembership(channelId, forwardedBy)
  }

  // 4. Check if forwarding is allowed (disappearing messages may block)
  if (original.disappearing_type && original.metadata?.prevent_forwarding) {
    throw new Error('This message cannot be forwarded')
  }

  // 5. Create forwarded messages
  const forwarded = await Promise.all(
    targetChannelIds.map(async (channelId) => {
      return db.messages.insert({
        channel_id: channelId,
        user_id: forwardedBy,
        content: comment || '',
        type: 'forwarded',
        forwarded_from_id: messageId,
        forward_comment: comment,
      })
    })
  )

  // 6. Log forwards for analytics
  await db.forwardLog.insertMany(
    forwarded.map((msg) => ({
      original_message_id: messageId,
      forwarded_message_id: msg.id,
      forwarded_by: forwardedBy,
    }))
  )

  return { forwarded_count: forwarded.length, messages: forwarded }
}

describe('Forwarding', () => {
  it('should forward to single channel')
  it('should forward to multiple channels')
  it('should preserve original attribution')
  it('should include optional comment')
  it('should check target permissions')
  it('should respect disappearing message restrictions')
  it('should log forward analytics')
})

describe('Quoting', () => {
  it('should render quote block')
  it('should link to original message')
  it('should show original author')
  it('should truncate long quotes')
})

// backend/jobs/send_scheduled_message.ts
import { jobsPlugin } from '@nself/plugins/jobs'

export async function registerScheduledMessageJob() {
  jobsPlugin.registerHandler('send_scheduled_message', async (job) => {
    const { scheduledMessageId } = job.data

    try {
      // 1. Get scheduled message
      const scheduled = await db.scheduledMessages.findById(scheduledMessageId)

      if (scheduled.status !== 'pending') {
        return { skipped: true, reason: `Status is ${scheduled.status}` }
      }

      // 2. Verify user still has permission
      const canSend = await checkChannelMembership(scheduled.channel_id, scheduled.user_id)

      if (!canSend) {
        await db.scheduledMessages.update(scheduledMessageId, {
          status: 'failed',
          error_message: 'User no longer has permission to send to this channel',
        })
        return { failed: true, reason: 'Permission denied' }
      }

      // 3. Send the message
      const message = await sendMessage({
        channelId: scheduled.channel_id,
        userId: scheduled.user_id,
        content: scheduled.content,
        type: scheduled.type,
        metadata: { ...scheduled.metadata, scheduled: true },
      })

      // 4. Update scheduled message record
      await db.scheduledMessages.update(scheduledMessageId, {
        status: 'sent',
        sent_at: new Date(),
        sent_message_id: message.id,
      })

      return { success: true, messageId: message.id }
    } catch (error) {
      await db.scheduledMessages.update(scheduledMessageId, {
        status: 'failed',
        error_message: error.message,
      })
      throw error
    }
  })
}

// Schedule a message
async function scheduleMessage(input: ScheduleMessageInput): Promise<ScheduledMessage> {
  // 1. Validate scheduled time (must be in future)
  const scheduledAt = new Date(input.scheduledAt)
  if (scheduledAt <= new Date()) {
    throw new Error('Scheduled time must be in the future')
  }

  // 2. Create scheduled message record
  const scheduled = await db.scheduledMessages.insert({
    channel_id: input.channelId,
    user_id: input.userId,
    content: sanitizeMarkdown(input.content),
    content_html: renderMarkdown(input.content),
    scheduled_at: scheduledAt,
    timezone: input.timezone || 'UTC',
    type: input.type || 'text',
    metadata: input.metadata,
  })

  // 3. Schedule job with jobs plugin
  const job = await jobsPlugin.schedule({
    name: 'send_scheduled_message',
    data: { scheduledMessageId: scheduled.id },
    runAt: scheduledAt,
    retries: 3,
    retryDelay: 60000, // 1 minute
  })

  // 4. Update with job ID
  await db.scheduledMessages.update(scheduled.id, {
    job_id: job.id,
  })

  return scheduled
}

import { zonedTimeToUtc, utcToZonedTime, format } from 'date-fns-tz'

function convertToUTC(localTime: string, timezone: string): Date {
  return zonedTimeToUtc(localTime, timezone)
}

function displayInUserTimezone(utcTime: Date, timezone: string): string {
  const zonedTime = utcToZonedTime(utcTime, timezone)
  return format(zonedTime, 'PPpp', { timeZone: timezone })
}

describe('Scheduled Messages', () => {
  it('should schedule message for future')
  it('should reject past times')
  it('should handle timezone conversion')
  it('should send at scheduled time')
  it('should allow editing before send')
  it('should allow cancellation')
  it('should handle send failures')
  it('should verify permissions at send time')
  it('should support attachments')
})

// backend/jobs/expire_messages.ts
import { jobsPlugin } from '@nself/plugins/jobs'

// Run every minute to clean up expired messages
jobsPlugin.schedule({
  name: 'expire_disappearing_messages',
  cron: '* * * * *', // Every minute
  handler: async () => {
    // 1. Find expired messages
    const expired = await db.messages.find({
      disappearing_expires_at: { _lte: new Date() },
      is_deleted: false,
    })

    // 2. Delete messages and their attachments
    for (const message of expired) {
      // Delete attachments from storage
      if (message.attachments?.length > 0) {
        await storagePlugin.deleteFiles(message.attachments.map((a) => a.file_url))
      }

      // Soft delete the message
      await db.messages.update(message.id, {
        is_deleted: true,
        deleted_at: new Date(),
        content: '', // Clear content for privacy
      })

      // Broadcast deletion to connected clients
      await realtimePlugin.broadcast({
        channel: `channel:${message.channel_id}`,
        event: 'message:expired',
        data: { messageId: message.id },
      })
    }

    return { deleted: expired.length }
  },
})

// backend/functions/view_message.ts
async function viewDisappearingMessage(
  messageId: string,
  viewerId: string
): Promise<Message | null> {
  const message = await db.messages.findById(messageId)

  if (!message || message.is_deleted) {
    return null
  }

  // View-once: can only be viewed once by recipient
  if (message.disappearing_type === 'view_once') {
    if (message.disappearing_viewed) {
      // Already viewed, return null content
      return { ...message, content: '[Message expired]', attachments: [] }
    }

    // Mark as viewed
    await db.messages.update(messageId, {
      disappearing_viewed: true,
      disappearing_viewed_at: new Date(),
      disappearing_viewed_by: viewerId,
    })

    // Schedule deletion after short delay
    await jobsPlugin.schedule({
      name: 'delete_view_once',
      data: { messageId },
      runAt: new Date(Date.now() + 5000), // 5 seconds
    })
  }

  // Burn after reading: start timer when opened
  if (message.disappearing_type === 'burn_after_reading') {
    if (!message.disappearing_expires_at) {
      const expiresAt = new Date(Date.now() + message.disappearing_duration * 1000)
      await db.messages.update(messageId, {
        disappearing_expires_at: expiresAt,
      })
    }
  }

  return message
}

describe('Disappearing Messages', () => {
  describe('Regular TTL', () => {
    it('should set expiration on send')
    it('should delete after duration')
    it('should clear content and attachments')
    it('should broadcast deletion')
  })

  describe('View Once', () => {
    it('should allow single view')
    it('should delete after viewed')
    it('should show placeholder if already viewed')
  })

  describe('Burn After Reading', () => {
    it('should start timer on open')
    it('should show countdown')
    it('should delete when timer expires')
  })

  describe('Settings', () => {
    it('should apply to new messages')
    it('should respect can_modify permission')
    it('should show banner when enabled')
  })
})

// Real-time reaction updates
realtimePlugin.on('reaction:add', async (data) => {
  const { messageId, emoji, userId } = data

  // Broadcast to all clients viewing this channel
  await realtimePlugin.broadcast({
    channel: `channel:${data.channelId}`,
    event: 'reaction:added',
    data: {
      messageId,
      emoji,
      user: await db.users.findById(userId, ['id', 'display_name', 'avatar_url']),
    },
  })
})

describe('Reactions', () => {
  it('should add reaction')
  it('should remove reaction')
  it('should toggle reaction')
  it('should prevent duplicate reactions')
  it('should broadcast to clients in real-time')
  it('should show reaction count')
  it('should show who reacted')
  it('should support custom emojis')
})

// backend/lib/mentions.ts
const MENTION_PATTERNS = {
  user: /@([a-zA-Z0-9_-]+)/g, // @username
  userId: /<@([A-Za-z0-9-]+)>/g, // <@user-id>
  channel: /#([a-zA-Z0-9_-]+)/g, // #channel-name
  channelId: /<#([A-Za-z0-9-]+)>/g, // <#channel-id>
  everyone: /@everyone/gi,
  here: /@here/gi,
  role: /@&([A-Za-z0-9-]+)/g, // @&role-id
}

interface ExtractedMention {
  type: 'user' | 'channel' | 'everyone' | 'here' | 'role'
  id?: string
  username?: string
  start: number
  end: number
}

function extractMentions(content: string): ExtractedMention[] {
  const mentions: ExtractedMention[] = []

  // @everyone
  for (const match of content.matchAll(MENTION_PATTERNS.everyone)) {
    mentions.push({
      type: 'everyone',
      start: match.index!,
      end: match.index! + match[0].length,
    })
  }

  // @here
  for (const match of content.matchAll(MENTION_PATTERNS.here)) {
    mentions.push({
      type: 'here',
      start: match.index!,
      end: match.index! + match[0].length,
    })
  }

  // @username
  for (const match of content.matchAll(MENTION_PATTERNS.user)) {
    mentions.push({
      type: 'user',
      username: match[1],
      start: match.index!,
      end: match.index! + match[0].length,
    })
  }

  // <@user-id>
  for (const match of content.matchAll(MENTION_PATTERNS.userId)) {
    mentions.push({
      type: 'user',
      id: match[1],
      start: match.index!,
      end: match.index! + match[0].length,
    })
  }

  return mentions
}

// backend/functions/create_mention_notifications.ts
async function createMentionNotifications(
  message: Message,
  mentions: ExtractedMention[]
): Promise<void> {
  const notifiedUserIds = new Set<string>()

  for (const mention of mentions) {
    let userIdsToNotify: string[] = []

    if (mention.type === 'everyone') {
      // Get all channel members
      const members = await db.channelMembers.find({
        channel_id: message.channel_id,
        user_id: { _neq: message.user_id },
      })
      userIdsToNotify = members.map((m) => m.user_id)
    } else if (mention.type === 'here') {
      // Get online channel members
      const members = await db.channelMembers.find({
        channel_id: message.channel_id,
        user_id: { _neq: message.user_id },
      })
      const presences = await db.userPresence.find({
        user_id: { _in: members.map((m) => m.user_id) },
        status: { _in: ['online', 'away'] },
      })
      userIdsToNotify = presences.map((p) => p.user_id)
    } else if (mention.type === 'user') {
      // Resolve username to ID if needed
      const userId = mention.id || (await resolveUsername(mention.username!))
      if (userId && userId !== message.user_id) {
        userIdsToNotify = [userId]
      }
    }

    // Create mention records and notifications
    for (const userId of userIdsToNotify) {
      if (notifiedUserIds.has(userId)) continue
      notifiedUserIds.add(userId)

      // Create mention record
      await db.mentions.insert({
        message_id: message.id,
        user_id: userId,
        type: mention.type,
      })

      // Send notification
      await notificationsPlugin.send({
        userId,
        type: 'mention',
        title: `${message.user.display_name} mentioned you`,
        body: truncate(message.content, 100),
        data: {
          messageId: message.id,
          channelId: message.channel_id,
          mentionType: mention.type,
        },
      })
    }
  }
}

describe('Mentions', () => {
  describe('Parsing', () => {
    it('should parse @username')
    it('should parse <@user-id>')
    it('should parse @everyone')
    it('should parse @here')
    it('should parse #channel')
  })

  describe('Notifications', () => {
    it('should notify mentioned user')
    it('should notify all members for @everyone')
    it('should notify online members for @here')
    it('should not self-notify')
    it('should deduplicate notifications')
  })

  describe('Autocomplete', () => {
    it('should search channel members')
    it('should show online status')
    it('should search channels')
    it('should prioritize recent interactions')
  })
})

// backend/lib/ssrf-protection.ts
import { URL } from 'url'
import { isPrivateIP } from 'net'
import dns from 'dns/promises'

const BLOCKED_HOSTS = [
  'localhost',
  '127.0.0.1',
  '0.0.0.0',
  '::1',
  'metadata.google.internal',
  '169.254.169.254', // AWS metadata
  'metadata.azure.com',
]

const BLOCKED_PROTOCOLS = ['file:', 'ftp:', 'gopher:']

async function validateUrl(urlString: string): Promise<void> {
  let url: URL

  try {
    url = new URL(urlString)
  } catch {
    throw new Error('Invalid URL')
  }

  // Check protocol
  if (BLOCKED_PROTOCOLS.includes(url.protocol)) {
    throw new Error('Protocol not allowed')
  }

  // Check hostname
  if (BLOCKED_HOSTS.includes(url.hostname.toLowerCase())) {
    throw new Error('Host not allowed')
  }

  // Resolve DNS and check for private IPs
  try {
    const addresses = await dns.resolve4(url.hostname)
    for (const addr of addresses) {
      if (isPrivateIP(addr)) {
        throw new Error('Private IP not allowed')
      }
    }
  } catch (error) {
    if (error.code === 'ENOTFOUND') {
      throw new Error('Host not found')
    }
    throw error
  }
}

async function fetchWithSsrfProtection(url: string, options: RequestInit = {}): Promise<Response> {
  await validateUrl(url)

  // Add timeout
  const controller = new AbortController()
  const timeout = setTimeout(() => controller.abort(), 10000)

  try {
    const response = await fetch(url, {
      ...options,
      signal: controller.signal,
      redirect: 'manual', // Handle redirects manually
      headers: {
        ...options.headers,
        'User-Agent': 'nChat-LinkPreview/1.0',
      },
    })

    // Handle redirects with SSRF check
    if ([301, 302, 307, 308].includes(response.status)) {
      const redirectUrl = response.headers.get('Location')
      if (redirectUrl) {
        await validateUrl(redirectUrl)
        return fetchWithSsrfProtection(redirectUrl, options)
      }
    }

    return response
  } finally {
    clearTimeout(timeout)
  }
}

// backend/services/link-unfurl.ts
import * as cheerio from 'cheerio'

interface LinkPreviewData {
  title?: string
  description?: string
  imageUrl?: string
  siteName?: string
  favicon?: string
  themeColor?: string
  videoUrl?: string
  author?: string
  publishedAt?: Date
}

async function unfurlLink(url: string): Promise<LinkPreviewData> {
  // 1. Check cache first
  const cached = await db.linkPreviews.findOne({
    url,
    expires_at: { _gt: new Date() },
  })

  if (cached) {
    return cached
  }

  // 2. Fetch with SSRF protection
  const response = await fetchWithSsrfProtection(url, {
    headers: { Accept: 'text/html' },
  })

  // 3. Check content type
  const contentType = response.headers.get('Content-Type') || ''
  if (!contentType.includes('text/html')) {
    throw new Error('Not an HTML page')
  }

  // 4. Parse HTML
  const html = await response.text()
  const $ = cheerio.load(html)

  // 5. Extract metadata (Open Graph, Twitter Cards, standard meta)
  const preview: LinkPreviewData = {
    title:
      $('meta[property="og:title"]').attr('content') ||
      $('meta[name="twitter:title"]').attr('content') ||
      $('title').text() ||
      undefined,

    description:
      $('meta[property="og:description"]').attr('content') ||
      $('meta[name="twitter:description"]').attr('content') ||
      $('meta[name="description"]').attr('content') ||
      undefined,

    imageUrl:
      $('meta[property="og:image"]').attr('content') ||
      $('meta[name="twitter:image"]').attr('content') ||
      undefined,

    siteName: $('meta[property="og:site_name"]').attr('content') || undefined,

    favicon:
      $('link[rel="icon"]').attr('href') ||
      $('link[rel="shortcut icon"]').attr('href') ||
      '/favicon.ico',

    themeColor: $('meta[name="theme-color"]').attr('content') || undefined,

    videoUrl:
      $('meta[property="og:video"]').attr('content') ||
      $('meta[property="og:video:url"]').attr('content') ||
      undefined,

    author:
      $('meta[name="author"]').attr('content') ||
      $('meta[property="article:author"]').attr('content') ||
      undefined,

    publishedAt: parseDate($('meta[property="article:published_time"]').attr('content')),
  }

  // 6. Resolve relative URLs
  const baseUrl = new URL(url)
  if (preview.imageUrl && !preview.imageUrl.startsWith('http')) {
    preview.imageUrl = new URL(preview.imageUrl, baseUrl).toString()
  }
  if (preview.favicon && !preview.favicon.startsWith('http')) {
    preview.favicon = new URL(preview.favicon, baseUrl).toString()
  }

  // 7. Cache result
  await db.linkPreviews.upsert({
    url,
    ...preview,
    fetched_at: new Date(),
    expires_at: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7 days
    fetch_status: 'success',
  })

  return preview
}

describe('Link Unfurling', () => {
  describe('SSRF Protection', () => {
    it('should block localhost')
    it('should block private IPs')
    it('should block internal metadata endpoints')
    it('should block file:// protocol')
    it('should validate redirect targets')
    it('should timeout slow requests')
  })

  describe('Metadata Extraction', () => {
    it('should extract Open Graph tags')
    it('should extract Twitter Cards')
    it('should fall back to standard meta tags')
    it('should resolve relative URLs')
    it('should handle missing metadata gracefully')
  })

  describe('Caching', () => {
    it('should cache results')
    it('should respect cache expiration')
    it('should handle cache misses')
  })
})

// backend/lib/markdown-sanitizer.ts
import DOMPurify from 'isomorphic-dompurify'
import { marked } from 'marked'
import hljs from 'highlight.js'

// Configure marked for security
marked.setOptions({
  gfm: true,
  breaks: true,
  headerIds: false,
  mangle: false,
  highlight: (code, lang) => {
    if (lang && hljs.getLanguage(lang)) {
      try {
        return hljs.highlight(code, { language: lang }).value
      } catch {
        // Ignore errors
      }
    }
    return code
  },
})

// DOMPurify configuration
const PURIFY_CONFIG: DOMPurify.Config = {
  ALLOWED_TAGS: [
    // Block elements
    'p',
    'br',
    'hr',
    // Headings
    'h1',
    'h2',
    'h3',
    'h4',
    'h5',
    'h6',
    // Text formatting
    'strong',
    'b',
    'em',
    'i',
    'u',
    's',
    'del',
    'ins',
    'code',
    'pre',
    'kbd',
    'samp',
    'var',
    'mark',
    'small',
    'sub',
    'sup',
    // Lists
    'ul',
    'ol',
    'li',
    // Quotes
    'blockquote',
    'q',
    'cite',
    // Links (will sanitize href)
    'a',
    // Tables
    'table',
    'thead',
    'tbody',
    'tfoot',
    'tr',
    'th',
    'td',
    // Other
    'details',
    'summary',
    'span',
    'div',
  ],
  ALLOWED_ATTR: [
    'href',
    'title',
    'alt',
    'class', // For syntax highlighting
    'target',
    'rel', // For links
    'colspan',
    'rowspan', // For tables
    'align',
  ],
  ALLOW_DATA_ATTR: false,
  FORBID_TAGS: ['script', 'style', 'iframe', 'object', 'embed', 'form', 'input'],
  FORBID_ATTR: ['onerror', 'onload', 'onclick', 'onmouseover'],
  // Transform hooks
  ADD_ATTR: ['target'],
  WHOLE_DOCUMENT: false,
  RETURN_DOM: false,
  RETURN_DOM_FRAGMENT: false,
}

// Add hooks for link sanitization
DOMPurify.addHook('afterSanitizeAttributes', (node) => {
  // Force links to open in new tab safely
  if (node.tagName === 'A') {
    node.setAttribute('target', '_blank')
    node.setAttribute('rel', 'noopener noreferrer nofollow')

    // Validate href
    const href = node.getAttribute('href')
    if (href) {
      // Block javascript: URLs
      if (href.toLowerCase().startsWith('javascript:')) {
        node.setAttribute('href', '#')
      }
      // Block data: URLs (except images)
      if (href.toLowerCase().startsWith('data:') && !href.toLowerCase().startsWith('data:image/')) {
        node.setAttribute('href', '#')
      }
    }
  }
})

/**
 * Sanitize raw markdown content (before rendering)
 */
export function sanitizeMarkdown(content: string): string {
  // Remove any HTML that might be in the markdown
  let sanitized = content

  // Escape HTML entities in non-code contexts
  // (preserve code blocks and inline code)
  const codeBlocks: string[] = []
  const inlineCode: string[] = []

  // Extract code blocks
  sanitized = sanitized.replace(/```[\s\S]*?```/g, (match) => {
    codeBlocks.push(match)
    return `__CODE_BLOCK_${codeBlocks.length - 1}__`
  })

  // Extract inline code
  sanitized = sanitized.replace(/`[^`]+`/g, (match) => {
    inlineCode.push(match)
    return `__INLINE_CODE_${inlineCode.length - 1}__`
  })

  // Escape HTML in remaining content
  sanitized = sanitized.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')

  // Restore code blocks
  codeBlocks.forEach((block, i) => {
    sanitized = sanitized.replace(`__CODE_BLOCK_${i}__`, block)
  })

  // Restore inline code
  inlineCode.forEach((code, i) => {
    sanitized = sanitized.replace(`__INLINE_CODE_${i}__`, code)
  })

  return sanitized
}

/**
 * Render markdown to sanitized HTML
 */
export function renderMarkdown(content: string): string {
  // First sanitize the markdown source
  const sanitizedMarkdown = sanitizeMarkdown(content)

  // Render to HTML
  const html = marked.parse(sanitizedMarkdown)

  // Sanitize the rendered HTML
  const sanitizedHtml = DOMPurify.sanitize(html, PURIFY_CONFIG)

  return sanitizedHtml
}

/**
 * Strip all formatting from content (plain text)
 */
export function stripFormatting(content: string): string {
  const html = renderMarkdown(content)
  return DOMPurify.sanitize(html, { ALLOWED_TAGS: [] })
}

describe('Markdown Sanitization', () => {
  describe('XSS Prevention', () => {
    it('should remove script tags')
    it('should remove onclick handlers')
    it('should remove javascript: URLs')
    it('should remove dangerous data: URLs')
    it('should handle nested XSS attempts')
    it('should sanitize malformed HTML')
  })

  describe('Allowed Formatting', () => {
    it('should render bold')
    it('should render italic')
    it('should render code blocks')
    it('should syntax highlight code')
    it('should render links with noopener')
    it('should render blockquotes')
    it('should render lists')
  })

  describe('Edge Cases', () => {
    it('should handle empty content')
    it('should handle very long content')
    it('should preserve whitespace in code')
    it('should handle unicode')
    it('should handle RTL text')
  })
})

// backend/functions/upload_attachment.ts
import { fileProcessingPlugin } from '@nself/plugins/file-processing'
import { minioClient } from '@nself/storage'

interface UploadInput {
  channelId: string
  userId: string
  fileName: string
  fileType: string
  fileSize: number
}

interface PresignedUploadResponse {
  uploadUrl: string
  fileKey: string
  expiresAt: Date
}

// Step 1: Get presigned upload URL
async function requestUploadUrl(input: UploadInput): Promise<PresignedUploadResponse> {
  // 1. Validate file type and size
  validateFileUpload(input)

  // 2. Check user permission
  await checkChannelMembership(input.channelId, input.userId)

  // 3. Check storage quota
  await checkStorageQuota(input.userId, input.fileSize)

  // 4. Generate storage key
  const fileKey = `channels/${input.channelId}/${Date.now()}-${sanitizeFileName(input.fileName)}`

  // 5. Get presigned URL from MinIO
  const uploadUrl = await minioClient.presignedPutObject(
    'attachments',
    fileKey,
    3600 // 1 hour expiry
  )

  return {
    uploadUrl,
    fileKey,
    expiresAt: new Date(Date.now() + 3600 * 1000),
  }
}

// Step 2: Confirm upload and process file
async function confirmUpload(
  messageId: string,
  fileKey: string,
  metadata?: Record<string, unknown>
): Promise<Attachment> {
  // 1. Verify file exists in storage
  const stat = await minioClient.statObject('attachments', fileKey)

  // 2. Create attachment record
  const attachment = await db.attachments.insert({
    message_id: messageId,
    file_name: extractFileName(fileKey),
    file_type: stat.metaData['content-type'],
    file_size: stat.size,
    file_url: `${STORAGE_URL}/${fileKey}`,
    storage_key: fileKey,
    metadata,
    processing_status: 'pending',
    virus_scan_status: 'pending',
  })

  // 3. Queue file processing
  await fileProcessingPlugin.process({
    attachmentId: attachment.id,
    fileKey,
    tasks: ['virus_scan', 'strip_exif', 'generate_thumbnail', 'optimize'],
  })

  return attachment
}

// File validation
function validateFileUpload(input: UploadInput): void {
  const MAX_FILE_SIZE = 100 * 1024 * 1024 // 100MB
  const ALLOWED_TYPES = [
    'image/jpeg',
    'image/png',
    'image/gif',
    'image/webp',
    'video/mp4',
    'video/webm',
    'video/quicktime',
    'audio/mpeg',
    'audio/ogg',
    'audio/wav',
    'application/pdf',
    'application/msword',
    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
    'text/plain',
    'text/markdown',
  ]

  if (input.fileSize > MAX_FILE_SIZE) {
    throw new Error(`File too large. Maximum size is ${MAX_FILE_SIZE / 1024 / 1024}MB`)
  }

  if (!ALLOWED_TYPES.includes(input.fileType)) {
    throw new Error('File type not allowed')
  }
}

// backend/handlers/file-processing.ts
import { fileProcessingPlugin } from '@nself/plugins/file-processing'

fileProcessingPlugin.on('processing:complete', async (result) => {
  const { attachmentId, tasks } = result

  const updates: Partial<Attachment> = {
    processing_status: 'complete',
  }

  // Update with processing results
  if (tasks.thumbnail) {
    updates.thumbnail_url = tasks.thumbnail.url
  }

  if (tasks.dimensions) {
    updates.width = tasks.dimensions.width
    updates.height = tasks.dimensions.height
  }

  if (tasks.duration) {
    updates.duration = tasks.duration.seconds
  }

  if (tasks.virus_scan) {
    updates.virus_scan_status = tasks.virus_scan.clean ? 'clean' : 'infected'
    updates.virus_scan_result = tasks.virus_scan.result

    // If infected, delete the file
    if (!tasks.virus_scan.clean) {
      await deleteInfectedFile(attachmentId)
      return
    }
  }

  await db.attachments.update(attachmentId, updates)
})

fileProcessingPlugin.on('processing:error', async (error) => {
  await db.attachments.update(error.attachmentId, {
    processing_status: 'failed',
    processing_error: error.message,
  })
})

// backend/middleware/attachment-access.ts
async function checkAttachmentAccess(attachmentId: string, userId: string): Promise<boolean> {
  const attachment = await db.attachments.findById(attachmentId)
  const message = await db.messages.findById(attachment.message_id)

  // Check if user has access to the channel
  const membership = await db.channelMembers.findOne({
    channel_id: message.channel_id,
    user_id: userId,
  })

  if (!membership) {
    // Check if channel is public
    const channel = await db.channels.findById(message.channel_id)
    return !channel.is_private
  }

  return true
}

// Generate signed URL for access
async function getSignedUrl(attachmentId: string, userId: string): Promise<string> {
  const hasAccess = await checkAttachmentAccess(attachmentId, userId)
  if (!hasAccess) {
    throw new Error('Access denied')
  }

  const attachment = await db.attachments.findById(attachmentId)

  return minioClient.presignedGetObject(
    attachment.bucket,
    attachment.storage_key,
    300 // 5 minute expiry
  )
}

describe('Attachments', () => {
  describe('Upload', () => {
    it('should validate file type')
    it('should validate file size')
    it('should check storage quota')
    it('should generate presigned URL')
    it('should handle upload completion')
  })

  describe('Processing', () => {
    it('should scan for viruses')
    it('should strip EXIF data')
    it('should generate thumbnails')
    it('should extract dimensions')
    it('should handle processing errors')
  })

  describe('Access Control', () => {
    it('should check channel membership')
    it('should allow public channel access')
    it('should generate signed URLs')
    it('should expire access tokens')
  })
})

interface MessagingFeatureFlags {
  threads: boolean
  reactions: boolean
  mentions: boolean
  forwarding: boolean
  scheduling: boolean
  disappearing: boolean
  linkPreviews: boolean
  fileUploads: boolean
  voiceMessages: boolean
  messageEdit: boolean
  messageEditHistory: boolean
  pinning: boolean
  bookmarking: boolean
}

const RATE_LIMITS = {
  sendMessage: { window: '1m', max: 30 },
  editMessage: { window: '1m', max: 20 },
  addReaction: { window: '1m', max: 60 },
  uploadFile: { window: '1h', max: 100, maxSizeMB: 500 },
  createThread: { window: '1h', max: 50 },
  forwardMessage: { window: '1m', max: 10 },
}

interface AuditLogEntry {
  timestamp: Date
  userId: string
  action: string
  resourceType: 'message' | 'thread' | 'reaction' | 'attachment'
  resourceId: string
  channelId: string
  metadata: Record<string, unknown>
  ipAddress?: string
  userAgent?: string
}

// e2e/messaging.spec.ts
describe('Core Messaging E2E', () => {
  test('Send and receive message in channel', async () => {
    // Login as user A
    // Navigate to channel
    // Send message
    // Verify message appears
    // Login as user B
    // Verify message visible
  })

  test('Create thread and reply', async () => {
    // Send message
    // Start thread
    // Add reply
    // Verify thread count
    // Verify notification
  })

  test('Full reaction workflow', async () => {
    // Send message
    // Add reaction
    // Verify reaction visible to others
    // Remove reaction
    // Verify removal
  })

  // ... more scenarios
})