/**
 * Serviço para gerenciar laboratórios via BFF
 * Integração com https://bff-dev.saveinmed.com.br/api/v1/laboratorios
 */

const BFF_BASE_URL = process.env.NEXT_PUBLIC_BFF_API_URL!;

/**
 * Interface para laboratório da API BFF
 */
export interface LaboratorioBff {
  id: string;
  nome: string;
  createdAt?: string;
  updatedAt?: string;
}

/**
 * Interface para criar/atualizar laboratório
 */
export interface LaboratorioCreateUpdate {
  nome: string;
}

/**
 * Interface para resposta paginada da API BFF
 */
export interface LaboratoriosBffResponse {
  page: number;
  limit: number;
  total: number;
  items: LaboratorioBff[];
}

/**
 * Interface para parâmetros de busca
 */
export interface LaboratoriosBffParams {
  page?: number;
  limit?: number;
  search?: string;
}

/**
 * Serviço de laboratórios via BFF
 */
export const laboratorioApiService = {
  /**
   * Lista laboratórios com paginação
   * @param params - Parâmetros de busca e paginação
   * @returns Lista paginada de laboratórios
   */
  listar: async (params: LaboratoriosBffParams = {}): Promise<LaboratoriosBffResponse> => {
    try {
      const token = localStorage.getItem('access_token');

      if (!token) {
        throw new Error('Token de autenticação não encontrado');
      }

      // Construir query params
      const queryParams = new URLSearchParams();
      if (params.page !== undefined) queryParams.append('page', params.page.toString());
      if (params.limit !== undefined) queryParams.append('limit', params.limit.toString());
      if (params.search) queryParams.append('search', params.search);

      const url = `${BFF_BASE_URL}/laboratorios${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;


      const response = await fetch(url, {
        method: 'GET',
        headers: {
          'accept': 'application/json',
          'Authorization': `Bearer ${token}`,
        },
      });

      if (!response.ok) {
        const errorText = await response.text();
        console.error('❌ Erro na resposta da API:', {
          status: response.status,
          statusText: response.statusText,
          body: errorText,
        });

        if (response.status === 401) {
          throw new Error('Token de autenticação inválido ou expirado');
        }

        throw new Error(`Erro ao buscar laboratórios: ${response.status} ${response.statusText}`);
      }

      const data: LaboratoriosBffResponse = await response.json();


      return data;

    } catch (error) {
      console.error('❌ Erro ao buscar laboratórios:', error);
      throw error;
    }
  },

  /**
   * Busca laboratório por ID
   * @param laboratorioId - ID do laboratório
   * @returns Dados do laboratório
   */
  buscarPorId: async (laboratorioId: string): Promise<LaboratorioBff | null> => {
    try {
      const token = localStorage.getItem('access_token');

      if (!token) {
        throw new Error('Token de autenticação não encontrado');
      }


      const response = await fetch(`${BFF_BASE_URL}/laboratorios/${laboratorioId}`, {
        method: 'GET',
        headers: {
          'accept': 'application/json',
          'Authorization': `Bearer ${token}`,
        },
      });

      if (!response.ok) {
        if (response.status === 404) {
          console.warn(`⚠️ Laboratório não encontrado: ${laboratorioId}`);
          return null;
        }

        const errorText = await response.text();
        console.error('❌ Erro na resposta da API:', {
          status: response.status,
          statusText: response.statusText,
          body: errorText,
        });

        if (response.status === 401) {
          throw new Error('Token de autenticação inválido ou expirado');
        }

        throw new Error(`Erro ao buscar laboratório: ${response.status} ${response.statusText}`);
      }

      const laboratorio: LaboratorioBff = await response.json();


      return laboratorio;

    } catch (error) {
      console.error('❌ Erro ao buscar laboratório:', error);
      throw error;
    }
  },

  /**
   * Cria novo laboratório
   * @param data - Dados do laboratório
   * @returns Laboratório criado
   */
  criar: async (data: LaboratorioCreateUpdate): Promise<LaboratorioBff> => {
    try {
      const token = localStorage.getItem('access_token');

      if (!token) {
        throw new Error('Token de autenticação não encontrado');
      }


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

      if (!response.ok) {
        const errorText = await response.text();
        console.error('❌ Erro na resposta da API:', {
          status: response.status,
          statusText: response.statusText,
          body: errorText,
        });

        if (response.status === 401) {
          throw new Error('Token de autenticação inválido ou expirado');
        }

        throw new Error(`Erro ao criar laboratório: ${response.status} ${response.statusText}`);
      }

      const laboratorio: LaboratorioBff = await response.json();


      return laboratorio;

    } catch (error) {
      console.error('❌ Erro ao criar laboratório:', error);
      throw error;
    }
  },

  /**
   * Atualiza laboratório
   * @param laboratorioId - ID do laboratório
   * @param data - Dados para atualização
   * @returns Laboratório atualizado
   */
  atualizar: async (laboratorioId: string, data: LaboratorioCreateUpdate): Promise<LaboratorioBff> => {
    try {
      const token = localStorage.getItem('access_token');

      if (!token) {
        throw new Error('Token de autenticação não encontrado');
      }


      const response = await fetch(`${BFF_BASE_URL}/laboratorios/${laboratorioId}`, {
        method: 'PATCH',
        headers: {
          'accept': 'application/json',
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`,
        },
        body: JSON.stringify(data),
      });

      if (!response.ok) {
        const errorText = await response.text();
        console.error('❌ Erro na resposta da API:', {
          status: response.status,
          statusText: response.statusText,
          body: errorText,
        });

        if (response.status === 401) {
          throw new Error('Token de autenticação inválido ou expirado');
        }

        throw new Error(`Erro ao atualizar laboratório: ${response.status} ${response.statusText}`);
      }

      const laboratorio: LaboratorioBff = await response.json();


      return laboratorio;

    } catch (error) {
      console.error('❌ Erro ao atualizar laboratório:', error);
      throw error;
    }
  },

  /**
   * Deleta laboratório
   * @param laboratorioId - ID do laboratório
   * @returns Sucesso da operação
   */
  deletar: async (laboratorioId: string): Promise<boolean> => {
    try {
      const token = localStorage.getItem('access_token');

      if (!token) {
        throw new Error('Token de autenticação não encontrado');
      }


      const response = await fetch(`${BFF_BASE_URL}/laboratorios/${laboratorioId}`, {
        method: 'DELETE',
        headers: {
          'accept': '*/*',
          'Authorization': `Bearer ${token}`,
        },
      });

      if (!response.ok) {
        const errorText = await response.text();
        console.error('❌ Erro na resposta da API:', {
          status: response.status,
          statusText: response.statusText,
          body: errorText,
        });

        if (response.status === 401) {
          throw new Error('Token de autenticação inválido ou expirado');
        }

        if (response.status === 404) {
          console.warn(`⚠️ Laboratório não encontrado para deleção: ${laboratorioId}`);
          return false;
        }

        throw new Error(`Erro ao deletar laboratório: ${response.status} ${response.statusText}`);
      }

      return true;

    } catch (error) {
      console.error('❌ Erro ao deletar laboratório:', error);
      throw error;
    }
  },
};