// Backend API Implementation for Semi-Automatic Moderation System

const express = require('express');
const axios = require('axios');
const snoowrap = require('snoowrap');
const Anthropic = require('@anthropic-ai/sdk');

const app = express();
app.use(express.json());

// Initialize Claude Sonnet 4
const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

// Initialize Reddit API
const getRedditInstance = (accessToken) => {
  return new snoowrap({
    userAgent: process.env.REDDIT_USER_AGENT,
    accessToken: accessToken,
  });
};

// Endpoint: Get user's moderated subreddits
app.get('/api/subreddits/moderated', async (req, res) => {
  try {
    const { accessToken } = req.headers;
    const reddit = getRedditInstance(accessToken);
    
    // Get user's moderated subreddits
    const moderatedSubreddits = await reddit.getUser(await reddit.getMe().name)
      .getModeratedSubreddits();
    
    const subreddits = moderatedSubreddits.map(sub => ({
      name: sub.display_name,
      title: sub.title,
      subscribers: sub.subscribers,
      permissions: sub.mod_permissions || [],
      description: sub.public_description
    }));

    res.json({ subreddits });
  } catch (error) {
    console.error('Error fetching moderated subreddits:', error);
    res.status(500).json({ error: 'Failed to fetch moderated subreddits' });
  }
});

// Endpoint: Get subreddit rules
app.get('/api/subreddits/:subreddit/rules', async (req, res) => {
  try {
    const { subreddit } = req.params;
    const { accessToken } = req.headers;
    const reddit = getRedditInstance(accessToken);
    
    const subredditObj = reddit.getSubreddit(subreddit);
    const rules = await subredditObj.getRules();
    
    // Also get sidebar and description for additional context
    const about = await subredditObj.fetch();
    
    const rulesData = {
      rules: rules.map(rule => ({
        short_name: rule.short_name,
        description: rule.description,
        kind: rule.kind,
        violation_reason: rule.violation_reason
      })),
      description: about.description,
      sidebar: about.description_html,
      subreddit_type: about.subreddit_type,
      submission_type: about.submission_type
    };

    res.json(rulesData);
  } catch (error) {
    console.error('Error fetching subreddit rules:', error);
    res.status(500).json({ error: 'Failed to fetch subreddit rules' });
  }
});

// Endpoint: Get moderation queue
app.get('/api/subreddits/:subreddit/modqueue', async (req, res) => {
  try {
    const { subreddit } = req.params;
    const { accessToken } = req.headers;
    const { limit = 25, after } = req.query;
    
    const reddit = getRedditInstance(accessToken);
    const subredditObj = reddit.getSubreddit(subreddit);
    
    // Get modqueue items
    const modqueue = await subredditObj.getModqueue({
      limit: parseInt(limit),
      after: after
    });

    const items = await Promise.all(modqueue.map(async (item) => {
      let content = {
        id: item.id,
        fullname: item.name,
        type: item.constructor.name.toLowerCase(), // submission or comment
        author: item.author ? item.author.name : '[deleted]',
        created_utc: item.created_utc,
        subreddit: item.subreddit.display_name,
        permalink: item.permalink,
        score: item.score,
        reports: item.user_reports || [],
        mod_reports: item.mod_reports || [],
        num_reports: item.num_reports || 0
      };

      if (item.constructor.name === 'Submission') {
        content = {
          ...content,
          title: item.title,
          selftext: item.selftext,
          url: item.url,
          is_self: item.is_self,
          thumbnail: item.thumbnail,
          post_hint: item.post_hint,
          num_comments: item.num_comments
        };
      } else if (item.constructor.name === 'Comment') {
        content = {
          ...content,
          body: item.body,
          link_title: item.link_title,
          link_id: item.link_id,
          parent_id: item.parent_id
        };
      }

      return content;
    }));

    res.json({
      items,
      after: modqueue.length > 0 ? modqueue[modqueue.length - 1].name : null
    });
  } catch (error) {
    console.error('Error fetching modqueue:', error);
    res.status(500).json({ error: 'Failed to fetch modqueue' });
  }
});

// Endpoint: Analyze subreddit rules with AI
app.post('/api/ai/analyze-rules', async (req, res) => {
  try {
    const { subreddit, rules, description, sidebar } = req.body;

    const prompt = `Analyze the following subreddit rules and create a comprehensive moderation guide:

SUBREDDIT: r/${subreddit}

RULES:
${rules.map((rule, idx) => `${idx + 1}. ${rule.short_name}: ${rule.description}`).join('\n')}

DESCRIPTION: ${description}

SIDEBAR CONTENT: ${sidebar}

Please provide a structured analysis in JSON format with:
1. "rule_categories": Group rules into categories (content, behavior, formatting, spam, etc.)
2. "violation_patterns": Common patterns that indicate rule violations
3. "severity_levels": Categorize each rule as "minor", "moderate", or "severe"
4. "keywords": Key terms to watch for each rule
5. "moderation_guidelines": Suggested actions for each rule violation
6. "edge_cases": Situations that require manual review

Respond with valid JSON only.`;

    const response = await anthropic.messages.create({
      model: "claude-sonnet-4-20250514",
      max_tokens: 4000,
      messages: [
        {
          role: "user",
          content: prompt
        }
      ]
    });

    const analysis = JSON.parse(response.content[0].text);
    
    res.json({
      success: true,
      analysis,
      cached_at: new Date().toISOString()
    });
  } catch (error) {
    console.error('Error analyzing rules with AI:', error);
    res.status(500).json({ error: 'Failed to analyze rules' });
  }
});

