Comment events

interface CommentEventPayload {
  comment: {
    id: string;
    content?: string; // May be omitted for certain visibility rules
    contentHtml?: string;
    contentMarkdown?: string;
    contentJson?: string;
    commentType: string;
    parentCommentId?: string;
    teamId?: string; // For ticket comments
    accountId?: string; // For account-related comments
    metadata: Record<string, unknown>;
    customerContact?: {
      id: string;
      email: string;
      avatarUrl: string;
    };
    author: {
      id: string;
      name: string;
      email: string;
      avatarUrl: string;
    };
    attachments: Array<{
      id: string;
      name: string;
      url: string;
      size: number;
      contentType: string;
      createdAt: Date;
      updatedAt: Date;
      deletedAt?: Date;
    }>;
    commentVisibility: string;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date;
    shouldSendEmail?: boolean; // Only for created events
    createdWithTicket?: boolean; // Only for created events
  };
  // Entity-specific payload additions
  ticket?: {
    id: string;
    title: string;
    description?: string;
    requestorEmail?: string;
    submitterEmail?: string;
    source: string;
    isProactive?: boolean;
    proactiveChannels?: string[];
  };
  accountTask?: {
    id: string;
    title: string;
  };
  accountActivity?: {
    id: string;
  };
  accountNote?: {
    id: string;
  };
}

interface CommentUpdateEventPayload {
  comment: {
    previous: CommentData; // Previous state of the comment
    updated: CommentData;  // Updated state of the comment
  };
  // Same entity-specific additions as above
}

interface ReactionEventPayload {
  reaction: {
    name: string; // Emoji name (e.g., "thumbs_up", "heart")
    author: {
      id: string;
      name: string;
      avatarUrl: string;
      email: string;
    };
    metadata: Record<string, any>;
  };
  comment: {
    id: string;
  };
}

interface CommentSNSEvent {
  eventId: string;
  eventType: string; // e.g., "ticket:comment:created"
  timestamp: string;
  orgId: string;
  actor: {
    id: string;
    type: string;
    email: string;
  };
  payload: CommentEventPayload | CommentUpdateEventPayload | ReactionEventPayload;
}

{
  mentions: {
    users: Array<{
      id: string;
      email: string;
      name: string;
    }>;
  };
  ignoreSelf: boolean; // Indicates if the author should be excluded from notifications
}

{
  source: "slack" | "email" | "api" | "web";
  integrationId?: string;
  externalId?: string;
  syncStatus?: string;
}

function handleCommentCreated(payload) {
  const { comment, ticket, accountTask } = payload;
  
  // Determine notification recipients
  const recipients = [];
  
  if (ticket) {
    // Notify ticket participants
    recipients.push(ticket.assignedAgent);
    recipients.push(ticket.customer);
  } else if (accountTask) {
    // Notify task assignee and watchers
    recipients.push(accountTask.assignedUser);
    recipients.push(...accountTask.watchers);
  }
  
  // Send notifications
  recipients.forEach(recipient => {
    if (comment.shouldSendEmail) {
      sendEmailNotification(recipient, comment, { ticket, accountTask });
    }
    sendInAppNotification(recipient, comment);
  });
}

function handleCommentUpdate(payload) {
  const { comment } = payload;
  const { previous, updated } = comment;
  
  // Sync to external systems
  if (previous.content !== updated.content) {
    // Content changed
    syncContentToExternalSystems(updated);
    
    // Log edit history
    logCommentEdit({
      commentId: updated.id,
      previousContent: previous.content,
      newContent: updated.content,
      editedBy: payload.actor.id,
      editedAt: updated.updatedAt
    });
  }
  
  // Update search index
  updateSearchIndex(updated);
}

function handleReactionEvent(payload) {
  const { reaction, comment } = payload;
  
  // Update reaction counts
  updateReactionCounts(comment.id, reaction.name, payload.eventType);
  
  // Notify comment author (if not self-reaction)
  if (reaction.author.id !== comment.author.id) {
    notifyCommentAuthor(comment.author.id, {
      type: 'reaction',
      reaction: reaction.name,
      reactorName: reaction.author.name,
      commentId: comment.id
    });
  }
  
  // Track engagement metrics
  trackEngagement({
    type: 'reaction',
    reactionType: reaction.name,
    commentId: comment.id,
    userId: reaction.author.id
  });
}

function handleCommentWithMentions(payload) {
  const { comment, metadata } = payload;
  
  if (metadata?.mentions?.users) {
    metadata.mentions.users.forEach(mentionedUser => {
      // Skip self-mentions if ignoreSelf is true
      if (metadata.ignoreSelf && mentionedUser.id === comment.author.id) {
        return;
      }
      
      // Send mention notification
      sendMentionNotification(mentionedUser, {
        comment,
        mentionedBy: comment.author,
        context: payload.ticket || payload.accountTask || payload.accountActivity
      });
      
      // Track mention metrics
      trackMention({
        mentionedUserId: mentionedUser.id,
        mentionedByUserId: comment.author.id,
        commentId: comment.id
      });
    });
  }
}

function handleThreadedComment(payload) {
  const { comment } = payload;
  
  if (comment.parentCommentId) {
    // This is a reply to another comment
    const parentComment = getCommentById(comment.parentCommentId);
    
    // Notify parent comment author
    notifyCommentAuthor(parentComment.author.id, {
      type: 'reply',
      replyId: comment.id,
      replyContent: comment.content,
      repliedBy: comment.author
    });
    
    // Update thread metrics
    updateThreadMetrics(comment.parentCommentId);
  }
}

function handleCommentAttachments(payload) {
  const { comment } = payload;
  
  comment.attachments?.forEach(attachment => {
    // Process attachment
    processAttachment({
      id: attachment.id,
      name: attachment.name,
      size: attachment.size,
      contentType: attachment.contentType,
      url: attachment.url,
      commentId: comment.id
    });
    
    // Virus scan for new attachments
    if (payload.eventType.includes('created')) {
      scheduleVirusScan(attachment.id);
    }
    
    // Update storage metrics
    updateStorageMetrics(attachment.size);
  });
}