const { SharpApiDetectProfanitiesService } = require('@sharpapi/sharpapi-node-detect-profanities');

const apiKey = process.env.SHARP_API_KEY;
const service = new SharpApiDetectProfanitiesService(apiKey);

const userComment = `
This is a sample comment that might contain inappropriate language.
Checking for profanities and offensive content.
`;

async function checkContent() {
  try {
    const statusUrl = await service.detectProfanities(userComment);
    console.log('Job submitted. Status URL:', statusUrl);

    const result = await service.fetchResults(statusUrl);
    const detection = result.getResultJson();

    if (!detection.result.pass) {
      console.log('⚠️ Profanity detected!');
      console.log('Confidence:', detection.result.score + '%');
      console.log('Reason:', detection.result.reason);
    } else {
      console.log('✅ Content is clean');
    }
  } catch (error) {
    console.error('Error:', error.message);
  }
}

checkContent();

const { SharpApiDetectProfanitiesService } = require('@sharpapi/sharpapi-node-detect-profanities');

const service = new SharpApiDetectProfanitiesService(process.env.SHARP_API_KEY);

const content = 'This is a sample user comment to check for inappropriate content.';

service.detectProfanities(content)
  .then(statusUrl => service.fetchResults(statusUrl))
  .then(result => {
    const detection = result.getResultJson().result;

    if (detection.pass) {
      console.log('✅ Content approved');
    } else {
      console.log(`⚠️ Content flagged (${detection.score}% confidence)`);
      console.log(`Reason: ${detection.reason}`);
    }
  })
  .catch(error => console.error('Detection failed:', error));

const service = new SharpApiDetectProfanitiesService(process.env.SHARP_API_KEY);

const userComments = [
  { id: 1, text: 'Great product! Really helpful.' },
  { id: 2, text: 'Terrible service, very disappointed.' },
  { id: 3, text: 'Amazing quality, highly recommend!' }
];

async function moderateComments(comments) {
  const moderated = await Promise.all(
    comments.map(async (comment) => {
      try {
        const statusUrl = await service.detectProfanities(comment.text);
        const result = await service.fetchResults(statusUrl);
        const detection = result.getResultJson().result;

        return {
          ...comment,
          approved: detection.pass,
          confidence: detection.score,
          reason: detection.reason,
          requiresReview: !detection.pass && detection.score < 75
        };
      } catch (error) {
        return {
          ...comment,
          approved: false,
          error: error.message,
          requiresReview: true
        };
      }
    })
  );

  return moderated;
}

const results = await moderateComments(userComments);

const approved = results.filter(r => r.approved).length;
const flagged = results.filter(r => !r.approved).length;
const needsReview = results.filter(r => r.requiresReview).length;

console.log(`📊 Moderation Summary:`);
console.log(`Total: ${results.length}`);
console.log(`✅ Approved: ${approved}`);
console.log(`⚠️ Flagged: ${flagged}`);
console.log(`👤 Needs Human Review: ${needsReview}`);

const service = new SharpApiDetectProfanitiesService(process.env.SHARP_API_KEY);

async function filterComment(comment, autoReject = true) {
  const statusUrl = await service.detectProfanities(comment.text);
  const result = await service.fetchResults(statusUrl);
  const detection = result.getResultJson().result;

  const action = {
    commentId: comment.id,
    userId: comment.userId,
    text: comment.text,
    pass: detection.pass,
    confidence: detection.score,
    reason: detection.reason,
    status: '',
    action: ''
  };

  if (detection.pass) {
    action.status = 'approved';
    action.action = 'publish';
  } else if (detection.score >= 85 && autoReject) {
    action.status = 'rejected';
    action.action = 'auto_reject';
  } else if (detection.score >= 60) {
    action.status = 'flagged';
    action.action = 'hold_for_review';
  } else {
    action.status = 'uncertain';
    action.action = 'manual_review';
  }

  return action;
}

const newComment = {
  id: 'CMT-12345',
  userId: 'USER-789',
  text: 'What a fantastic experience! Absolutely loved it!'
};

const moderation = await filterComment(newComment);

console.log(`Comment Status: ${moderation.status}`);
console.log(`Action: ${moderation.action}`);
console.log(`Confidence: ${moderation.confidence}%`);

if (moderation.action === 'publish') {
  console.log('✅ Comment published successfully');
} else if (moderation.action === 'auto_reject') {
  console.log('🚫 Comment automatically rejected');
  console.log(`Reason: ${moderation.reason}`);
} else {
  console.log('⏸️ Comment held for manual review');
}

const service = new SharpApiDetectProfanitiesService(process.env.SHARP_API_KEY);

async function generateModerationReport(posts) {
  const analyzed = await Promise.all(
    posts.map(async (post) => {
      const statusUrl = await service.detectProfanities(post.content);
      const result = await service.fetchResults(statusUrl);
      const detection = result.getResultJson().result;

      return {
        postId: post.id,
        author: post.author,
        timestamp: post.timestamp,
        pass: detection.pass,
        score: detection.score,
        reason: detection.reason,
        severity: detection.score >= 90 ? 'high' :
                 detection.score >= 75 ? 'medium' :
                 detection.score >= 60 ? 'low' : 'uncertain'
      };
    })
  );

  const report = {
    totalPosts: posts.length,
    clean: analyzed.filter(a => a.pass).length,
    flagged: analyzed.filter(a => !a.pass).length,
    highSeverity: analyzed.filter(a => a.severity === 'high').length,
    mediumSeverity: analyzed.filter(a => a.severity === 'medium').length,
    lowSeverity: analyzed.filter(a => a.severity === 'low').length,
    needsReview: analyzed.filter(a => a.severity === 'uncertain').length,
    posts: analyzed.filter(a => !a.pass).map(a => ({
      postId: a.postId,
      author: a.author,
      severity: a.severity,
      score: a.score,
      reason: a.reason
    }))
  };

  return report;
}

const forumPosts = [
  { id: 'POST-1', author: 'user123', content: 'Great discussion!', timestamp: new Date() },
  { id: 'POST-2', author: 'user456', content: 'Thanks for sharing!', timestamp: new Date() },
  { id: 'POST-3', author: 'user789', content: 'Very helpful post.', timestamp: new Date() }
];

const report = await generateModerationReport(forumPosts);

console.log('📋 Moderation Report:');
console.log(`Total Posts: ${report.totalPosts}`);
console.log(`Clean: ${report.clean}`);
console.log(`Flagged: ${report.flagged}`);
console.log(`  - High Severity: ${report.highSeverity}`);
console.log(`  - Medium Severity: ${report.mediumSeverity}`);
console.log(`  - Low Severity: ${report.lowSeverity}`);
console.log(`  - Needs Review: ${report.needsReview}`);

if (report.posts.length > 0) {
  console.log('\n🚨 Flagged Posts:');
  report.posts.forEach(p => {
    console.log(`  - ${p.postId} by ${p.author} (${p.severity} severity, ${p.score}%)`);
    console.log(`    Reason: ${p.reason}`);
  });
}