/**
 * Voxyz API Routes - Trigger Rules
 * Handles trigger rule execution and management
 */

import { NextRequest, NextResponse } from 'next/server';
import { 
  getActiveTriggerRules, 
  evaluateAllTriggers,
  triggerManualEvaluation,
  runTriggerMonitor,
  getRecentTriggerLogs 
} from '@/lib/services/trigger-rules.service';
import { fetchAllTasks } from '@/lib/data/tasks';
import { getServiceSupabase } from '@/lib/supabase/client';

// GET /api/voxyz/trigger-rules - Get trigger rules and logs
export async function GET(request: NextRequest) {
  try {
    const { searchParams } = new URL(request.url);
    const logs = searchParams.get('logs');
    const limit = parseInt(searchParams.get('limit') || '50');
    
    if (logs) {
      const triggerLogs = await getRecentTriggerLogs(limit);
      return NextResponse.json({ logs: triggerLogs });
    }
    
    const rules = await getActiveTriggerRules();
    return NextResponse.json({ rules });
    
  } catch (error) {
    console.error('Error fetching trigger rules:', error);
    return NextResponse.json(
      { error: 'Failed to fetch trigger rules' },
      { status: 500 }
    );
  }
}

// POST /api/voxyz/trigger-rules - Run trigger evaluation or manual trigger
export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    const { action, triggerType, taskIds } = body;
    
    if (action === 'run-monitor') {
      // Run the trigger monitor agent
      await runTriggerMonitor();
      return NextResponse.json({ 
        success: true,
        message: 'Trigger monitor executed' 
      });
    }
    
    if (action === 'manual-trigger') {
      if (!triggerType) {
        return NextResponse.json(
          { error: 'Missing required field: triggerType' },
          { status: 400 }
        );
      }
      
      const results = await triggerManualEvaluation(triggerType, taskIds);
      
      return NextResponse.json({
        success: true,
        triggered: results.length,
        results,
      });
    }
    
    if (action === 'evaluate-all') {
      // Evaluate all triggers against current context
      const tasks = await fetchAllTasks();
      const context = {
        currentTime: new Date(),
        activeTasks: tasks.filter(t => t.status !== 'done' && t.status !== 'canceled'),
        recentProposals: [],
        todayMissions: [],
        userAvailability: [],
      };
      
      const results = await evaluateAllTriggers(context);
      
      return NextResponse.json({
        success: true,
        evaluated: results.length,
        triggered: results.filter(r => r.triggered).length,
        results,
      });
    }
    
    return NextResponse.json(
      { error: 'Unknown action' },
      { status: 400 }
    );
    
  } catch (error) {
    console.error('Error running trigger evaluation:', error);
    return NextResponse.json(
      { error: 'Failed to run trigger evaluation' },
      { status: 500 }
    );
  }
}

// PATCH /api/voxyz/trigger-rules - Update a trigger rule
export async function PATCH(request: NextRequest) {
  try {
    const body = await request.json();
    const { id, isActive, priority } = body;
    
    if (!id) {
      return NextResponse.json(
        { error: 'Missing required field: id' },
        { status: 400 }
      );
    }
    
    const supabase = getServiceSupabase();
    
    const updates: Record<string, unknown> = {
      updated_at: new Date().toISOString(),
    };
    
    if (isActive !== undefined) updates.is_active = isActive;
    if (priority !== undefined) updates.priority = priority;
    
    const { data, error } = await supabase
      .from('ops_trigger_rules')
      .update(updates)
      .eq('id', id)
      .select()
      .single();
    
    if (error) {
      throw error;
    }
    
    return NextResponse.json({ rule: data });
    
  } catch (error) {
    console.error('Error updating trigger rule:', error);
    return NextResponse.json(
      { error: 'Failed to update trigger rule' },
      { status: 500 }
    );
  }
}