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

interface AcceptDirectInviteRequest {
  inviterMainId: number;
}

interface LaravelUser {
  id: number;
  name: string;
  email: string;
  phone?: string;
  is_affiliate?: boolean;
}

export async function POST(request: NextRequest) {
  try {
    const authToken = request.cookies.get('auth_token');
    const authUserCookie = request.cookies.get('AuthUser');

    if (!authToken?.value || !authUserCookie?.value) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
    }

    let currentLaravelUser: LaravelUser;
    try {
      currentLaravelUser = JSON.parse(authUserCookie.value) as LaravelUser;
    } catch {
      return NextResponse.json({ error: 'Invalid user session' }, { status: 401 });
    }

    const body: AcceptDirectInviteRequest = await request.json();
    const inviterMainId = Number(body.inviterMainId);
    if (!inviterMainId || Number.isNaN(inviterMainId)) {
      return NextResponse.json({ error: 'Invalid inviterMainId' }, { status: 422 });
    }

    // Synchroniser l'utilisateur courant dans Supabase
    let currentSupabaseId: string;
    {
      const { data: exists } = await supabase
        .from('users')
        .select('id')
        .eq('main_id', currentLaravelUser.id)
        .single();
      if (exists) {
        currentSupabaseId = exists.id;
      } else {
        const { data: created, error: createErr } = await supabase
          .from('users')
          .insert({
            main_id: currentLaravelUser.id,
            username: null,
            name: currentLaravelUser.name,
            email: currentLaravelUser.email,
            phone: currentLaravelUser.phone || null,
            is_affiliate: currentLaravelUser.is_affiliate || false,
            avatar_url: null,
            status: 'offline',
            last_seen: new Date().toISOString(),
          })
          .select('id')
          .single();
        if (createErr || !created) {
          return NextResponse.json({ error: 'Failed to sync current user' }, { status: 500 });
        }
        currentSupabaseId = created.id;
      }
    }

    // Récupérer/Synchroniser l'invitant par main_id
    let inviterSupabaseId: string;
    {
      const { data: inviterUser } = await supabase
        .from('users')
        .select('id, name')
        .eq('main_id', inviterMainId)
        .single();

      if (inviterUser) {
        inviterSupabaseId = inviterUser.id;
      } else {
        // Si l'invitant n'existe pas encore dans Supabase, on ne peut pas récupérer son template
        // mais on crée tout de même son entrée minimale
        const { data: createdInviter, error: inviterErr } = await supabase
          .from('users')
          .insert({
            main_id: inviterMainId,
            username: null,
            name: null,
            email: null,
            phone: null,
            is_affiliate: false,
            avatar_url: null,
            status: 'offline',
            last_seen: new Date().toISOString(),
          })
          .select('id')
          .single();
        if (inviterErr || !createdInviter) {
          return NextResponse.json({ error: 'Inviter not found' }, { status: 404 });
        }
        inviterSupabaseId = createdInviter.id;
      }
    }

    if (inviterSupabaseId === currentSupabaseId) {
      return NextResponse.json({ error: 'Cannot create conversation with self' }, { status: 400 });
    }

    // Vérifier si une conversation directe existe déjà entre les deux utilisateurs
    let existingConversationId: string | null = null;
    {
      const { data: currentConvs } = await supabase
        .from('conversation_participants')
        .select('conversation_id, conversations!inner(type)')
        .eq('user_id', currentSupabaseId);

      if (currentConvs) {
        for (const p of currentConvs) {
          const conversation = p.conversations as unknown as { type: string };
          if (conversation.type === 'direct') {
            const { data: other } = await supabase
              .from('conversation_participants')
              .select('id')
              .eq('conversation_id', p.conversation_id)
              .eq('user_id', inviterSupabaseId)
              .single();
            if (other) {
              existingConversationId = p.conversation_id;
              break;
            }
          }
        }
      }
    }

    let conversationId: string;
    let createdNow = false;
    if (existingConversationId) {
      conversationId = existingConversationId;
    } else {
      // Créer la conversation
      const { data: newConv, error: convErr } = await supabase
        .from('conversations')
        .insert({ type: 'direct', name: null })
        .select('id')
        .single();
      if (convErr || !newConv) {
        return NextResponse.json({ error: 'Failed to create conversation' }, { status: 500 });
      }
      conversationId = newConv.id;
      createdNow = true;

      const { error: partsErr } = await supabase
        .from('conversation_participants')
        .insert([
          { conversation_id: conversationId, user_id: inviterSupabaseId },
          { conversation_id: conversationId, user_id: currentSupabaseId },
        ]);
      if (partsErr) {
        await supabase.from('conversations').delete().eq('id', conversationId);
        return NextResponse.json({ error: 'Failed to add participants' }, { status: 500 });
      }

      // Insérer le message d'invitation depuis le template par défaut de l'invitant s'il existe
      const { data: template } = await supabase
        .from('invitation_message_templates')
        .select('content')
        .eq('user_id', inviterSupabaseId)
        .eq('is_default', true)
        .single();

      const templateContent = template?.content as string | undefined;
      if (templateContent && templateContent.trim().length > 0) {
        const { data: newMsg } = await supabase
          .from('messages')
          .insert({
            conversation_id: conversationId,
            sender_id: inviterSupabaseId,
            content: templateContent,
            message_type: 'text',
            status: 'sent',
          })
          .select('id')
          .single();
        if (newMsg) {
          // Marquer comme lu pour l'invitant (auteur)
          await supabase.from('message_reads').insert({ message_id: newMsg.id, user_id: inviterSupabaseId });
        }
      }
    }

    return NextResponse.json({
      success: true,
      conversationId,
      existingConversation: !createdNow,
    }, { status: 201 });

  } catch (error) {
    console.error('Error accepting direct invite:', error);
    return NextResponse.json({ error: 'Server error' }, { status: 500 });
  }
}