// src/app/api/user/route.ts
import { NextResponse, type NextRequest } from 'next/server'
import { getServerSession } from 'next-auth'
import { authOptions } from '@/app/lib/auth'
import { prisma } from '@/app/lib/prisma'

export async function GET(req: NextRequest) {
  const session = await getServerSession(authOptions(req))
  const steamId = session?.user?.steamId

  if (!steamId) {
    return NextResponse.json({ error: 'Nicht eingeloggt' }, { status: 401 })
  }

  // 1) User + Team (nur skalare Felder + Leader-Relation laden)
  const userRaw = await prisma.user.findUnique({
    where: { steamId },
    select: {
      name: true,
      steamId: true,
      avatar: true,
      premierRank: true,
      isAdmin: true,
      status: true,
      team: {
        select: {
          id: true,
          name: true,
          logo: true,
          leaderId: true,
          leader: {
            select: {
              steamId: true,
              name: true,
              avatar: true,
            },
          },
          activePlayers: true,
          inactivePlayers: true,
        },
      },
    },
  })

  if (!userRaw) {
    return NextResponse.json({ error: 'User nicht gefunden' }, { status: 404 })
  }

  // 2) Falls Team vorhanden: active/inactive IDs in User-Objekte auflösen
  let teamResolved: any = null
  if (userRaw.team) {
    const activeIds = userRaw.team.activePlayers ?? []
    const inactiveIds = userRaw.team.inactivePlayers ?? []

    // findMany mit leeren Arrays ist ok und liefert []
    const [activeUsers, inactiveUsers] = await Promise.all([
      prisma.user.findMany({
        where: { steamId: { in: activeIds } },
        select: { steamId: true, name: true, avatar: true, premierRank: true },
      }),
      prisma.user.findMany({
        where: { steamId: { in: inactiveIds } },
        select: { steamId: true, name: true, avatar: true, premierRank: true },
      }),
    ])

    // Optional: Reihenfolge gemäß IDs beibehalten
    const byId = (ids: string[], users: any[]) => {
      const map = new Map(users.map((u) => [u.steamId, u]))
      return ids.map((id) => map.get(id)).filter(Boolean)
    }

    teamResolved = {
      id: userRaw.team.id,
      name: userRaw.team.name,
      logo: userRaw.team.logo,
      leader: userRaw.team.leader ?? null,
      activePlayers: byId(activeIds, activeUsers),
      inactivePlayers: byId(inactiveIds, inactiveUsers),
    }
  }

  // 3) Antwort formen (Team ersetzt durch aufgelöste Struktur)
  const response = {
    name: userRaw.name,
    steamId: userRaw.steamId,
    avatar: userRaw.avatar,
    premierRank: userRaw.premierRank,
    isAdmin: userRaw.isAdmin,
    status: userRaw.status ?? 'offline',
    team: teamResolved,
  }

  return NextResponse.json(response, { headers: { 'Cache-Control': 'no-store' } })
}