import { NextResponse } from "next/server";
import { prisma } from "@/lib/prisma";
import { hasRole } from "@/lib/permissions";
import { auth } from "@/lib/auth";

export async function POST(request: Request) {
  // Check permissions
  const permission = await hasRole("club_admin");
  if (!permission.allowed) {
    return NextResponse.json(
      { error: permission.reason || "Unauthorized" },
      { status: 403 }
    );
  }

  try {
    const body = await request.json();
    const { email, password, name, role, playerId } = body;

    // Validate required fields
    if (!email || !password) {
      return NextResponse.json(
        { error: "Email and password are required" },
        { status: 400 }
      );
    }

    // Check if user already exists
    const existingUser = await prisma.user.findUnique({
      where: { email },
    });

    if (existingUser) {
      return NextResponse.json(
        { error: "A user with this email already exists" },
        { status: 400 }
      );
    }

    // Use Better Auth to create the user
    const signUpResult = await auth.api.signUpEmail({
      body: {
        email,
        password,
        name: name || undefined,
      },
    });

    const user = signUpResult.user;

    // Update the user's role in the database
    await prisma.user.update({
      where: { id: user.id },
      data: {
        role: role || "player",
        playerId: playerId ? parseInt(playerId) : null,
        emailVerified: true, // Admin-created users are auto-verified
      },
    });

    // If a player was associated, update the player's user relation
    if (playerId) {
      await prisma.player.update({
        where: { id: parseInt(playerId) },
        data: { user: { connect: { id: user.id } } },
      });
    }

    return NextResponse.json({
      success: true,
      user: {
        id: user.id,
        email: user.email,
        name: user.name,
        role: role || "player",
        playerId: playerId ? parseInt(playerId) : null,
      },
    });
  } catch (error: any) {
    console.error("Error creating user:", error);
    
    // Handle Better Auth specific errors
    if (error.message && error.message.includes("already exists")) {
      return NextResponse.json(
        { error: "A user with this email already exists" },
        { status: 400 }
      );
    }
    
    return NextResponse.json(
      { error: "Failed to create user" },
      { status: 500 }
    );
  }
}

export async function GET(request: Request) {
  // Check permissions
  const permission = await hasRole("club_admin");
  if (!permission.allowed) {
    return NextResponse.json(
      { error: permission.reason || "Unauthorized" },
      { status: 403 }
    );
  }

  try {
    const { searchParams } = new URL(request.url);
    const playerId = searchParams.get("playerId");

    const users = await prisma.user.findMany({
      where: playerId ? { playerId: parseInt(playerId) } : {},
      orderBy: { createdAt: "desc" },
      include: {
        player: true,
      },
    });

    return NextResponse.json({ users });
  } catch (error) {
    console.error("Error fetching users:", error);
    return NextResponse.json(
      { error: "Failed to fetch users" },
      { status: 500 }
    );
  }
}