// Endpoint: Analyze modqueue item with AI
app.post('/api/ai/analyze-item', async (req, res) => {
  try {
    const { item, rules_analysis, subreddit_context } = req.body;

    const content = item.type === 'submission' 
      ? `Title: ${item.title}\nContent: ${item.selftext}\nURL: ${item.url || 'N/A'}`
      : `Comment: ${item.body}\nOn post: ${item.link_title}`;

    const prompt = `As a Reddit moderation assistant, analyze this ${item.type} for rule violations:

SUBREDDIT: r/${item.subreddit}
AUTHOR: ${item.author}
SCORE: ${item.score}
REPORTS: ${item.num_reports} reports

CONTENT:
${content}

SUBREDDIT RULES ANALYSIS:
${JSON.stringify(rules_analysis, null, 2)}

EXISTING REPORTS:
User Reports: ${JSON.stringify(item.reports)}
Mod Reports: ${JSON.stringify(item.mod_reports)}

Please analyze and respond with JSON containing:
1. "violations_found": Array of rule violations with rule names and explanations
2. "confidence_score": Overall confidence (1-10) in the analysis
3. "suggested_action": "approve", "remove", "spam", or "manual_review"
4. "reasoning": Detailed explanation of the suggestion
5. "severity": "low", "medium", or "high"
6. "removal_reason": If suggesting removal, provide reason text
7. "requires_human_review": Boolean for edge cases
8. "additional_actions": Suggested flair, sticky comment, etc.

Consider context, intent, and potential false positives. Be conservative with removals.

Respond with valid JSON only.`;

    const response = await anthropic.messages.create({
      model: "claude-sonnet-4-20250514",
      max_tokens: 2000,
      messages: [
        {
          role: "user",
          content: prompt
        }
      ]
    });

    const analysis = JSON.parse(response.content[0].text);
    
    res.json({
      success: true,
      item_id: item.id,
      analysis,
      analyzed_at: new Date().toISOString()
    });
  } catch (error) {
    console.error('Error analyzing item with AI:', error);
    res.status(500).json({ error: 'Failed to analyze item' });
  }
});

// Endpoint: Take moderation action
app.post('/api/moderation/action', async (req, res) => {
  try {
    const { item_id, action, reason, accessToken } = req.body;
    const reddit = getRedditInstance(accessToken);

    let result;
    
    switch (action) {
      case 'approve':
        result = await reddit.getSubmission(item_id).approve();
        break;
      case 'remove':
        result = await reddit.getSubmission(item_id).remove({ spam: false });
        if (reason) {
          await reddit.getSubmission(item_id).reply(reason).distinguish();
        }
        break;
      case 'spam':
        result = await reddit.getSubmission(item_id).remove({ spam: true });
        break;
      default:
        throw new Error('Invalid action');
    }

    res.json({
      success: true,
      action,
      item_id,
      timestamp: new Date().toISOString()
    });
  } catch (error) {
    console.error('Error taking moderation action:', error);
    res.status(500).json({ error: 'Failed to take moderation action' });
  }
});

// Endpoint: Batch analyze modqueue
app.post('/api/moderation/batch-analyze', async (req, res) => {
  try {
    const { subreddit, accessToken, limit = 10 } = req.body;
    
    // Get rules analysis first
    const rulesResponse = await axios.get(`/api/subreddits/${subreddit}/rules`, {
      headers: { accessToken }
    });
    
    const rulesAnalysisResponse = await axios.post('/api/ai/analyze-rules', {
      subreddit,
      ...rulesResponse.data
    });
    
    // Get modqueue items
    const modqueueResponse = await axios.get(`/api/subreddits/${subreddit}/modqueue`, {
      headers: { accessToken },
      params: { limit }
    });
    
    // Analyze each item
    const analyses = await Promise.all(
      modqueueResponse.data.items.map(async (item) => {
        try {
          const analysisResponse = await axios.post('/api/ai/analyze-item', {
            item,
            rules_analysis: rulesAnalysisResponse.data.analysis,
            subreddit_context: rulesResponse.data
          });
          
          return {
            item,
            analysis: analysisResponse.data.analysis
          };
        } catch (error) {
          console.error(`Error analyzing item ${item.id}:`, error);
          return {
            item,
            analysis: { error: 'Analysis failed', requires_human_review: true }
          };
        }
      })
    );
    
    res.json({
      success: true,
      subreddit,
      total_items: analyses.length,
      analyses,
      rules_analysis: rulesAnalysisResponse.data.analysis
    });
  } catch (error) {
    console.error('Error in batch analysis:', error);
    res.status(500).json({ error: 'Failed to perform batch analysis' });
  }
});

module.exports = app;