const mongoose = require('mongoose');
const SourceText = require('./models/SourceText');

// MongoDB connection
const MONGODB_URI = process.env.MONGODB_URI || 'mongodb+srv://nothingyu:wSg3lbO1PkHiRMq9@sandbox.ecysggv.mongodb.net/?retryWrites=true&w=majority&appName=sandbox';

async function lockWeek1Week2Tasks() {
  try {
    console.log('🌐 Connecting to MongoDB...');
    await mongoose.connect(MONGODB_URI);
    console.log('✅ Connected to MongoDB');

    // Find all Week 1 and Week 2 tutorial tasks
    const week1Tasks = await SourceText.find({ 
      category: 'tutorial', 
      weekNumber: 1 
    }).sort({ title: 1 });
    
    const week2Tasks = await SourceText.find({ 
      category: 'tutorial', 
      weekNumber: 2 
    }).sort({ title: 1 });

    console.log(`📋 Found ${week1Tasks.length} Week 1 tutorial tasks`);
    console.log(`📋 Found ${week2Tasks.length} Week 2 tutorial tasks`);

    // Lock Week 1 tasks
    console.log('\n🔒 Locking Week 1 tutorial tasks...');
    let lockedWeek1Count = 0;
    for (const task of week1Tasks) {
      const updatedTask = await SourceText.findByIdAndUpdate(
        task._id,
        { 
          isProtected: true,
          protectedReason: 'Week 1 tutorial tasks are locked to prevent accidental changes',
          lastModified: new Date(),
          modificationHistory: [
            {
              action: 'LOCKED',
              timestamp: new Date(),
              reason: 'Week 1 tutorial tasks locked for protection'
            }
          ]
        },
        { new: true }
      );
      console.log(`✅ Locked: ${updatedTask.title}`);
      lockedWeek1Count++;
    }

    // Lock Week 2 tasks
    console.log('\n🔒 Locking Week 2 tutorial tasks...');
    let lockedWeek2Count = 0;
    for (const task of week2Tasks) {
      const updatedTask = await SourceText.findByIdAndUpdate(
        task._id,
        { 
          isProtected: true,
          protectedReason: 'Week 2 tutorial tasks are locked to prevent accidental changes',
          lastModified: new Date(),
          modificationHistory: [
            {
              action: 'LOCKED',
              timestamp: new Date(),
              reason: 'Week 2 tutorial tasks locked for protection'
            }
          ]
        },
        { new: true }
      );
      console.log(`✅ Locked: ${updatedTask.title}`);
      lockedWeek2Count++;
    }

    console.log(`\n🎉 LOCKING COMPLETE:`);
    console.log(`   Week 1: ${lockedWeek1Count} tasks locked`);
    console.log(`   Week 2: ${lockedWeek2Count} tasks locked`);

    // Verify locked tasks
    console.log('\n📋 Verification - Locked tasks:');
    const allLockedTasks = await SourceText.find({ 
      isProtected: true 
    }).sort({ weekNumber: 1, title: 1 });
    
    allLockedTasks.forEach((task, index) => {
      console.log(`${index + 1}. Week ${task.weekNumber} - ${task.title}`);
      console.log(`   Protected: ${task.isProtected ? 'YES' : 'NO'}`);
      console.log(`   Reason: ${task.protectedReason}`);
    });

    console.log(`\n📊 Total locked tasks: ${allLockedTasks.length}`);

  } catch (error) {
    console.error('❌ Error locking tasks:', error);
    process.exit(1);
  } finally {
    await mongoose.disconnect();
    console.log('🔌 Disconnected from MongoDB');
  }
}

// SAFE UPDATE FUNCTIONS WITH PROTECTION CHECKS

