"Como faço para buscar cotações de múltiplas ações?"
"Quais parâmetros posso usar no endpoint de histórico?"
"Como funciona a autenticação por token?"

"Me mostre um exemplo em React para buscar dados da PETR4"
"Como integrar com Next.js usando Server Components?"
"Qual a melhor forma de tratar erros da API?"

"Estou recebendo erro 429, o que significa?"
"Por que minha requisição está retornando vazia?"
"Como otimizar múltiplas requisições?"

// Exemplo básico com fetch
const token = 'SEU_TOKEN';
const ticker = 'PETR4';

const response = await fetch(
  `https://brapi.dev/api/quote/${ticker}?token=${token}`,
);

if (!response.ok) {
  throw new Error(`Erro: ${response.status}`);
}

const data = await response.json();
console.log(data.results[0].regularMarketPrice);

// Para múltiplos tickers:
const response = await fetch(
  `https://brapi.dev/api/quote/PETR4,VALE3,ITUB4?token=${token}`,
);

import { useState, useEffect } from 'react';

function StockQuote({ ticker }) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    async function fetchQuote() {
      try {
        const response = await fetch(
          `https://brapi.dev/api/quote/${ticker}?token=${process.env.REACT_APP_BRAPI_TOKEN}`,
        );

        if (!response.ok) {
          throw new Error(`HTTP ${response.status}`);
        }

        const result = await response.json();
        setData(result.results[0]);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    }

    fetchQuote();

    // Atualiza a cada 15 minutos
    const interval = setInterval(fetchQuote, 15 * 60 * 1000);
    return () => clearInterval(interval);
  }, [ticker]);

  if (loading) return <div>Carregando...</div>;
  if (error) return <div>Erro: {error}</div>;

  return (
    <div>
      <h2>{data.shortName}</h2>
      <p>R$ {data.regularMarketPrice.toFixed(2)}</p>
      <p
        className={
          data.regularMarketChangePercent >= 0 ? 'positive' : 'negative'
        }
      >
        {data.regularMarketChangePercent >= 0 ? '▲' : '▼'}
        {Math.abs(data.regularMarketChangePercent).toFixed(2)}%
      </p>
    </div>
  );
}

class BrapiError extends Error {
  constructor(message, status, data) {
    super(message);
    this.status = status;
    this.data = data;
  }
}

async function fetchWithHandling(url, token) {
  try {
    const response = await fetch(`${url}?token=${token}`);

    if (!response.ok) {
      const errorData = await response.json().catch(() => ({}));

      switch (response.status) {
        case 401:
          throw new BrapiError('Token inválido ou expirado', 401, errorData);
        case 404:
          throw new BrapiError('Ticker não encontrado', 404, errorData);
        case 429:
          throw new BrapiError(
            'Limite de requisições excedido',
            429,
            errorData,
          );
        case 500:
          throw new BrapiError('Erro interno do servidor', 500, errorData);
        default:
          throw new BrapiError(
            `Erro HTTP ${response.status}`,
            response.status,
            errorData,
          );
      }
    }

    return await response.json();
  } catch (error) {
    if (error instanceof BrapiError) {
      throw error;
    }
    throw new BrapiError('Erro de conexão', 0, {
      originalError: error.message,
    });
  }
}

// Uso
try {
  const data = await fetchWithHandling(
    'https://brapi.dev/api/quote/PETR4',
    'SEU_TOKEN',
  );
  console.log(data);
} catch (error) {
  if (error.status === 401) {
    // Redirecionar para login ou mostrar formulário de token
    console.log('Por favor, verifique seu token de API');
  } else if (error.status === 429) {
    // Implementar retry com backoff exponencial
    console.log('Aguarde um pouco antes de tentar novamente');
  } else {
    console.error('Erro:', error.message);
  }
}

// Usuário: "Como buscar dados da PETR4?"
// IA: Mostra exemplo básico

// Usuário: "Agora adicione os dados fundamentalistas"
// IA: Adiciona parâmetro modules ao exemplo anterior

// Usuário: "E o histórico dos últimos 6 meses?"
// IA: Adiciona parâmetros range e interval

// Código do usuário:
const fetchStock = async (ticker) => {
  const res = await fetch(`https://brapi.dev/api/quote/${ticker}`);
  return res.json();
};

// Sugestão da IA:
// "Seu código está quase perfeito! Algumas melhorias:
// 1. Adicione o token de autenticação
// 2. Verifique se a resposta foi bem-sucedida
// 3. Adicione tratamento de erros
// 4. Considere usar async/await com try/catch"

// Pergunta: "Como criar um dashboard com múltiplas ações?"
// Resposta: Componente React com estado global, atualização automática
// e tratamento de loading/erros

# Pergunta: "Como criar um endpoint proxy em Node.js?"
# Resposta: Express.js middleware com cache Redis,
# rate limiting e tratamento de erros centralizado

// Pergunta: "Como integrar com Flutter?"
// Resposta: Pacote http, tratamento de JSON,
# state management com Provider/Bloc

# Pergunta: "Como analisar séries históricas com pandas?"
# Resposta: Coleta de dados, tratamento de missing values,
# visualização com matplotlib/plotly

Usuário: Olá! Como começo a usar a API?

IA: Olá! Para começar, você precisa:
1. Obter um token gratuito em brapi.dev
2. Fazer uma requisição para o endpoint de cotações
3. Adicionar seu token como parâmetro

Quer um exemplo prático em qual linguagem?

Usuário: Estou recebendo erro 429 ao fazer muitas requisições

IA: Erro 429 significa rate limit excedido. Soluções:
1. Implemente cache de 15 minutos (dados são atualizados nesse intervalo)
2. Use batch requests para múltiplos tickers
3. Adicione delay entre requisições

Quer um exemplo de implementação de cache?

Usuário: Preciso criar um sistema de alertas de preços

IA: Para um sistema de alertas, sugiro:
1. Backend com agendador (cron job)
2. Comparação com limiares configuráveis
3. Notificações por email/webhook
4. Banco de dados para histórico

Posso te mostrar uma arquitetura completa. Qual sua preferência de tecnologia?