import { RegisterInput, LoginInput, User, AuthResponse, VerifyEmailResponse } from '@/types/user';
import { getApiUrl } from './config';
import { Client, HydraCollection } from '@/types/medical';

// Utiliser la détection automatique au lieu de la variable d'env statique
const API_BASE_URL = getApiUrl();

console.log('🌐 API URL configurée:', API_BASE_URL);

export class ApiError extends Error {
  constructor(
    message: string,
    public status: number,
    public violations?: Array<{ propertyPath: string; message: string }>
  ) {
    super(message);
    this.name = "ApiError";
  }
}

async function fetchApi<T>(
  endpoint: string,
  options?: RequestInit
): Promise<T> {
  const url = `${API_BASE_URL}${endpoint}`;

  const response = await fetch(url, {
    ...options,
    headers: {
      "Content-Type": "application/ld+json",
      Accept: "application/ld+json",
      ...options?.headers,
    },
  });

  if (!response.ok) {
    const error = await response.json().catch(() => ({
      message: "Une erreur est survenue",
    }));

    throw new ApiError(
      error.message ||
      error["hydra:description"] ||
      `Erreur ${response.status}`,
      response.status,
      error.violations
    );
  }

  return response.json();
}

export const api = {
  register: async (data: { email: string; password: string; name: string; firstName: string; }) => {
    const response = await fetchApi<{
      id: number;
      email: string;
      roles: string[];
      verified: boolean;
    }>('/register', {
      method: 'POST',
      body: JSON.stringify(data),
    });

    return {
      id: response.id,
      email: response.email,
      roles: response.roles,
      isVerified: response.verified,
    };
  },

  login: async (data: { email: string; password: string }) => {
    // CHANGEMENT : Utiliser le proxy au lieu de l'API directe
    const response = await fetch('/api/login', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data),
    });

    if (!response.ok) {
      const error = await response.json();
      throw new ApiError(error.message || 'Erreur de connexion', response.status);
    }

    const data_response = await response.json();

    return {
      token: data_response.token,
      id: data_response.id,
      email: data_response.email,
      roles: data_response.roles,
      isVerified: data_response.verified ?? false,
      activeSubscription: data_response.activeSubscription ?? false,
      appID: data_response.appID,
      name: data_response.name,
      firstName: data_response.firstName,
    };
  },

  verifyEmail: async (token: string) => {
    return fetchApi<{
      message: string;
      email: string;
      verified: boolean;
    }>(`/verify-email?token=${encodeURIComponent(token)}`, {
      method: "GET",
    });
  },

  getCurrentUser: async (token: string) => {
    console.log('🔄 Récupération utilisateur via /api/me');

    // UTILISER LE PROXY au lieu de l'API directe
    const response = await fetch('/api/me', {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
        'Accept': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération de l\'utilisateur',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    const data = await response.json();
    console.log('✅ Utilisateur récupéré:', data.email);

    return {
      id: data.id,
      email: data.email,
      roles: data.roles,
      isVerified: data.verified,
      activeSubscription: data.activeSubscription,
      appID: data.appID,
      name: data.name,
      firstName: data.firstName,
    };
  },

  activateSubscription: async (token: string) => {
    const response = await fetchApi<{
      '@context': string;
      '@id': string;
      '@type': string;
      id: number;
      email: string;
      roles: string[];
      verified: boolean;
      activeSubscription: boolean;
      appID?: string;
    }>('/subscription/activate', {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${token}`,
      },
      body: JSON.stringify({}),
    });

    return {
      id: response.id,
      email: response.email,
      roles: response.roles,
      isVerified: response.verified,
      activeSubscription: response.activeSubscription,
      appID: response.appID,
    };
  },

  changeAppPassword: async (token: string, newPassword: string) => {
    // CHANGEMENT : Utiliser le proxy au lieu de l'API directe
    const response = await fetch('/api/change-password', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ token, newPassword }),
    });

    if (!response.ok) {
      const error = await response.json();
      throw new ApiError(error.message || 'Erreur changement mot de passe', response.status);
    }

    return response.json();
  },

  resetAppPassword: async (token: string, currentPassword: string, newPassword: string) => {
    const response = await fetch('/api/reset-app-password', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ token, currentPassword, newPassword }),
    });

    if (!response.ok) {
      const error = await response.json();
      // Essayer de récupérer le message d'erreur de plusieurs sources
      const errorMessage =
        error.message ||
        error.error ||
        error['hydra:description'] ||
        'Erreur changement mot de passe';

      console.error('❌ Erreur API:', errorMessage, error);
      throw new ApiError(errorMessage, response.status);
    }

    return response.json();
  },

  forgotPassword: async (email: string) => {
    return fetchApi<{
      message: string;
    }>("/forgot-password", {
      method: "POST",
      body: JSON.stringify({ email }),
    });
  },

  resetPassword: async (data: {
    token: string;
    newPassword: string;
    confirmPassword: string;
  }) => {
    return fetchApi<{
      message: string;
    }>("/reset-password", {
      method: "POST",
      body: JSON.stringify(data),
    });
  },

  // Récupérer les clients de l'utilisateur connecté
  getClients: async (token: string) => {
    const response = await fetch('/api/clients', {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération des clients',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    const data = await response.json();
    // API Platform peut retourner soit 'hydra:member' soit 'member'
    return data['hydra:member'] || data['member'] || [];
  },

  // Récupérer un client spécifique avec toutes ses données
  getClient: async (token: string, clientId: number) => {
    const response = await fetch(`/api/clients/${clientId}`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération du client',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Créer un nouveau client
  createClient: async (token: string, data: {
    name: string;
    firstName: string;
    dateOfBirth: string;
    adress: string;
    geographicCoordinates?: string;
  }) => {
    const response = await fetch('/api/clients', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data),
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la création du client',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Mettre à jour un client
  updateClient: async (token: string, clientId: number, data: {
    name: string;
    firstName: string;
    dateOfBirth: string;
    adress: string;
    geographicCoordinates?: string;
  }) => {
    const response = await fetch(`/api/clients/${clientId}`, {
      method: 'PUT',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data),
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la mise à jour du client',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Supprimer un client
  deleteClient: async (token: string, clientId: number) => {
    const response = await fetch(`/api/clients/${clientId}`, {
      method: 'DELETE',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok && response.status !== 204) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la suppression',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return { success: true };
  },

  // ========== EMERGENCY CONTACTS ==========

  // Récupérer tous les contacts d'urgence
  getEmergencyContacts: async (token: string) => {
    const response = await fetch('/api/emergency_contacts', {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération des contacts',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    const data = await response.json();
    // API Platform peut retourner soit 'hydra:member' soit 'member' soit un tableau direct
    return data['hydra:member'] || data['member'] || data || [];
  },

  // Récupérer un contact d'urgence par ID
  getEmergencyContact: async (token: string, contactId: number) => {
    const response = await fetch(`/api/emergency_contacts/${contactId}`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération du contact',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Créer un nouveau contact d'urgence
  createEmergencyContact: async (token: string, data: {
    name: string;
    firstname: string;
    filiation: string;
    phone: string;
  }) => {
    const response = await fetch('/api/emergency_contacts', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data),
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la création du contact',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Mettre à jour un contact d'urgence
  updateEmergencyContact: async (token: string, contactId: number, data: {
    name: string;
    firstname: string;
    filiation: string;
    phone: string;
  }) => {
    const response = await fetch(`/api/emergency_contacts/${contactId}`, {
      method: 'PUT',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data),
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la mise à jour du contact',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Supprimer un contact d'urgence
  deleteEmergencyContact: async (token: string, contactId: number) => {
    const response = await fetch(`/api/emergency_contacts/${contactId}`, {
      method: 'DELETE',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok && response.status !== 204) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la suppression',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return { success: true };
  },

  // ========== DRUGS (MÉDICAMENTS) ==========

  // Récupérer tous les médicaments
  getDrugs: async (token: string) => {
    const response = await fetch('/api/drugs', {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération des médicaments',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    const data = await response.json();
    // API Platform peut retourner soit 'hydra:member' soit 'member' soit un tableau direct
    return data['hydra:member'] || data['member'] || data || [];
  },

  // Récupérer un médicament par ID
  getDrug: async (token: string, drugId: number) => {
    const response = await fetch(`/api/drugs/${drugId}`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération du médicament',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Créer un nouveau médicament
  createDrug: async (token: string, data: {
    name: string;
    posologie: number;
    picture: string;
    day: boolean;
    week: boolean;
  }) => {
    const response = await fetch('/api/drugs', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data),
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la création du médicament',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Mettre à jour un médicament
  updateDrug: async (token: string, drugId: number, data: {
    name: string;
    posologie: number;
    picture: string;
    day: boolean;
    week: boolean;
  }) => {
    const response = await fetch(`/api/drugs/${drugId}`, {
      method: 'PUT',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data),
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la mise à jour du médicament',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Supprimer un médicament
  deleteDrug: async (token: string, drugId: number) => {
    const response = await fetch(`/api/drugs/${drugId}`, {
      method: 'DELETE',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok && response.status !== 204) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la suppression',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return { success: true };
  },

  // Upload d'une image de médicament
  uploadDrugImage: async (token: string, file: File) => {
    const formData = new FormData();
    formData.append('image', file);

    const response = await fetch('/api/drugs/upload-image', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
      },
      body: formData,
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de l\'upload de l\'image',
      }));
      throw new ApiError(
        error.message || error.error || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // ========== CARE PATHWAYS (PARCOURS DE SOINS) ==========

  // Récupérer tous les parcours de soins
  getCarePathways: async (token: string) => {
    const response = await fetch('/api/care_pathways', {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération des parcours de soins',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    const data = await response.json();
    // API Platform peut retourner soit 'hydra:member' soit 'member' soit un tableau direct
    return data['hydra:member'] || data['member'] || data || [];
  },

  // Récupérer un parcours de soins par ID
  getCarePathway: async (token: string, carePathwayId: number) => {
    const response = await fetch(`/api/care_pathways/${carePathwayId}`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération du parcours de soins',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Créer un nouveau parcours de soins
  createCarePathway: async (token: string, data: {
    title: string;
    description: string;
    clientId: number;
  }) => {
    // Transformer clientId en IRI pour API Platform
    const payload = {
      title: data.title,
      description: data.description,
      client: `/api/clients/${data.clientId}`, // IRI du client
    };

    const response = await fetch('/api/care_pathways', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(payload),
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la création du parcours de soins',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Mettre à jour un parcours de soins
  updateCarePathway: async (token: string, carePathwayId: number, data: {
    title: string;
    description: string;
  }) => {
    const response = await fetch(`/api/care_pathways/${carePathwayId}`, {
      method: 'PUT',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data),
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la mise à jour du parcours de soins',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Supprimer un parcours de soins
  deleteCarePathway: async (token: string, carePathwayId: number) => {
    const response = await fetch(`/api/care_pathways/${carePathwayId}`, {
      method: 'DELETE',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok && response.status !== 204) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la suppression',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return { success: true };
  },

  // ========== PARTICULARITIES (PARTICULARITÉS) ==========

  // Récupérer toutes les particularités
  getParticularities: async (token: string) => {
    const response = await fetch('/api/particularities', {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération des particularités',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    const data = await response.json();
    // API Platform peut retourner soit 'hydra:member' soit 'member' soit un tableau direct
    return data['hydra:member'] || data['member'] || data || [];
  },

  // Récupérer une particularité par ID
  getParticularity: async (token: string, particularityId: number) => {
    const response = await fetch(`/api/particularities/${particularityId}`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération de la particularité',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Créer une nouvelle particularité
  createParticularity: async (token: string, data: {
    info: string;
    clientId: number;
  }) => {
    // Transformer clientId en IRI pour API Platform
    const payload = {
      info: data.info,
      client: `/api/clients/${data.clientId}`, // IRI du client
    };

    const response = await fetch('/api/particularities', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(payload),
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la création de la particularité',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Mettre à jour une particularité
  updateParticularity: async (token: string, particularityId: number, data: {
    info: string;
  }) => {
    const response = await fetch(`/api/particularities/${particularityId}`, {
      method: 'PUT',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data),
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la mise à jour de la particularité',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Supprimer une particularité
  deleteParticularity: async (token: string, particularityId: number) => {
    const response = await fetch(`/api/particularities/${particularityId}`, {
      method: 'DELETE',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok && response.status !== 204) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la suppression',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return { success: true };
  },

  // ========== QRCODE ===========

  // Récupérer tous les QRCodes
  getQrcodes: async (token: string) => {
    const response = await fetch('/api/qrcodes', {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération des médicaments',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    const data = await response.json();
    // API Platform peut retourner soit 'hydra:member' soit 'member' soit un tableau direct
    return data['hydra:member'] || data['member'] || data || [];
  },

  // Récupérer le QRCode de l'utilisateur connecté
  getQrcode: async (token: string, qrcodeId: number) => {
    const response = await fetch(`/api/qrcodes/${qrcodeId}`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération du QRcode',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Créer un QRCode
  createQrcode: async (token: string, data: { qrcode: string}) => {
    const response = await fetch('/api/qrcodes', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data),
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la création du QRcode',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Mettre à jour le QRCode
  updateQrcode: async (token: string, qrcodeId: number, data: { qrcode: String }) => {
    const response = await fetch(`/api/qrcodes/${qrcodeId}`, {
      method: 'PUT',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data),
    });
    if (!response.ok) {
      const error = await response.json().catch(() => ({ message: 'Erreur mise à jour QRCode' }));
      throw new ApiError(error.message || `Erreur ${response.status}`, response.status);
    }
    return response.json();
  },


  // Supprimer le QRCode
  deleteQrcode: async (token: string, qrcodeId: number) => {
    const response = await fetch(`/api/qrcodes/${qrcodeId}`, {
      method: 'DELETE',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });
    if (!response.ok && response.status !== 204) {
      const error = await response.json().catch(() => ({ message: 'Erreur suppression QRCode' }));
      throw new ApiError(error.message || `Erreur ${response.status}`, response.status);
    }
    return { success: true };
  },

  // Upload d'une image de QRCode
  uploadQrcodeImage: async (token: string, file: File) => {
    const formData = new FormData();
    formData.append('image', file);
    const response = await fetch('/api/qrcode/upload-image', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${token}`,
      },
      body: formData,
    });
    if (!response.ok) {
      const error = await response.json().catch(() => ({ message: 'Erreur upload image QRCode' }));
      throw new ApiError(
        error.message || error.error || `Erreur ${response.status}`,
        response.status
      );
    }
    return response.json();
  },

  // ========== INTERVENTIONS ==========

  // Récupérer toutes les interventions (intervenants)
  getInterventions: async (token: string, page: number = 1) => {
    const response = await fetch(`/api/interventions?page=${page}`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération des interventions',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

  // Récupérer toutes les interventions médicales (medical_lists)
  getMedicalInterventions: async (token: string, page: number = 1) => {
    const response = await fetch(`/api/medicals?page=${page}`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    });

    if (!response.ok) {
      const error = await response.json().catch(() => ({
        message: 'Erreur lors de la récupération des interventions médicales',
      }));
      throw new ApiError(
        error.message || `Erreur ${response.status}`,
        response.status
      );
    }

    return response.json();
  },

};