import { NextRequest, NextResponse } from "next/server";
import { getPool } from "@/services/database";
import { isUserAuthenticated } from "@/lib/server-auth";

// GET - Récupérer toutes les teams
export async function GET() {
  try {
    // Vérifier l'authentification
    const isAuthenticated = await isUserAuthenticated();
    if (!isAuthenticated) {
      return NextResponse.json({ error: "Non autorisé" }, { status: 401 });
    }

    const pool = getPool();
    const query = `
      SELECT 
        t.id,
        t.name,
        t.direction,
        COUNT(DISTINCT u.uuid_id) as member_count
      FROM teams t
      LEFT JOIN users u ON t.id = u.team_id
      GROUP BY t.id, t.name, t.direction
      ORDER BY t.direction, t.name
    `;

    const result = await pool.query(query);

    const teams = result.rows.map((row) => ({
      id: row.id,
      name: row.name,
      direction: row.direction,
      memberCount: parseInt(row.member_count) || 0,
    }));

    return NextResponse.json(teams);
  } catch (error) {
    console.error("Error fetching teams:", error);
    return NextResponse.json(
      { error: "Erreur lors de la récupération des teams" },
      { status: 500 }
    );
  }
}

// POST - Créer une nouvelle team
export async function POST(request: NextRequest) {
  try {
    // Vérifier l'authentification
    const isAuthenticated = await isUserAuthenticated();
    if (!isAuthenticated) {
      return NextResponse.json({ error: "Non autorisé" }, { status: 401 });
    }

    const { name, direction } = await request.json();

    if (!name || !direction) {
      return NextResponse.json(
        { error: "Le nom et la direction sont requis" },
        { status: 400 }
      );
    }

    const pool = getPool();

    // Vérifier si la team existe déjà
    const existingTeam = await pool.query(
      "SELECT id FROM teams WHERE LOWER(name) = LOWER($1)",
      [name]
    );

    if (existingTeam.rows.length > 0) {
      return NextResponse.json(
        { error: "Une équipe avec ce nom existe déjà" },
        { status: 409 }
      );
    }

    // Créer la nouvelle team
    const result = await pool.query(
      `INSERT INTO teams (name, direction) 
       VALUES ($1, $2) 
       RETURNING id, name, direction`,
      [name, direction]
    );

    const newTeam = result.rows[0];

    const team = {
      id: newTeam.id,
      name: newTeam.name,
      direction: newTeam.direction,
      memberCount: 0,
    };

    return NextResponse.json(team, { status: 201 });
  } catch (error) {
    console.error("Error creating team:", error);
    return NextResponse.json(
      { error: "Erreur lors de la création de l'équipe" },
      { status: 500 }
    );
  }
}

// PUT - Mettre à jour une team
export async function PUT(request: NextRequest) {
  try {
    // Vérifier l'authentification
    const isAuthenticated = await isUserAuthenticated();
    if (!isAuthenticated) {
      return NextResponse.json({ error: "Non autorisé" }, { status: 401 });
    }

    const { id, name, direction } = await request.json();

    if (!id || !name || !direction) {
      return NextResponse.json(
        { error: "L'ID, le nom et la direction sont requis" },
        { status: 400 }
      );
    }

    const pool = getPool();

    // Vérifier si la team existe
    const existingTeam = await pool.query(
      "SELECT id FROM teams WHERE id = $1",
      [id]
    );

    if (existingTeam.rows.length === 0) {
      return NextResponse.json(
        { error: "Équipe non trouvée" },
        { status: 404 }
      );
    }

    // Vérifier si le nom existe déjà (sauf pour cette team)
    const duplicateName = await pool.query(
      "SELECT id FROM teams WHERE LOWER(name) = LOWER($1) AND id != $2",
      [name, id]
    );

    if (duplicateName.rows.length > 0) {
      return NextResponse.json(
        { error: "Une équipe avec ce nom existe déjà" },
        { status: 409 }
      );
    }

    // Mettre à jour la team
    await pool.query(
      `UPDATE teams 
       SET name = $1, direction = $2 
       WHERE id = $3`,
      [name, direction, id]
    );

    // Récupérer la team mise à jour
    const result = await pool.query(
      `SELECT t.id, t.name, t.direction, COUNT(DISTINCT u.uuid_id) as member_count
       FROM teams t
       LEFT JOIN users u ON t.id = u.team_id
       WHERE t.id = $1
       GROUP BY t.id, t.name, t.direction`,
      [id]
    );

    const team = result.rows[0];

    return NextResponse.json({
      id: team.id,
      name: team.name,
      direction: team.direction,
      memberCount: parseInt(team.member_count) || 0,
    });
  } catch (error) {
    console.error("Error updating team:", error);
    return NextResponse.json(
      { error: "Erreur lors de la mise à jour de l'équipe" },
      { status: 500 }
    );
  }
}

// DELETE - Supprimer une team ou une direction
export async function DELETE(request: NextRequest) {
  try {
    // Vérifier l'authentification
    const isAuthenticated = await isUserAuthenticated();
    if (!isAuthenticated) {
      return NextResponse.json({ error: "Non autorisé" }, { status: 401 });
    }

    const { searchParams } = new URL(request.url);
    const id = searchParams.get("id");
    const direction = searchParams.get("direction");

    if (!id && !direction) {
      return NextResponse.json(
        { error: "L'ID de l'équipe ou la direction est requis" },
        { status: 400 }
      );
    }

    const pool = getPool();

    if (direction) {
      // Supprimer une direction entière
      // Vérifier d'abord si des équipes ont des membres
      const memberCheck = await pool.query(
        `SELECT COUNT(*) as count 
         FROM users u
         JOIN teams t ON u.team_id = t.id 
         WHERE t.direction = $1`,
        [direction]
      );

      const memberCount = parseInt(memberCheck.rows[0].count);
      if (memberCount > 0) {
        return NextResponse.json(
          {
            error: `Impossible de supprimer la direction "${direction}" car certaines équipes ont des membres`,
          },
          { status: 409 }
        );
      }

      // Supprimer toutes les équipes de la direction
      await pool.query("DELETE FROM teams WHERE direction = $1", [direction]);

      return NextResponse.json({
        message: `Direction "${direction}" et toutes ses équipes supprimées avec succès`,
      });
    } else {
      // Supprimer une équipe spécifique
      // Vérifier si la team a des membres
      const memberCheck = await pool.query(
        `SELECT COUNT(*) as count 
         FROM users 
         WHERE team_id = $1`,
        [id]
      );

      const memberCount = parseInt(memberCheck.rows[0].count);
      if (memberCount > 0) {
        return NextResponse.json(
          {
            error:
              "Impossible de supprimer une équipe qui contient des membres",
          },
          { status: 409 }
        );
      }

      // Supprimer la team
      await pool.query("DELETE FROM teams WHERE id = $1", [id]);

      return NextResponse.json({ message: "Équipe supprimée avec succès" });
    }
  } catch (error) {
    console.error("Error deleting team/direction:", error);
    return NextResponse.json(
      { error: "Erreur lors de la suppression" },
      { status: 500 }
    );
  }
}