NeahFront7/app/api/users/[userId]/route.ts

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

// Helper function to get Leantime user ID by email
async function getLeantimeUserId(email: string): Promise<number | null> {
  try {
    const response = await fetch('https://agilite.slm-lab.net/api/jsonrpc', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key': process.env.LEANTIME_TOKEN || '',
      },
      body: JSON.stringify({
        method: 'leantime.rpc.Users.Users.usernameExist',
        jsonrpc: '2.0',
        id: 1,
        params: {
          username: email,
          notUserId: 0
        }
      })
    });

    const data = await response.json();
    console.log('Leantime username check response:', data);

    if (!response.ok || !data.result) {
      console.error('Failed to check Leantime user:', data);
      return null;
    }

    // If user exists, get their ID
    const userResponse = await fetch('https://agilite.slm-lab.net/api/jsonrpc', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key': process.env.LEANTIME_TOKEN || '',
      },
      body: JSON.stringify({
        method: 'leantime.rpc.Users.Users.getUserByEmail',
        jsonrpc: '2.0',
        id: 1,
        params: {
          email: email
        }
      })
    });

    const userData = await userResponse.json();
    console.log('Leantime get user response:', userData);

    if (!userResponse.ok || !userData.result) {
      console.error('Failed to get Leantime user:', userData);
      return null;
    }

    return userData.result.id;
  } catch (error) {
    console.error('Error getting Leantime user:', error);
    return null;
  }
}

// Helper function to delete user from Leantime
async function deleteLeantimeUser(email: string): Promise<{ success: boolean; error?: string }> {
  try {
    // First get the Leantime user ID
    const leantimeUserId = await getLeantimeUserId(email);
    if (!leantimeUserId) {
      return { 
        success: false, 
        error: 'User not found in Leantime' 
      };
    }

    const response = await fetch('https://agilite.slm-lab.net/api/jsonrpc', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key': process.env.LEANTIME_TOKEN || '',
      },
      body: JSON.stringify({
        method: 'leantime.rpc.Users.Users.deleteUser',
        jsonrpc: '2.0',
        id: 1,
        params: {
          id: leantimeUserId
        }
      })
    });

    const data = await response.json();
    console.log('Leantime delete response:', data);

    if (!response.ok || !data.result) {
      console.error('Leantime user deletion failed:', data);
      return { 
        success: false, 
        error: data.error?.message || 'Failed to delete user in Leantime' 
      };
    }

    return { success: true };
  } catch (error) {
    console.error('Error deleting Leantime user:', error);
    return { 
      success: false, 
      error: 'Error deleting user in Leantime' 
    };
  }
}

export async function DELETE(
  req: Request,
  { params }: { params: { userId: string } }
) {
  const session = await getServerSession(authOptions);

  if (!session) {
    return NextResponse.json({ error: "Non autorisé" }, { status: 401 });
  }

  try {
    // Get admin token
    const tokenResponse = await fetch(
      `${process.env.KEYCLOAK_BASE_URL}/realms/${process.env.KEYCLOAK_REALM}/protocol/openid-connect/token`,
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
        },
        body: new URLSearchParams({
          grant_type: 'client_credentials',
          client_id: process.env.KEYCLOAK_CLIENT_ID!,
          client_secret: process.env.KEYCLOAK_CLIENT_SECRET!,
        }),
      }
    );

    const tokenData = await tokenResponse.json();
    if (!tokenResponse.ok || !tokenData.access_token) {
      console.error("Failed to get admin token:", tokenData);
      return NextResponse.json({ error: "Erreur d'authentification" }, { status: 401 });
    }

    // Get user details before deletion
    const userResponse = await fetch(
      `${process.env.KEYCLOAK_BASE_URL}/admin/realms/${process.env.KEYCLOAK_REALM}/users/${params.userId}`,
      {
        headers: {
          Authorization: `Bearer ${tokenData.access_token}`,
        },
      }
    );

    if (!userResponse.ok) {
      console.error("Failed to get user details:", await userResponse.text());
      return NextResponse.json(
        { error: "Erreur lors de la récupération des détails de l'utilisateur" },
        { status: userResponse.status }
      );
    }

    const userDetails = await userResponse.json();

    // Delete user from Keycloak
    const deleteResponse = await fetch(
      `${process.env.KEYCLOAK_BASE_URL}/admin/realms/${process.env.KEYCLOAK_REALM}/users/${params.userId}`,
      {
        method: "DELETE",
        headers: {
          Authorization: `Bearer ${tokenData.access_token}`,
        },
      }
    );

    if (!deleteResponse.ok) {
      const errorData = await deleteResponse.json();
      console.error("Keycloak delete error:", errorData);
      return NextResponse.json(
        { error: "Erreur lors de la suppression de l'utilisateur", details: errorData },
        { status: deleteResponse.status }
      );
    }

    // Delete user from Leantime
    const leantimeResult = await deleteLeantimeUser(params.userId);

    if (!leantimeResult.success) {
      console.error("Leantime user deletion failed:", leantimeResult.error);
      // We don't return an error here since Keycloak user was deleted successfully
      // We just log the error and continue
    }

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

  } catch (error) {
    console.error("Error deleting user:", error);
    return NextResponse.json(
      { error: "Erreur serveur", details: error },
      { status: 500 }
    );
  }
}

export async function PUT(
  req: Request,
  { params }: { params: { userId: string } }
) {
  const session = await getServerSession(authOptions);

  if (!session) {
    return NextResponse.json({ error: "Non autorisé" }, { status: 401 });
  }

  try {
    const body = await req.json();

    // Get client credentials token
    const tokenResponse = await fetch(
      `${process.env.KEYCLOAK_BASE_URL}/realms/${process.env.KEYCLOAK_REALM}/protocol/openid-connect/token`,
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
        },
        body: new URLSearchParams({
          grant_type: 'client_credentials',
          client_id: process.env.KEYCLOAK_CLIENT_ID!,
          client_secret: process.env.KEYCLOAK_CLIENT_SECRET!,
        }),
      }
    );

    const tokenData = await tokenResponse.json();

    if (!tokenResponse.ok) {
      console.error("Failed to get token:", tokenData);
      return NextResponse.json({ error: "Failed to get token" }, { status: 500 });
    }

    // Update user
    const updateResponse = await fetch(
      `${process.env.KEYCLOAK_BASE_URL}/admin/realms/${process.env.KEYCLOAK_REALM}/users/${params.userId}`,
      {
        method: 'PUT',
        headers: {
          'Authorization': `Bearer ${tokenData.access_token}`,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
      }
    );

    if (!updateResponse.ok) {
      const errorData = await updateResponse.json();
      console.error("Failed to update user:", errorData);
      return NextResponse.json({ error: "Failed to update user" }, { status: updateResponse.status });
    }

    return NextResponse.json({ success: true });
  } catch (error) {
    console.error("Error in PUT user:", error);
    return NextResponse.json({ error: "Internal server error" }, { status: 500 });
  }
}