import { NextResponse } from 'next/server';
import { prisma } from '@/lib/db';
import { getCurrentAdmin, AdminPermission, hasPermission } from '@/lib/admin-auth';

export const runtime = 'nodejs';

export async function GET(
  request: Request,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const admin = await getCurrentAdmin(request as any);
    if (!admin || !hasPermission(admin, AdminPermission.READ_CHAT)) {
      return NextResponse.json(
        { error: 'Unauthorized' },
        { status: 401 }
      );
    }

    const { id } = await params;

    const conversation = await prisma.chatConversation.findUnique({
      where: { id },
      include: {
        user: {
          select: {
            id: true,
            email: true,
            name: true,
            role: true,
            createdAt: true,
            lastLoginAt: true
          }
        },
        messages: {
          select: {
            id: true,
            role: true,
            content: true,
            timestamp: true,
            metadata: true
          },
          orderBy: {
            timestamp: 'asc'
          }
        }
      }
    });

    if (!conversation) {
      return NextResponse.json(
        { error: 'Conversation not found' },
        { status: 404 }
      );
    }

    // Analyze conversation for potential issues
    const analysis = {
      messageCount: conversation.messages.length,
      userMessages: conversation.messages.filter(m => m.role === 'USER').length,
      assistantMessages: conversation.messages.filter(m => m.role === 'ASSISTANT').length,
      averageMessageLength: conversation.messages.reduce((acc, msg) => acc + msg.content.length, 0) / conversation.messages.length || 0,
      lastActivity: conversation.lastMessageAt,
      duration: conversation.lastMessageAt
        ? new Date(conversation.lastMessageAt).getTime() - new Date(conversation.createdAt).getTime()
        : 0,
      potentialIssues: [] as string[]
    };

    // Check for potential content issues
    const suspiciousKeywords = ['inappropriate', 'harmful', 'illegal', 'violence', 'hate'];
    const hasContentIssues = conversation.messages.some(msg =>
      suspiciousKeywords.some(keyword =>
        msg.content.toLowerCase().includes(keyword)
      )
    );

    if (hasContentIssues) {
      analysis.potentialIssues.push('Potentially inappropriate content detected');
    }

    if (analysis.messageCount > 100) {
      analysis.potentialIssues.push('Unusually long conversation');
    }

    if (analysis.userMessages > 50) {
      analysis.potentialIssues.push('High user message count');
    }

    return NextResponse.json({
      conversation,
      analysis
    });

  } catch (error) {
    console.error('Admin conversation detail error:', error);
    return NextResponse.json(
      { error: 'Server error' },
      { status: 500 }
    );
  }
}

export async function PUT(
  request: Request,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const admin = await getCurrentAdmin(request as any);
    if (!admin || !hasPermission(admin, AdminPermission.WRITE_CHAT)) {
      return NextResponse.json(
        { error: 'Unauthorized' },
        { status: 401 }
      );
    }

    const { id } = await params;
    const body = await request.json();
    const { action, reason } = body;

    let updateData: any = {};

    switch (action) {
      case 'deactivate':
        updateData = { isActive: false };
        break;
      case 'activate':
        updateData = { isActive: true };
        break;
      default:
        return NextResponse.json(
          { error: 'Invalid action' },
          { status: 400 }
        );
    }

    const conversation = await prisma.chatConversation.update({
      where: { id },
      data: updateData,
      select: {
        id: true,
        title: true,
        isActive: true,
        user: {
          select: {
            email: true
          }
        }
      }
    });

    // TODO: Add audit log entry here in the future
    console.log(`Admin ${admin.email} performed action '${action}' on conversation ${conversation.title}${reason ? ` with reason: ${reason}` : ''}`);

    return NextResponse.json({ conversation });

  } catch (error) {
    console.error('Admin conversation update error:', error);
    return NextResponse.json(
      { error: 'Server error' },
      { status: 500 }
    );
  }
}

export async function DELETE(
  request: Request,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const admin = await getCurrentAdmin(request as any);
    if (!admin || !hasPermission(admin, AdminPermission.DELETE_CHAT)) {
      return NextResponse.json(
        { error: 'Unauthorized' },
        { status: 401 }
      );
    }

    const { id } = await params;

    const conversation = await prisma.chatConversation.findUnique({
      where: { id },
      select: { title: true, user: { select: { email: true } } }
    });

    if (!conversation) {
      return NextResponse.json(
        { error: 'Conversation not found' },
        { status: 404 }
      );
    }

    // Delete conversation and all related messages (CASCADE)
    await prisma.chatConversation.delete({
      where: { id }
    });

    console.log(`Admin ${admin.email} deleted conversation "${conversation.title}"`);

    return NextResponse.json({ success: true });

  } catch (error) {
    console.error('Admin conversation delete error:', error);
    return NextResponse.json(
      { error: 'Server error' },
      { status: 500 }
    );
  }
}