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

const BFF_BASE_URL = process.env.NEXT_PUBLIC_BFF_API_URL!;

/**
 * Status válidos para pedidos na API BFF
 */
export type StatusPedido = 'pendente' | 'aprovado' | 'entregue' | 'cancelado';

/**
 * Interface para dados do pedido na API
 */
export interface PedidoApiData {
  status: StatusPedido;     // Status do pedido (valores aceitos pela API)
  "valor-total": number;    // Valor total do pedido (produtos + frete)
  "valor-produtos": number; // Valor apenas dos produtos
  "valor-frete": number;    // Valor do frete
  itens: string[];          // IDs dos produtos
  quantidade: number[];     // Quantidades de cada produto
  pagamentos?: string;      // ID do pagamento (opcional)
  carrinhos?: string;       // ID do carrinho
  usuarios: string;         // ID do usuário
  faturas?: string;         // ID da fatura (opcional)
  entregas?: string;        // ID da entrega (opcional)
}

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

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

  /**
   * Extrai o ID correto do usuário baseado na prioridade dos campos
   */
  extractUserId: (userData: any): string | null => {
    if (!userData) return null;


    // Prioridade baseada na estrutura observada nas imagens:
    // 1. Campo 'id' (prioridade máxima - observado nas imagens como o correto)
    // 2. Campo '$id' (Appwrite)
    // 3. Campo 'usuario_id' (fallback)
    // 4. Campo 'userId' (fallback)

    const possibleIds = {
      id: userData.id,
      $id: userData.$id,
      usuario_id: userData.usuario_id,
      userId: userData.userId
    };


    // Verificar especificamente o campo 'id' primeiro
    if (userData.id && typeof userData.id === 'string' && userData.id.length > 0) {
      return userData.id;
    }

    // Fallbacks
    if (userData.$id && typeof userData.$id === 'string' && userData.$id.length > 0) {
      return userData.$id;
    }

    if (userData.usuario_id && typeof userData.usuario_id === 'string' && userData.usuario_id.length > 0) {
      return userData.usuario_id;
    }

    if (userData.userId && typeof userData.userId === 'string' && userData.userId.length > 0) {
      return userData.userId;
    }

    console.error('❌ [extractUserId] Nenhum ID válido encontrado');
    return null;
  },

  /**
   * 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);

      const selectedId = pedidoApiService.extractUserId(user);

      return selectedId;
    } catch (error) {
      console.error('❌ [getUserId] Erro ao obter ID do usuário:', error);
      return null;
    }
  },

  /**
   * Busca dados do usuário via API /me se não estiver no localStorage
   */
  fetchUserData: async (): Promise<any | null> => {
    try {
      const token = pedidoApiService.getAuthToken();
      if (!token) return null;


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

      if (response.ok) {
        const responseData = await response.json();

        // A resposta pode vir com data.data ou data diretamente
        // Baseado na estrutura fornecida, deve ser data diretamente
        const userData = responseData.data || responseData;



        // Salvar no localStorage para referência (mas não para usar como source do ID)
        localStorage.setItem('user', JSON.stringify(userData));

        return userData;
      } else {
        console.error('❌ Erro na requisição /auth/me:', response.status, response.statusText);
        return null;
      }

    } catch (error) {
      console.error('💥 Erro ao buscar dados do usuário:', error);
      return null;
    }
  },

  /**
   * Busca o ID atual do usuário diretamente da API /auth/me
   */
  getCurrentUserId: async (): Promise<string | null> => {
    try {

      const userData = await pedidoApiService.fetchUserData();
      if (!userData) {
        console.error('❌ Não foi possível buscar dados do usuário');
        return null;
      }

      const userId = userData.id;

      if (!userId) {
        console.error('❌ Campo "id" não encontrado na resposta');
        return null;
      }

      return userId;
    } catch (error) {
      console.error('💥 Erro ao buscar ID do usuário:', error);
      return null;
    }
  },

  convertCarrinhoToPedidoFormat: (itensCarrinho: any[]): Partial<PedidoApiData> => {
    const itens: string[] = [];
    const quantidade: number[] = [];
    let valorProdutos = 0;

    itensCarrinho.forEach(item => {
      const produto = item.produto;
      const qtd = item.quantidade;
      const preco = (produto as any).preco_final || 0;

      itens.push(produto.$id || produto.id);
      quantidade.push(qtd);
      valorProdutos += preco * qtd;
    });

    const valorFrete = 0; // Inicialmente 0, será atualizado depois
    const valorTotal = valorProdutos + valorFrete;

    return {
      itens,
      quantidade,
      "valor-produtos": parseFloat(valorProdutos.toFixed(2)),
      "valor-frete": parseFloat(valorFrete.toFixed(2)),
      "valor-total": parseFloat(valorTotal.toFixed(2)),
    };
  },

  /**
   * Cria um novo pedido na API
   */
  criar: async (itensCarrinho: any[], carrinhoId?: string): Promise<PedidoApiResponse> => {
    try {
      const token = pedidoApiService.getAuthToken();
      if (!token) {
        return { success: false, error: 'Token de autenticação não encontrado' };
      }

      let userId = pedidoApiService.getUserId();

      // Se não tem usuário no localStorage, buscar via API
      if (!userId) {
        const userData = await pedidoApiService.fetchUserData();
        userId = userData?.$id || userData?.id || userData?.usuario_id;
      }

      if (!userId) {
        return { success: false, error: 'ID do usuário não encontrado' };
      }

      if (!itensCarrinho || itensCarrinho.length === 0) {
        return { success: false, error: 'Nenhum item encontrado no carrinho' };
      }

      const pedidoData = pedidoApiService.convertCarrinhoToPedidoFormat(itensCarrinho);

      // Especificar documentId como unique() para garantir criação de novo pedido
      const payload = {
        documentId: "unique()",
        data: {
          status: "pendente",
          ...pedidoData,
          usuarios: userId,
          // Campos opcionais - deixar em branco por enquanto conforme solicitado
          ...(carrinhoId && { carrinhos: carrinhoId }),
          // pagamentos e faturas serão adicionados posteriormente
        }
      };


      const response = await fetch(`${BFF_BASE_URL}/pedidos`, {
        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) {
        return { success: true, data };
      } else {
        console.error('❌ Erro ao criar pedido:', data);
        return { success: false, error: data.message || 'Erro ao criar pedido' };
      }
    } catch (error) {
      console.error('💥 Erro na criação do pedido:', error);
      return { success: false, error: 'Erro de conexão ao criar pedido' };
    }
  },

  /**
   * Busca um pedido específico por ID
   */
  buscarPorId: async (pedidoId: string): Promise<PedidoApiResponse> => {
    try {
      const token = pedidoApiService.getAuthToken();
      if (!token) {
        return { success: false, error: 'Token de autenticação não encontrado' };
      }


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

      const data = await response.json();

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

  /**
   * Busca pedidos pendentes para um carrinho específico
   */
  buscarPendentePorCarrinho: async (carrinhoId: string): Promise<PedidoApiResponse> => {
    try {
      const token = pedidoApiService.getAuthToken();
      if (!token) {
        return { success: false, error: 'Token de autenticação não encontrado' };
      }


      // Primeiro, tentar buscar com filtro específico
      let response = await fetch(`${BFF_BASE_URL}/pedidos?carrinhos=${carrinhoId}&status=pendente&limit=10`, {
        method: 'GET',
        headers: {
          'accept': 'application/json',
          'Authorization': `Bearer ${token}`,
        },
      });

      // Se a busca específica não funcionar, fazer busca geral
      if (!response.ok) {
        response = await fetch(`${BFF_BASE_URL}/pedidos?page=1&limit=100`, {
          method: 'GET',
          headers: {
            'accept': 'application/json',
            'Authorization': `Bearer ${token}`,
          },
        });
      }

      const data = await response.json();

      if (response.ok) {

        // A resposta tem estrutura {page, limit, total, items}
        const pedidos = data.items || [];

        if (Array.isArray(pedidos)) {

          // Procurar por pedido pendente com o mesmo carrinho
          const pedidoPendente = pedidos.find((pedido: any) => {
            const carrinhoMatch = pedido.carrinhos === carrinhoId;
            const statusMatch = pedido.status === 'pendente';


            return carrinhoMatch && statusMatch;
          });

          if (pedidoPendente) {
            return { success: true, data: pedidoPendente };
          } else {
            return { success: false, error: 'Nenhum pedido pendente encontrado' };
          }
        } else {
          return { success: false, error: 'Estrutura de resposta inválida' };
        }
      } else {
        console.error('❌ Erro ao buscar pedidos - status:', response.status, 'data:', data);
        return { success: false, error: data.message || 'Erro ao buscar pedidos' };
      }
    } catch (error) {
      console.error('💥 Erro ao buscar pedido pendente:', error);
      return { success: false, error: 'Erro de conexão ao buscar pedido pendente' };
    }
  },

  /**
   * Lista pedidos do usuário
   */
  listarPorUsuario: async (page: number = 1): Promise<PedidoApiResponse> => {
    try {
      const token = pedidoApiService.getAuthToken();
      if (!token) {
        return { success: false, error: 'Token de autenticação não encontrado' };
      }

      // SEMPRE buscar o ID atual da API /auth/me para garantir que está correto

      const userData = await pedidoApiService.fetchUserData();
      if (!userData) {
        return { success: false, error: 'Não foi possível obter dados do usuário atual' };
      }


      // Extrair o ID diretamente do campo "id" da resposta
      const userId = userData.id;

      if (!userId) {
        console.error('❌ Campo "id" não encontrado na resposta da API /auth/me');
        return { success: false, error: 'ID do usuário não encontrado na resposta da API' };
      }


      const response = await fetch(`${BFF_BASE_URL}/pedidos?page=${page}&limit=100&usuario_id=${userId}`, {
        method: 'GET',
        headers: {
          'accept': 'application/json',
          'Authorization': `Bearer ${token}`,
        },
      });

      const data = await response.json();

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

  /**
   * Atualiza um pedido existente
   */
  atualizar: async (pedidoId: string, dadosAtualizacao: Partial<PedidoApiData>): Promise<PedidoApiResponse> => {
    try {
      const token = pedidoApiService.getAuthToken();
      if (!token) {
        return { success: false, error: 'Token de autenticação não encontrado' };
      }


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

      const data = await response.json();

      if (response.ok) {
        return { success: true, data };
      } else {
        console.error('❌ Erro ao atualizar pedido:', data);
        return { success: false, error: data.message || 'Erro ao atualizar pedido' };
      }
    } catch (error) {
      console.error('💥 Erro na atualização do pedido:', error);
      return { success: false, error: 'Erro de conexão ao atualizar pedido' };
    }
  },

  /**
   * Atualiza apenas o status de um pedido
   */
  atualizarStatus: async (pedidoId: string, novoStatus: StatusPedido): Promise<PedidoApiResponse> => {
    try {
      const token = pedidoApiService.getAuthToken();
      if (!token) {
        return { success: false, error: 'Token de autenticação não encontrado' };
      }

      const payload = {
        status: novoStatus
      };


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

      const data = await response.json();

      if (response.ok) {
        return { success: true, data };
      } else {
        console.error('❌ Erro ao atualizar status do pedido:', data);
        return { success: false, error: data.message || 'Erro ao atualizar status do pedido' };
      }
    } catch (error) {
      console.error('💥 Erro na atualização do status:', error);
      return { success: false, error: 'Erro de conexão ao atualizar status' };
    }
  },
};