#!/usr/bin/env node
/**
 * Recategorize Architectural Safeguards Document Sections
 * Applies logical categorization based on content purpose
 */

require('dotenv').config();

const { connect, close } = require('../src/utils/db.util');
const Document = require('../src/models/Document.model');

// Manual section categorization mapping
const SECTION_CATEGORIES = {
  // Conceptual Foundation - Understanding the problem and solution
  'How Tractatus Protects Plural Morals from AI Pattern Bias': 'conceptual',
  'Executive Summary': 'conceptual',
  '3. The Dichotomy Resolved: Hierarchical Boundaries + Non-Hierarchical Deliberation': 'conceptual',
  '6. The Ultimate Safeguard: User Can Fork the System': 'conceptual',
  '7. Summary: How Tractatus Prevents Runaway AI': 'conceptual',
  '9. Conclusion: The Fight Against Amoral Intelligence': 'conceptual',

  // Technical Implementation - How the system works architecturally
  '1. The Structural Architecture: Three Layers of Protection': 'technical',
  '5. Extending to Multi-User Contexts: Preventing Majority Dominance': 'technical',

  // Practical Application - Using and testing the system
  '2. How This Prevents LLM Hierarchical Dominance': 'practical',
  '4. What Happens If LLM Tries to Dominate Anyway?': 'practical',
  'Appendix B: Red-Team Scenarios (Adversarial Testing)': 'practical',
  'Appendix C: Implementation Checklist': 'practical',

  // Reference Material - Metadata, comparisons, research questions
  '8. Open Questions & Future Research': 'reference',
  'Contact': 'reference',
  'License': 'reference',
  'Document Metadata': 'reference',
  'Appendix A: Comparison to Other AI Governance Approaches': 'reference'
};

async function recategorizeSections() {
  try {
    console.log('\n=== Recategorizing Architectural Safeguards Sections ===\n');

    const slug = 'architectural-safeguards-against-llm-hierarchical-dominance-prose';

    // Connect to database
    await connect();

    // Find document
    console.log('📊 Finding document in database...');
    const doc = await Document.findBySlug(slug);

    if (!doc) {
      console.error('❌ Error: Document not found');
      await close();
      process.exit(1);
    }

    console.log('✓ Found document with', doc.sections.length, 'sections');

    // Update section categories
    console.log('\n🔄 Applying logical categorization...\n');

    let updated = 0;
    doc.sections.forEach(section => {
      const newCategory = SECTION_CATEGORIES[section.title];
      if (newCategory) {
        const oldCategory = section.category;
        section.category = newCategory;
        if (oldCategory !== newCategory) {
          console.log(`  "${section.title}"`);
          console.log(`    ${oldCategory} → ${newCategory}`);
          updated++;
        }
      } else {
        console.log(`  ⚠️  No mapping for: "${section.title}" (keeping ${section.category})`);
      }
    });

    console.log(`\n✓ Updated ${updated} section categories`);

    // Save updated document
    console.log('\n💾 Saving changes...');
    const result = await Document.update(doc._id, {
      sections: doc.sections
    });

    if (!result) {
      console.error('❌ Error: Failed to update document');
      await close();
      process.exit(1);
    }

    console.log('✓ Changes saved successfully!');

    // Show final breakdown
    console.log('\n📋 Final Section Breakdown:');
    const categoryCounts = {};
    doc.sections.forEach(section => {
      categoryCounts[section.category] = (categoryCounts[section.category] || 0) + 1;
    });

    const categoryLabels = {
      conceptual: '📘 Conceptual',
      technical: '🔧 Technical',
      practical: '✨ Practical',
      reference: '📋 Reference'
    };

    Object.entries(categoryCounts).sort().forEach(([category, count]) => {
      const label = categoryLabels[category] || category;
      console.log(`   ${label}: ${count} sections`);
    });

    console.log('\n✅ Recategorization complete!');
    console.log(`   View at: https://agenticgovernance.digital/docs.html?doc=${slug}`);

    await close();

  } catch (error) {
    console.error('\n❌ Recategorization failed:', error.message);
    console.error(error.stack);
    process.exit(1);
  }
}

// Run if called directly
if (require.main === module) {
  recategorizeSections();
}

module.exports = recategorizeSections;