import { dK as defineContentEventHandler, c as createError, dL as optionalAuth, bT as requirePermission, aG as requireFeature, d$ as getCommentByIdForEntry, e0 as deleteComment, ad as logAuditEventAsync, e1 as broadcastCommentEvent, e2 as matchesScope, ae as getAdminScopesForRole } from '../../../../../../nitro/nitro.mjs';
import { m as mapContentApiError } from '../../../../../../_/api-helpers.mjs';
import { g as getAuditActorFromEvent } from '../../../../../../_/audit-log-actor.mjs';
import 'node:crypto';
import 'jsonwebtoken';
import 'node:fs';
import 'node:module';
import 'node:path';
import 'node:url';
import 'node:http';
import 'node:https';
import 'node:events';
import 'node:buffer';
import 'pino';
import 'drizzle-orm/better-sqlite3';
import 'drizzle-orm/node-postgres';
import 'drizzle-orm/mysql2';
import 'better-sqlite3';
import 'pg';
import 'mysql2/promise';
import 'drizzle-orm';
import 'fs';
import 'path';
import 'prom-client';
import 'bcryptjs';
import '@node-rs/argon2';
import 'node:async_hooks';
import 'crypto';
import 'node:dns';
import 'node:util';
import 'node:net';
import 'fs/promises';
import 'url';
import 'semver';
import '../../../../../../_/delivery-metrics.mjs';

const _commentId__delete = defineContentEventHandler("read", async (event) => {
  var _a, _b, _c, _d, _e, _f;
  try {
    const contentType = (_a = event.context.params) == null ? void 0 : _a.contentType;
    const id = (_b = event.context.params) == null ? void 0 : _b.id;
    const commentId = (_c = event.context.params) == null ? void 0 : _c.commentId;
    if (!contentType || !id || !commentId) {
      throw createError({
        statusCode: 400,
        statusMessage: "Bad Request",
        message: "Content type, entry ID and comment ID are required"
      });
    }
    const numericId = parseInt(id);
    if (isNaN(numericId)) {
      throw createError({
        statusCode: 400,
        statusMessage: "Bad Request",
        message: "Entry ID must be a valid number"
      });
    }
    const numericCommentId = parseInt(commentId);
    if (isNaN(numericCommentId)) {
      throw createError({
        statusCode: 400,
        statusMessage: "Bad Request",
        message: "Comment ID must be a valid number"
      });
    }
    await optionalAuth(event);
    await requirePermission(
      event.context.user,
      contentType,
      "read",
      event.context.adminUser,
      event.context.apiToken
    );
    await requireFeature("collaboration.comments", event);
    const existingComment = await getCommentByIdForEntry(numericCommentId, contentType, numericId);
    if (!existingComment) {
      throw createError({
        statusCode: 404,
        statusMessage: "Not Found",
        message: "Comment not found"
      });
    }
    const actor = getAuditActorFromEvent(event);
    if (!actor.id) {
      throw createError({
        statusCode: 401,
        statusMessage: "Unauthorized",
        message: "Authentication required to delete comments"
      });
    }
    const canModerate = await canModerateComments(event);
    await deleteComment(numericCommentId, actor.id, { canModerate });
    logAuditEventAsync({
      action: "comment.delete",
      actor,
      target: {
        entityType: contentType,
        entityId: numericId,
        displayName: `comment #${numericCommentId}`
      }
    });
    broadcastCommentEvent(contentType, numericId, "comment.deleted", existingComment, {
      type: actor.type,
      id: actor.id,
      displayName: actor.displayName || actor.email || `${actor.type}:${actor.id}`
    });
    return {
      success: true,
      data: null
    };
  } catch (error) {
    mapContentApiError(error, {
      routeLabel: `DELETE /api/content/${(_d = event.context.params) == null ? void 0 : _d.contentType}/${(_e = event.context.params) == null ? void 0 : _e.id}/comments/${(_f = event.context.params) == null ? void 0 : _f.commentId}`
    });
  }
});
async function canModerateComments(event) {
  const apiToken = event.context.apiToken;
  if (apiToken == null ? void 0 : apiToken.scopes) {
    return matchesScope(apiToken.scopes, "content:write");
  }
  const adminUser = event.context.adminUser;
  if (!(adminUser == null ? void 0 : adminUser.role)) {
    return false;
  }
  const scopes = await getAdminScopesForRole(adminUser.role);
  return matchesScope(scopes, "content:write");
}

export { _commentId__delete as default };
//# sourceMappingURL=_commentId_.delete.mjs.map