async function safeUpdateProtectedTask(taskId, updates, reason = 'No reason provided') {
  try {
    console.log('🌐 Connecting to MongoDB...');
    await mongoose.connect(MONGODB_URI);
    console.log('✅ Connected to MongoDB');

    const task = await SourceText.findById(taskId);
    
    if (!task) {
      console.log(`❌ Task with ID ${taskId} not found`);
      return;
    }

    if (task.isProtected) {
      console.log(`🚫 CANNOT UPDATE: Task "${task.title}" is PROTECTED`);
      console.log(`   Reason: ${task.protectedReason}`);
      console.log(`   To update this task, you must first unlock it with a special key`);
      return;
    }

    // Safe to update
    const updatedTask = await SourceText.findByIdAndUpdate(
      taskId,
      { 
        ...updates,
        lastModified: new Date(),
        modificationHistory: [
          ...(task.modificationHistory || []),
          {
            action: 'UPDATED',
            timestamp: new Date(),
            reason: reason
          }
        ]
      },
      { new: true }
    );

    console.log(`✅ Updated task: ${updatedTask.title}`);

  } catch (error) {
    console.error('❌ Error updating task:', error);
  } finally {
    await mongoose.disconnect();
    console.log('🔌 Disconnected from MongoDB');
  }
}

async function unlockProtectedTask(taskId, unlockKey) {
  try {
    console.log('🌐 Connecting to MongoDB...');
    await mongoose.connect(MONGODB_URI);
    console.log('✅ Connected to MongoDB');

    // Simple unlock key - in production, use a more secure method
    const VALID_UNLOCK_KEY = 'UNLOCK_WEEK1_WEEK2_2024';
    
    if (unlockKey !== VALID_UNLOCK_KEY) {
      console.log('❌ Invalid unlock key. Protected tasks cannot be unlocked.');
      return;
    }

    const task = await SourceText.findById(taskId);
    
    if (!task) {
      console.log(`❌ Task with ID ${taskId} not found`);
      return;
    }

    if (!task.isProtected) {
      console.log(`⚠️  Task "${task.title}" is not protected`);
      return;
    }

    const updatedTask = await SourceText.findByIdAndUpdate(
      taskId,
      { 
        isProtected: false,
        protectedReason: null,
        lastModified: new Date(),
        modificationHistory: [
          ...(task.modificationHistory || []),
          {
            action: 'UNLOCKED',
            timestamp: new Date(),
            reason: 'Task unlocked with valid key'
          }
        ]
      },
      { new: true }
    );

    console.log(`✅ Unlocked task: ${updatedTask.title}`);

  } catch (error) {
    console.error('❌ Error unlocking task:', error);
  } finally {
    await mongoose.disconnect();
    console.log('🔌 Disconnected from MongoDB');
  }
}

async function showProtectedTasks() {
  try {
    console.log('🌐 Connecting to MongoDB...');
    await mongoose.connect(MONGODB_URI);
    console.log('✅ Connected to MongoDB');

    const protectedTasks = await SourceText.find({ 
      isProtected: true 
    }).sort({ weekNumber: 1, title: 1 });
    
    console.log(`\n🔒 PROTECTED TASKS (${protectedTasks.length} total):`);
    
    protectedTasks.forEach((task, index) => {
      console.log(`${index + 1}. Week ${task.weekNumber} - ${task.title}`);
      console.log(`   ID: ${task._id}`);
      console.log(`   Protected: ${task.isProtected ? 'YES' : 'NO'}`);
      console.log(`   Reason: ${task.protectedReason}`);
      console.log(`   Last Modified: ${task.lastModified}`);
      console.log('---');
    });

  } catch (error) {
    console.error('❌ Error showing protected tasks:', error);
  } finally {
    await mongoose.disconnect();
    console.log('🔌 Disconnected from MongoDB');
  }
}

// Export functions for safe operations
module.exports = {
  lockWeek1Week2Tasks,
  safeUpdateProtectedTask,
  unlockProtectedTask,
  showProtectedTasks
};

// Run the locking
lockWeek1Week2Tasks();