import { apiClient } from '@/services/api/client';
import type {
  Playlist,
  PlaylistTrack,
  PlaylistListResponse,
} from '../types';

/**
 * Playlist Service
 * T0299: Service frontend pour gérer les playlists
 * T0451: Utilise les types depuis types.ts
 */

/**
 * Classe d'erreur personnalisée pour les playlists
 */
export class PlaylistError extends Error {
  constructor(
    message: string,
    public code: 'NOT_FOUND' | 'FORBIDDEN' | 'VALIDATION' | 'NETWORK' | 'SERVER' | 'UNKNOWN',
    public retryable: boolean = false,
    public originalError?: unknown
  ) {
    super(message);
    this.name = 'PlaylistError';
  }
}

/**
 * Crée une nouvelle playlist
 * T0457: Create Playlist Frontend Service
 * @param data Données de la playlist à créer
 * @returns La playlist créée
 * @throws PlaylistError si la requête échoue
 */
export async function createPlaylist(data: CreatePlaylistRequest): Promise<Playlist> {
  try {
    const response = await apiClient.post<{ playlist: Playlist }>('/playlists', {
      title: data.title,
      description: data.description,
      is_public: data.is_public ?? true,
      cover_url: data.cover_url,
    });
    return response.data.playlist;
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 400) {
        const errorMessage = error.response?.data?.error || 'Données invalides';
        throw new PlaylistError(errorMessage, 'VALIDATION', false, error);
      }
      if (error.response?.status === 401) {
        throw new PlaylistError(
          'Non autorisé: Veuillez vous connecter',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Échec de la création. Veuillez réessayer plus tard.',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Récupère une liste de playlists avec pagination
 * T0457: Create Playlist Frontend Service
 * @param userId ID de l'utilisateur pour filtrer (optionnel)
 * @param page Numéro de page (défaut: 1)
 * @param limit Nombre d'éléments par page (défaut: 20)
 * @returns La réponse avec les playlists et les métadonnées de pagination
 * @throws PlaylistError si la requête échoue
 */
export async function getPlaylists(
  userId?: number,
  page = 1,
  limit = 20
): Promise<PlaylistListResponse> {
  try {
    const params = new URLSearchParams({
      page: page.toString(),
      limit: limit.toString(),
    });
    if (userId) {
      params.append('user_id', userId.toString());
    }

    const response = await apiClient.get<PlaylistListResponse>(
      `/playlists?${params.toString()}`
    );
    return response.data;
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Impossible de récupérer les playlists',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Récupère une playlist par son ID
 * T0457: Create Playlist Frontend Service
 * @param id ID de la playlist
 * @returns La playlist
 * @throws PlaylistError si la requête échoue
 */
export async function getPlaylist(id: number): Promise<Playlist> {
  try {
    const response = await apiClient.get<{ playlist: Playlist }>(`/playlists/${id}`);
    return response.data.playlist;
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 404) {
        throw new PlaylistError('Playlist introuvable', 'NOT_FOUND', false, error);
      }
      if (error.response?.status === 403) {
        throw new PlaylistError('Accès refusé à cette playlist', 'FORBIDDEN', false, error);
      }
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Impossible de récupérer la playlist',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Met à jour une playlist
 * T0457: Create Playlist Frontend Service
 * @param id ID de la playlist
 * @param data Données à mettre à jour
 * @returns La playlist mise à jour
 * @throws PlaylistError si la requête échoue
 */
export async function updatePlaylist(
  id: number,
  data: UpdatePlaylistRequest
): Promise<Playlist> {
  try {
    const body: { title?: string; description?: string; is_public?: boolean; cover_url?: string } = {};
    if (data.title !== undefined) body.title = data.title;
    if (data.description !== undefined) body.description = data.description;
    if (data.is_public !== undefined) body.is_public = data.is_public;
    if (data.cover_url !== undefined) body.cover_url = data.cover_url;

    const response = await apiClient.put<{ playlist: Playlist }>(
      `/playlists/${id}`,
      body
    );
    return response.data.playlist;
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 400) {
        const errorMessage = error.response?.data?.error || 'Données invalides';
        throw new PlaylistError(errorMessage, 'VALIDATION', false, error);
      }
      if (error.response?.status === 403) {
        throw new PlaylistError(
          'Accès refusé: Vous n\'êtes pas propriétaire de cette playlist',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 404) {
        throw new PlaylistError('Playlist introuvable', 'NOT_FOUND', false, error);
      }
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Échec de la mise à jour. Veuillez réessayer plus tard.',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Supprime une playlist
 * T0457: Create Playlist Frontend Service
 * @param id ID de la playlist
 * @throws PlaylistError si la requête échoue
 */
export async function deletePlaylist(id: number): Promise<void> {
  try {
    await apiClient.delete(`/playlists/${id}`);
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 403) {
        throw new PlaylistError(
          'Accès refusé: Vous n\'êtes pas propriétaire de cette playlist',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 404) {
        throw new PlaylistError('Playlist introuvable', 'NOT_FOUND', false, error);
      }
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Échec de la suppression. Veuillez réessayer plus tard.',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Ajoute un track à une playlist
 * T0469: Create PlaylistTrack Frontend Service
 * @param playlistId ID de la playlist
 * @param trackId ID du track
 * @param position Position optionnelle du track dans la playlist (défaut: fin de la playlist)
 * @throws PlaylistError si la requête échoue
 */
export async function addTrackToPlaylist(
  playlistId: number,
  trackId: number,
  position?: number
): Promise<void> {
  try {
    const body: { track_id: number; position?: number } = {
      track_id: trackId,
    };
    if (position !== undefined) {
      body.position = position;
    }
    await apiClient.post(`/playlists/${playlistId}/tracks`, body);
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 400) {
        const errorMessage = error.response?.data?.error || 'Track déjà dans la playlist';
        throw new PlaylistError(errorMessage, 'VALIDATION', false, error);
      }
      if (error.response?.status === 403) {
        throw new PlaylistError(
          'Accès refusé: Vous n\'êtes pas propriétaire de cette playlist',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 404) {
        const errorMessage = error.response?.data?.error || 'Playlist ou track introuvable';
        throw new PlaylistError(errorMessage, 'NOT_FOUND', false, error);
      }
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Échec de l\'ajout. Veuillez réessayer plus tard.',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Retire un track d'une playlist
 * T0469: Create PlaylistTrack Frontend Service
 * @param playlistId ID de la playlist
 * @param trackId ID du track
 * @throws PlaylistError si la requête échoue
 */
export async function removeTrackFromPlaylist(
  playlistId: number,
  trackId: number
): Promise<void> {
  try {
    await apiClient.delete(`/playlists/${playlistId}/tracks/${trackId}`);
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 401) {
        throw new PlaylistError(
          'Non autorisé: Veuillez vous connecter',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 403) {
        throw new PlaylistError(
          'Accès refusé: Vous n\'êtes pas propriétaire de cette playlist',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 404) {
        const errorMessage = error.response?.data?.error || 'Playlist ou track introuvable';
        throw new PlaylistError(errorMessage, 'NOT_FOUND', false, error);
      }
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Échec de la suppression. Veuillez réessayer plus tard.',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Réorganise les tracks d'une playlist
 * T0469: Create PlaylistTrack Frontend Service
 * @param playlistId ID de la playlist
 * @param trackPositions Map des IDs de tracks vers leurs nouvelles positions (trackId -> position)
 * @throws PlaylistError si la requête échoue
 */
export async function reorderPlaylistTracks(
  playlistId: number,
  trackPositions: Record<number, number>
): Promise<void> {
  try {
    await apiClient.put(`/playlists/${playlistId}/tracks/reorder`, {
      track_positions: trackPositions,
    });
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 400) {
        const errorMessage = error.response?.data?.error || 'Données invalides';
        throw new PlaylistError(errorMessage, 'VALIDATION', false, error);
      }
      if (error.response?.status === 401) {
        throw new PlaylistError(
          'Non autorisé: Veuillez vous connecter',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 403) {
        throw new PlaylistError(
          'Accès refusé: Vous n\'êtes pas propriétaire de cette playlist',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 404) {
        throw new PlaylistError('Playlist introuvable', 'NOT_FOUND', false, error);
      }
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Échec de la réorganisation. Veuillez réessayer plus tard.',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

// Alias pour compatibilité avec le code existant
/**
 * @deprecated Utilisez addTrackToPlaylist à la place
 */
export const addTrack = addTrackToPlaylist;

/**
 * @deprecated Utilisez removeTrackFromPlaylist à la place
 */
export const removeTrack = removeTrackFromPlaylist;

/**
 * @deprecated Utilisez reorderPlaylistTracks à la place
 */
export function reorderTracks(playlistId: number, trackIds: number[]): Promise<void> {
  // Convertir la liste de trackIds en map de positions
  const trackPositions: Record<number, number> = {};
  trackIds.forEach((trackId, index) => {
    trackPositions[trackId] = index + 1;
  });
  return reorderPlaylistTracks(playlistId, trackPositions);
}

/**
 * Liste les playlists avec pagination (offset-based)
 * T0457: Create Playlist Frontend Service
 * @param limit Nombre d'éléments par page (défaut: 20)
 * @param offset Offset pour la pagination (défaut: 0)
 * @returns La réponse avec les playlists et les métadonnées de pagination
 * @throws PlaylistError si la requête échoue
 */
export async function listPlaylists(limit = 20, offset = 0): Promise<PlaylistListResponse> {
  try {
    const params = new URLSearchParams({
      limit: limit.toString(),
      offset: offset.toString(),
    });

    const response = await apiClient.get<PlaylistListResponse>(
      `/playlists?${params.toString()}`
    );
    return response.data;
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Impossible de récupérer les playlists',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Type pour un collaborateur de playlist
 * T0481: Create Playlist Share Frontend Service
 */
export interface PlaylistCollaborator {
  id: number;
  playlist_id: number;
  user_id: number;
  permission: 'read' | 'write' | 'admin';
  created_at: string;
  updated_at: string;
  user?: {
    id: number;
    username: string;
    email: string;
  };
}

/**
 * Requête pour ajouter un collaborateur
 * T0481: Create Playlist Share Frontend Service
 */
export interface AddCollaboratorRequest {
  user_id: number;
  permission: 'read' | 'write' | 'admin';
}

/**
 * Requête pour mettre à jour la permission d'un collaborateur
 * T0481: Create Playlist Share Frontend Service
 */
export interface UpdateCollaboratorPermissionRequest {
  permission: 'read' | 'write' | 'admin';
}

/**
 * PlaylistShareLink représente un lien de partage public pour une playlist
 * T0488: Create Playlist Public Share Link
 */
export interface PlaylistShareLink {
  id: number;
  playlist_id: number;
  user_id: number;
  share_token: string;
  expires_at?: string;
  access_count: number;
  created_at: string;
  updated_at: string;
}

/**
 * Ajoute un collaborateur à une playlist
 * T0481: Create Playlist Share Frontend Service
 * @param playlistId ID de la playlist
 * @param data Données du collaborateur à ajouter
 * @returns Le collaborateur créé
 * @throws PlaylistError si la requête échoue
 */
export async function addCollaborator(
  playlistId: number,
  data: AddCollaboratorRequest
): Promise<PlaylistCollaborator> {
  try {
    const response = await apiClient.post<{ collaborator: PlaylistCollaborator }>(
      `/playlists/${playlistId}/collaborators`,
      {
        user_id: data.user_id,
        permission: data.permission,
      }
    );
    return response.data.collaborator;
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 400) {
        const errorMessage = error.response?.data?.error || 'Données invalides';
        throw new PlaylistError(errorMessage, 'VALIDATION', false, error);
      }
      if (error.response?.status === 401) {
        throw new PlaylistError(
          'Non autorisé: Veuillez vous connecter',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 403) {
        throw new PlaylistError(
          'Accès refusé: Vous n\'êtes pas propriétaire de cette playlist',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 404) {
        const errorMessage = error.response?.data?.error || 'Playlist ou utilisateur introuvable';
        throw new PlaylistError(errorMessage, 'NOT_FOUND', false, error);
      }
      if (error.response?.status === 409) {
        throw new PlaylistError(
          'Cet utilisateur est déjà collaborateur de cette playlist',
          'VALIDATION',
          false,
          error
        );
      }
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Échec de l\'ajout du collaborateur. Veuillez réessayer plus tard.',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Retire un collaborateur d'une playlist
 * T0481: Create Playlist Share Frontend Service
 * @param playlistId ID de la playlist
 * @param userId ID de l'utilisateur collaborateur à retirer
 * @throws PlaylistError si la requête échoue
 */
export async function removeCollaborator(
  playlistId: number,
  userId: number
): Promise<void> {
  try {
    await apiClient.delete(`/playlists/${playlistId}/collaborators/${userId}`);
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 401) {
        throw new PlaylistError(
          'Non autorisé: Veuillez vous connecter',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 403) {
        throw new PlaylistError(
          'Accès refusé: Vous n\'êtes pas propriétaire de cette playlist',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 404) {
        const errorMessage = error.response?.data?.error || 'Playlist ou collaborateur introuvable';
        throw new PlaylistError(errorMessage, 'NOT_FOUND', false, error);
      }
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Échec de la suppression du collaborateur. Veuillez réessayer plus tard.',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Met à jour la permission d'un collaborateur
 * T0481: Create Playlist Share Frontend Service
 * @param playlistId ID de la playlist
 * @param userId ID de l'utilisateur collaborateur
 * @param data Nouvelle permission
 * @throws PlaylistError si la requête échoue
 */
export async function updateCollaboratorPermission(
  playlistId: number,
  userId: number,
  data: UpdateCollaboratorPermissionRequest
): Promise<void> {
  try {
    await apiClient.put(`/playlists/${playlistId}/collaborators/${userId}`, {
      permission: data.permission,
    });
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 400) {
        const errorMessage = error.response?.data?.error || 'Permission invalide';
        throw new PlaylistError(errorMessage, 'VALIDATION', false, error);
      }
      if (error.response?.status === 401) {
        throw new PlaylistError(
          'Non autorisé: Veuillez vous connecter',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 403) {
        throw new PlaylistError(
          'Accès refusé: Vous n\'êtes pas propriétaire de cette playlist',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 404) {
        const errorMessage = error.response?.data?.error || 'Playlist ou collaborateur introuvable';
        throw new PlaylistError(errorMessage, 'NOT_FOUND', false, error);
      }
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Échec de la mise à jour de la permission. Veuillez réessayer plus tard.',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Récupère tous les collaborateurs d'une playlist
 * T0481: Create Playlist Share Frontend Service
 * @param playlistId ID de la playlist
 * @returns Liste des collaborateurs
 * @throws PlaylistError si la requête échoue
 */
export async function getCollaborators(
  playlistId: number
): Promise<PlaylistCollaborator[]> {
  try {
    const response = await apiClient.get<{ collaborators: PlaylistCollaborator[] }>(
      `/playlists/${playlistId}/collaborators`
    );
    return response.data.collaborators;
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 401) {
        throw new PlaylistError(
          'Non autorisé: Veuillez vous connecter',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 403) {
        throw new PlaylistError(
          'Accès refusé: Vous n\'avez pas accès à cette playlist',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 404) {
        throw new PlaylistError('Playlist introuvable', 'NOT_FOUND', false, error);
      }
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Impossible de récupérer les collaborateurs',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Crée un lien de partage public pour une playlist
 * T0488: Create Playlist Public Share Link
 * @param playlistId ID de la playlist
 * @returns Le lien de partage créé
 * @throws PlaylistError si la requête échoue
 */
export async function createShareLink(playlistId: number): Promise<PlaylistShareLink> {
  try {
    const response = await apiClient.post<{ share_link: PlaylistShareLink }>(
      `/playlists/${playlistId}/share-link`
    );
    return response.data.share_link;
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 400) {
        const errorMessage = error.response?.data?.error || 'Données invalides';
        throw new PlaylistError(errorMessage, 'VALIDATION', false, error);
      }
      if (error.response?.status === 401) {
        throw new PlaylistError(
          'Non autorisé: Veuillez vous connecter',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 403) {
        throw new PlaylistError(
          'Accès refusé: Vous n\'êtes pas propriétaire de cette playlist',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 404) {
        const errorMessage = error.response?.data?.error || 'Playlist introuvable';
        throw new PlaylistError(errorMessage, 'NOT_FOUND', false, error);
      }
      if (error.response?.status === 500) {
        throw new PlaylistError(
          'Erreur serveur: Échec de la création du lien de partage. Veuillez réessayer plus tard.',
          'SERVER',
          true,
          error
        );
      }
      if (!error.response) {
        throw new PlaylistError(
          'Erreur réseau: Impossible de se connecter au serveur',
          'NETWORK',
          true,
          error
        );
      }
    }
    throw new PlaylistError(
      error instanceof Error ? error.message : 'Une erreur inattendue est survenue',
      'UNKNOWN',
      false,
      error
    );
  }
}

/**
 * Recommendation représente une recommandation de playlist avec son score
 * T0498: Create Playlist Recommendations
 */
export interface PlaylistRecommendation {
  playlist: Playlist;
  score: number;
  reason: string;
}

/**
 * GetRecommendationsParams représente les paramètres pour obtenir des recommandations
 * T0498: Create Playlist Recommendations
 */
export interface GetRecommendationsParams {
  limit?: number; // Nombre de recommandations (défaut: 20, max: 100)
  min_score?: number; // Score minimum (défaut: 0.1)
  include_own?: boolean; // Inclure les playlists de l'utilisateur (défaut: false)
}

/**
 * GetRecommendationsResponse représente la réponse de recommandations
 * T0498: Create Playlist Recommendations
 */
export interface GetRecommendationsResponse {
  recommendations: PlaylistRecommendation[];
  count: number;
}

/**
 * Récupère les recommandations de playlists pour l'utilisateur actuel
 * T0498: Create Playlist Recommendations
 * @param params Paramètres de recommandation
 * @returns La réponse avec les recommandations
 * @throws PlaylistError si la requête échoue
 */
export async function getPlaylistRecommendations(params?: GetRecommendationsParams): Promise<GetRecommendationsResponse> {
  try {
    const queryParams = new URLSearchParams();
    
    if (params?.limit !== undefined) {
      queryParams.append('limit', params.limit.toString());
    }
    if (params?.min_score !== undefined) {
      queryParams.append('min_score', params.min_score.toString());
    }
    if (params?.include_own !== undefined) {
      queryParams.append('include_own', params.include_own.toString());
    }

    const queryString = queryParams.toString();
    const url = `/playlists/recommendations${queryString ? `?${queryString}` : ''}`;
    
    const response = await apiClient.get<GetRecommendationsResponse>(url);
    return response.data;
  } catch (error) {
    if (error instanceof AxiosError) {
      if (error.response?.status === 401) {
        throw new PlaylistError(
          'Non autorisé: Veuillez vous connecter',
          'FORBIDDEN',
          false,
          error
        );
      }
      if (error.response?.status === 500) {
        throw new PlaylistError('Erreur serveur lors de la récupération des recommandations', 'SERVER', true, error);
      }
      throw new PlaylistError('Erreur réseau lors de la récupération des recommandations', 'NETWORK', true, error);
    }
    throw new PlaylistError('Erreur inconnue lors de la récupération des recommandations', 'UNKNOWN', false, error);
  }
}

