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

const BFF_BASE_URL = process.env.NEXT_PUBLIC_BFF_API_URL!;

/**
 * Interface para dados do pagamento na API
 */
export interface PagamentoApiData {
  status: 'pendente' | 'pago' | 'falhou';
  metodo: 'pix' | 'credito' | 'debito';
  valor: number;
  pedidos: string;  // ID do pedido
}

/**
 * Interface para resposta da API
 */
export interface PagamentoApiResponse {
  success: boolean;
  data?: any;
  error?: string;
  message?: string;
}

/**
 * Serviço de pagamentos para API BFF
 */
export const pagamentoApiService = {
  /**
   * Obtém o token de autenticação do localStorage
   */
  getAuthToken: (): string | null => {
    return localStorage.getItem('access_token');
  },

  /**
   * Obtém o ID do usuário atual
   */
  getUserId: (): string | null => {
    try {
      const userStr = localStorage.getItem('user');
      if (!userStr) return null;
      
      const user = JSON.parse(userStr);
      return user.$id || user.id || user.usuario_id || null;
    } catch (error) {
      console.error('Erro ao obter ID do usuário:', error);
      return null;
    }
  },

  /**
   * Cria um novo pagamento
   */
  criar: async (
    metodo: 'pix' | 'credito' | 'debito',
    valor: number,
    pedidoId: string
  ): Promise<PagamentoApiResponse> => {
    try {
      const token = pagamentoApiService.getAuthToken();
      if (!token) {
        return { success: false, error: 'Token de autenticação não encontrado' };
      }

      const payload: PagamentoApiData = {
        status: 'pendente',
        metodo: metodo,
        valor: valor,
        pedidos: pedidoId
      };

      console.log('💳 Criando pagamento na API:', payload);

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

      const data = await response.json();

      if (response.ok) {
        console.log('✅ Pagamento criado com sucesso:', data);
        return { success: true, data };
      } else {
        console.error('❌ Erro ao criar pagamento:', data);
        return { success: false, error: data.message || 'Erro ao criar pagamento' };
      }
    } catch (error) {
      console.error('💥 Erro na criação do pagamento:', error);
      return { success: false, error: 'Erro de conexão ao criar pagamento' };
    }
  },

  /**
   * Confirma um pagamento (PATCH /pagamentos/:id/confirmar)
   */
  confirmar: async (pagamentoId: string): Promise<PagamentoApiResponse> => {
    try {
      const token = pagamentoApiService.getAuthToken();
      if (!token) {
        return { success: false, error: 'Token de autenticação não encontrado' };
      }

      console.log('✅ Confirmando pagamento:', pagamentoId);

      const response = await fetch(`${BFF_BASE_URL}/pagamentos/${pagamentoId}/confirmar`, {
        method: 'PATCH',
        headers: {
          'accept': 'application/json',
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`,
        },
      });

      const data = await response.json();

      if (response.ok) {
        console.log('✅ Pagamento confirmado com sucesso:', data);
        return { success: true, data };
      } else {
        console.error('❌ Erro ao confirmar pagamento:', data);
        return { success: false, error: data.message || 'Erro ao confirmar pagamento' };
      }
    } catch (error) {
      console.error('💥 Erro na confirmação do pagamento:', error);
      return { success: false, error: 'Erro de conexão ao confirmar pagamento' };
    }
  },

  /**
   * Busca um pagamento por ID
   */
  buscarPorId: async (pagamentoId: string): Promise<PagamentoApiResponse> => {
    try {
      const token = pagamentoApiService.getAuthToken();
      if (!token) {
        return { success: false, error: 'Token de autenticação não encontrado' };
      }

      console.log('🔍 Buscando pagamento por ID:', pagamentoId);

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

      const data = await response.json();

      if (response.ok) {
        console.log('✅ Pagamento encontrado:', data);
        return { success: true, data };
      } else {
        console.error('❌ Erro ao buscar pagamento:', data);
        return { success: false, error: data.message || 'Pagamento não encontrado' };
      }
    } catch (error) {
      console.error('💥 Erro ao buscar pagamento:', error);
      return { success: false, error: 'Erro de conexão ao buscar pagamento' };
    }
  },

  /**
   * Lista pagamentos de um pedido
   */
  listarPorPedido: async (pedidoId: string): Promise<PagamentoApiResponse> => {
    try {
      const token = pagamentoApiService.getAuthToken();
      if (!token) {
        return { success: false, error: 'Token de autenticação não encontrado' };
      }

      console.log('📋 Listando pagamentos do pedido:', pedidoId);

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

      const data = await response.json();

      if (response.ok) {
        console.log('✅ Pagamentos listados com sucesso:', data);
        return { success: true, data };
      } else {
        console.error('❌ Erro ao listar pagamentos:', data);
        return { success: false, error: data.message || 'Erro ao listar pagamentos' };
      }
    } catch (error) {
      console.error('💥 Erro ao listar pagamentos:', error);
      return { success: false, error: 'Erro de conexão ao listar pagamentos' };
    }
  },

  /**
   * Mock de processamento de pagamento
   * (Para uso temporário até integração real)
   */
  processarPagamentoMock: async (
    metodo: 'pix' | 'credito' | 'debito',
    valor: number
  ): Promise<{ success: boolean; transactionId?: string; error?: string }> => {
    console.log('🎭 MOCK: Processando pagamento...', { metodo, valor });
    
    // Simular delay de processamento
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    // Simular 90% de sucesso para todos os métodos
    const sucesso = Math.random() > 0.1;
    
    if (sucesso) {
      const transactionId = `mock_${Date.now()}_${Math.random().toString(36).substring(7)}`;
      console.log('✅ MOCK: Pagamento processado com sucesso:', transactionId);
      return { success: true, transactionId };
    } else {
      console.log('❌ MOCK: Falha no processamento do pagamento');
      return { success: false, error: 'Falha na simulação do pagamento' };
    }
  }
};