import { getServerSession } from "next-auth";
import { authOptions } from "@/app/api/auth/[...nextauth]/route";
import { NextResponse } from "next/server";

export async function GET(request: Request) {
  const session = await getServerSession(authOptions);
  
  if (!session) {
    console.error('No session found');
    return new Response(JSON.stringify({ error: 'Unauthorized' }), {
      status: 401,
      headers: { 'Content-Type': 'application/json' },
    });
  }

  console.log('Session data:', {
    hasToken: !!session.rocketChatToken,
    hasUserId: !!session.rocketChatUserId,
    tokenLength: session.rocketChatToken?.length,
    userIdLength: session.rocketChatUserId?.length,
    username: session.user?.username
  });

  if (!session.rocketChatToken || !session.rocketChatUserId) {
    console.error('Missing Rocket.Chat credentials in session:', {
      hasToken: !!session.rocketChatToken,
      hasUserId: !!session.rocketChatUserId,
      username: session.user?.username
    });
    return new Response(JSON.stringify({ error: 'Missing Rocket.Chat credentials' }), {
      status: 401,
      headers: { 'Content-Type': 'application/json' },
    });
  }

  try {
    // Get the base URL from the environment variable
    const baseUrl = process.env.NEXT_PUBLIC_IFRAME_PAROLE_URL?.split('/channel')[0];
    if (!baseUrl) {
      console.error('Failed to get Rocket.Chat base URL from environment variables');
      return new Response(JSON.stringify({ error: 'Server configuration error' }), {
        status: 500,
        headers: { 'Content-Type': 'application/json' },
      });
    }

    // Get user's subscriptions
    const subscriptionsResponse = await fetch(`${baseUrl}/api/v1/subscriptions.get`, {
      headers: {
        'X-Auth-Token': session.rocketChatToken,
        'X-User-Id': session.rocketChatUserId,
      },
    });

    if (!subscriptionsResponse.ok) {
      console.error('Failed to get subscriptions:', {
        status: subscriptionsResponse.status,
        statusText: subscriptionsResponse.statusText,
        username: session.user?.username
      });
      return new Response(JSON.stringify({ error: 'Failed to get subscriptions' }), {
        status: subscriptionsResponse.status,
        headers: { 'Content-Type': 'application/json' },
      });
    }

    const subscriptionsData = await subscriptionsResponse.json();
    console.log('Subscriptions response:', subscriptionsData);

    // Filter subscriptions to only include rooms where the user is a participant
    const userSubscriptions = subscriptionsData.update.filter((subscription: any) => {
      // For direct messages, check if the room ID contains the user's ID
      if (subscription.t === 'd') {
        return subscription.rid.includes(session.rocketChatUserId);
      }
      // For channels and groups, include all subscriptions
      return true;
    });

    console.log('Filtered subscriptions for user:', userSubscriptions.length);

    const messages: any[] = [];

    for (const subscription of userSubscriptions) {
      // Skip if we already have 6 messages
      if (messages.length >= 6) break;

      console.log(`Fetching messages for room ${subscription.name} using endpoint ${subscription.t === 'c' ? 'channels.messages' : 'im.messages'}`);
      
      const endpoint = subscription.t === 'c' ? 'channels.messages' : 'im.messages';
      const roomId = subscription.t === 'c' ? subscription.name : subscription.rid;
      
      // Only fetch the last message
      const messagesResponse = await fetch(
        `${baseUrl}/api/v1/${endpoint}?roomId=${roomId}&count=1`,
        {
          headers: {
            'X-Auth-Token': session.rocketChatToken,
            'X-User-Id': session.rocketChatUserId,
          },
        }
      );

      if (!messagesResponse.ok) {
        console.error(`Failed to get messages for room ${subscription.name}:`, {
          status: messagesResponse.status,
          statusText: messagesResponse.statusText,
          username: session.user?.username
        });
        continue;
      }

      const messagesData = await messagesResponse.json();
      console.log(`Messages response for ${subscription.name}:`, messagesData);

      if (messagesData.messages && messagesData.messages.length > 0) {
        const lastMessage = messagesData.messages[0];
        messages.push({
          ...lastMessage,
          roomName: subscription.fname || subscription.name || 'Direct Message',
          roomType: subscription.t,
          unread: subscription.unread || 0,
          userMentions: subscription.userMentions || 0,
          groupMentions: subscription.groupMentions || 0,
          alert: subscription.alert || false
        });
      } else {
        console.log(`No messages found for room: ${roomId}`);
      }
    }

    // Sort messages by timestamp (newest first) and take only the first 6
    messages.sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime());
    const limitedMessages = messages.slice(0, 6);

    console.log('Found messages:', limitedMessages.length);
    return new Response(JSON.stringify({ messages: limitedMessages }), {
      status: 200,
      headers: { 'Content-Type': 'application/json' },
    });
  } catch (error) {
    console.error('Error fetching messages:', error);
    return new Response(JSON.stringify({ error: 'Internal server error' }), {
      status: 500,
      headers: { 'Content-Type': 'application/json' },
    });
  }
}