/**
 */

const BFF_BASE_URL = process.env.NEXT_PUBLIC_BFF_API_URL!;

/**
 * Interface para usuário da API BFF
 */
export interface UsuarioBff {
  id: string;
  identificador: string;
  ativo: boolean;
  superadmin: boolean;
  auth_id_appwrite: string | null;
  nome: string | null;
  email: string | null;
  telefone: string | null;
  nivel: string | null;
  registro_completo: boolean;
  enderecos: any[];
  empresas_dados: any[];
  nome_social: string | null;
  cpf: string | null;
  createdAt: string;
  updatedAt: string;
}

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

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

/**
 * Serviço de usuários via BFF
 */
export const usuarioApiService = {
  /**
   * Lista usuários com paginação
   * @param params - Parâmetros de busca e paginação
   * @returns Lista paginada de usuários
   */
  listar: async (params: UsuariosBffParams = {}): Promise<UsuariosBffResponse> => {
    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}/usuarios${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 usuários: ${response.status} ${response.statusText}`);
      }

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


      return data;

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

  /**
   * Busca usuário por ID
   * @param usuarioId - ID do usuário
   * @returns Dados do usuário
   */
  buscarPorId: async (usuarioId: string): Promise<UsuarioBff | 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}/usuarios/${usuarioId}`, {
        method: 'GET',
        headers: {
          'accept': 'application/json',
          'Authorization': `Bearer ${token}`,
        },
      });

      if (!response.ok) {
        if (response.status === 404) {
          console.warn(`⚠️ Usuário não encontrado: ${usuarioId}`);
          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 usuário: ${response.status} ${response.statusText}`);
      }

      const usuario: UsuarioBff = await response.json();


      return usuario;

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

  /**
   * Atualiza usuário
   * @param usuarioId - ID do usuário
   * @param data - Dados para atualização
   * @returns Usuário atualizado
   */
  atualizar: async (usuarioId: string, data: Partial<UsuarioBff>): Promise<UsuarioBff> => {
    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}/usuarios/${usuarioId}`, {
        method: 'PUT',
        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 usuário: ${response.status} ${response.statusText}`);
      }

      const usuario: UsuarioBff = await response.json();


      return usuario;

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