import { NextRequest, NextResponse } from 'next/server';
import { getSupabaseAdmin } from '@/lib/supabase/server';

const CEO_PIN = '5050';

/**
 * GET /api/feature-flags - List all flags (admin) or active flags (public)
 */
export async function GET(request: NextRequest) {
  try {
    const pin = request.headers.get('x-ceo-pin') || new URL(request.url).searchParams.get('pin');
    const isAdmin = pin === CEO_PIN;
    const admin = getSupabaseAdmin();

    let query = admin
      .from('feature_flags')
      .select('*')
      .order('created_at', { ascending: true });

    if (!isAdmin) {
      query = query.eq('active', true);
    }

    const { data, error } = await query;
    if (error) {
      return NextResponse.json({ error: 'Failed to fetch flags' }, { status: 500 });
    }

    // For admin, also get experiment stats
    if (isAdmin && data) {
      const flagKeys = data.filter(f => f.flag_type === 'experiment').map(f => f.key);
      if (flagKeys.length > 0) {
        const { data: assignments } = await admin
          .from('experiment_assignments')
          .select('flag_key, variant');

        const { data: events } = await admin
          .from('experiment_events')
          .select('flag_key, variant, event_type');

        // Aggregate stats per flag
        const stats: Record<string, { assignments: Record<string, number>; events: Record<string, number> }> = {};
        for (const a of assignments || []) {
          if (!stats[a.flag_key]) stats[a.flag_key] = { assignments: {}, events: {} };
          stats[a.flag_key].assignments[a.variant] = (stats[a.flag_key].assignments[a.variant] || 0) + 1;
        }
        for (const e of events || []) {
          if (!stats[e.flag_key]) stats[e.flag_key] = { assignments: {}, events: {} };
          const key = `${e.variant}:${e.event_type}`;
          stats[e.flag_key].events[key] = (stats[e.flag_key].events[key] || 0) + 1;
        }

        return NextResponse.json({ data, stats });
      }
    }

    return NextResponse.json({ data });
  } catch (err) {
    console.error('Feature flags GET error:', err);
    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
  }
}

/**
 * PATCH /api/feature-flags - Update a flag (admin only)
 */
export async function PATCH(request: NextRequest) {
  try {
    const pin = request.headers.get('x-ceo-pin');
    if (pin !== CEO_PIN) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
    }

    const body = await request.json();
    const { key, active, enabled, rollout_percentage, variants, target_user_types } = body;

    if (!key) {
      return NextResponse.json({ error: 'key required' }, { status: 400 });
    }

    const updates: Record<string, unknown> = {};
    if (active !== undefined) updates.active = active;
    if (enabled !== undefined) updates.enabled = enabled;
    if (rollout_percentage !== undefined) updates.rollout_percentage = rollout_percentage;
    if (variants !== undefined) updates.variants = variants;
    if (target_user_types !== undefined) updates.target_user_types = target_user_types;

    if (Object.keys(updates).length === 0) {
      return NextResponse.json({ error: 'No updates' }, { status: 400 });
    }

    const admin = getSupabaseAdmin();
    const { data, error } = await admin
      .from('feature_flags')
      .update(updates)
      .eq('key', key)
      .select()
      .single();

    if (error) {
      console.error('Flag update error:', error);
      return NextResponse.json({ error: 'Failed to update flag' }, { status: 500 });
    }

    return NextResponse.json({ data });
  } catch (err) {
    console.error('Feature flags PATCH error:', err);
    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
  }
}

/**
 * POST /api/feature-flags - Create a new flag (admin only)
 */
export async function POST(request: NextRequest) {
  try {
    const pin = request.headers.get('x-ceo-pin');
    if (pin !== CEO_PIN) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
    }

    const body = await request.json();
    const { key, name, description, flag_type, variants } = body;

    if (!key?.trim() || !name?.trim()) {
      return NextResponse.json({ error: 'key and name required' }, { status: 400 });
    }

    if (!['boolean', 'percentage', 'experiment'].includes(flag_type || 'boolean')) {
      return NextResponse.json({ error: 'Invalid flag_type' }, { status: 400 });
    }

    const admin = getSupabaseAdmin();
    const { data, error } = await admin
      .from('feature_flags')
      .insert({
        key: key.trim().toLowerCase().replace(/\s+/g, '_'),
        name: name.trim(),
        description: description?.trim() || null,
        flag_type: flag_type || 'boolean',
        variants: variants || [],
        active: false,
      })
      .select()
      .single();

    if (error) {
      if (error.code === '23505') {
        return NextResponse.json({ error: 'Flag key already exists' }, { status: 409 });
      }
      console.error('Flag create error:', error);
      return NextResponse.json({ error: 'Failed to create flag' }, { status: 500 });
    }

    return NextResponse.json({ data }, { status: 201 });
  } catch (err) {
    console.error('Feature flags POST error:', err);
    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
  }
}