// Usando Sentry (funciona com React Native)
import * as Sentry from '@sentry/react-native';

Sentry.init({
  dsn: 'https://your-dsn@sentry.io/project',
  tracesSampleRate: 0.2, // 20% das transações para desempenho
  environment: __DEV__ ? 'development' : 'production',
});

// Envolva seu componente raiz
const App = () => {
  return (
    <Sentry.ErrorBoundary fallback={<ErrorScreen />}>
      <YourApp />
    </Sentry.ErrorBoundary>
  );
};

// Adicione contexto para depuração
Sentry.setUser({ id: userId });
Sentry.setTag('wallet_connected', hasWallet.toString());

// Registre tentativas de transação com contexto
const executeTransaction = async (tx: Transaction, type: string) => {
  const startTime = Date.now();
  
  try {
    const signature = await connection.sendTransaction(tx, [wallet]);
    await connection.confirmTransaction(signature);
    
    // Registre o sucesso
    analytics.track('transaction_success', {
      type,
      duration: Date.now() - startTime,
      signature,
    });
    
    return signature;
  } catch (error) {
    // Registre a falha com detalhes
    analytics.track('transaction_failure', {
      type,
      duration: Date.now() - startTime,
      error: error.message,
      errorCode: error.code,
    });
    
    Sentry.captureException(error, {
      tags: { transaction_type: type },
      extra: { tx: tx.serialize().toString('base64') }
    });
    
    throw error;
  }
};

const RPC_ENDPOINTS = [
  'https://your-primary.rpc.com',
  'https://your-backup.rpc.com',
  'https://api.mainnet-beta.solana.com', // Fallback público
];

let currentEndpointIndex = 0;

const getConnection = () => {
  return new Connection(RPC_ENDPOINTS[currentEndpointIndex], 'confirmed');
};

const rotateEndpoint = () => {
  currentEndpointIndex = (currentEndpointIndex + 1) % RPC_ENDPOINTS.length;
  console.log(`Switched to RPC: ${RPC_ENDPOINTS[currentEndpointIndex]}`);
};

const executeWithRetry = async <T>(
  operation: (connection: Connection) => Promise<T>,
  maxRetries = 3
): Promise<T> => {
  let lastError;
  
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await operation(getConnection());
    } catch (error) {
      lastError = error;
      
      // Rotacione em erros de conexão
      if (error.message.includes('429') || error.message.includes('timeout')) {
        rotateEndpoint();
      }
    }
  }
  
  throw lastError;
};

// Implemente exponential backoff
const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));

const fetchWithBackoff = async (fetchFn: () => Promise<any>, maxRetries = 5) => {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fetchFn();
    } catch (error) {
      if (error.message.includes('429') && attempt < maxRetries - 1) {
        const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
        console.log(`Rate limited, waiting ${delay}ms`);
        await sleep(delay);
      } else {
        throw error;
      }
    }
  }
};

const setupAccountSubscription = (publicKey: PublicKey) => {
  let ws: number;
  let heartbeatInterval: NodeJS.Timeout;
  
  const connect = () => {
    ws = connection.onAccountChange(
      publicKey,
      (accountInfo) => {
        handleAccountUpdate(accountInfo);
      }
    );
    
    // Heartbeat para detectar desconexões silenciosas
    heartbeatInterval = setInterval(async () => {
      try {
        await connection.getSlot();
      } catch {
        console.log('WebSocket health check failed, reconnecting...');
        cleanup();
        connect();
      }
    }, 30000);
  };
  
  const cleanup = () => {
    if (ws) connection.removeAccountChangeListener(ws);
    if (heartbeatInterval) clearInterval(heartbeatInterval);
  };
  
  connect();
  
  return cleanup;
};

// Versionamento de API
const API_VERSION = '2024.1';

const apiRequest = async (endpoint: string, options: RequestInit) => {
  return fetch(`https://api.yourapp.com/v1/${endpoint}`, {
    ...options,
    headers: {
      ...options.headers,
      'X-App-Version': APP_VERSION,
      'X-API-Version': API_VERSION,
    }
  });
};

// O backend pode rotear ou transformar com base na versão

const checkForceUpdate = async () => {
  const response = await fetch('https://api.yourapp.com/app-config');
  const config = await response.json();
  
  const currentVersion = DeviceInfo.getVersion();
  
  if (compareVersions(currentVersion, config.minimumVersion) < 0) {
    // Atualização forçada necessária
    Alert.alert(
      'Atualização Necessária',
      'Por favor, atualize para a versão mais recente para continuar.',
      [
        {
          text: 'Atualizar',
          onPress: () => Linking.openURL(config.storeUrl)
        }
      ],
      { cancelable: false }
    );
    return false;
  }
  
  if (compareVersions(currentVersion, config.latestVersion) < 0) {
    // Aviso suave de atualização
    Alert.alert(
      'Atualização Disponível',
      'Uma nova versão está disponível com melhorias.',
      [
        { text: 'Depois', style: 'cancel' },
        { text: 'Atualizar', onPress: () => Linking.openURL(config.storeUrl) }
      ]
    );
  }
  
  return true;
};

interface FeatureFlags {
  newSwapInterface: boolean;
  enableNftGallery: boolean;
  showPromotionalBanner: boolean;
  maxTransactionRetries: number;
}

const defaultFlags: FeatureFlags = {
  newSwapInterface: false,
  enableNftGallery: true,
  showPromotionalBanner: false,
  maxTransactionRetries: 3,
};

const fetchFeatureFlags = async (): Promise<FeatureFlags> => {
  try {
    const response = await fetch('https://api.yourapp.com/feature-flags');
    const serverFlags = await response.json();
    return { ...defaultFlags, ...serverFlags };
  } catch {
    return defaultFlags; // Fallback para padrões se a requisição falhar
  }
};

// Uso
const FeatureFlagProvider: React.FC = ({ children }) => {
  const [flags, setFlags] = useState<FeatureFlags>(defaultFlags);
  
  useEffect(() => {
    fetchFeatureFlags().then(setFlags);
  }, []);
  
  return (
    <FeatureFlagContext.Provider value={flags}>
      {children}
    </FeatureFlagContext.Provider>
  );
};

import CodePush from 'react-native-code-push';

// Verifique atualizações ao iniciar o app
const codePushOptions = {
  checkFrequency: CodePush.CheckFrequency.ON_APP_START,
  installMode: CodePush.InstallMode.ON_NEXT_RESTART,
};

const App = () => {
  // ... seu app
};

export default CodePush(codePushOptions)(App);

const reportIssue = async (userDescription: string) => {
  const diagnostics = {
    appVersion: DeviceInfo.getVersion(),
    buildNumber: DeviceInfo.getBuildNumber(),
    os: Platform.OS,
    osVersion: DeviceInfo.getSystemVersion(),
    deviceModel: DeviceInfo.getModel(),
    walletConnected: !!currentWallet,
    walletType: currentWallet?.type,
    recentTransactions: await getRecentTransactionLogs(),
    timestamp: new Date().toISOString(),
  };
  
  await fetch('https://api.yourapp.com/support/issue', {
    method: 'POST',
    body: JSON.stringify({
      description: userDescription,
      diagnostics,
      userId: currentUser?.id,
    })
  });
};

// Armazene o histórico de transações localmente
const logTransaction = async (tx: {
  signature: string;
  type: string;
  status: 'pending' | 'confirmed' | 'failed';
  timestamp: number;
  error?: string;
}) => {
  const history = await getTransactionHistory();
  history.unshift(tx);
  
  // Mantenha as últimas 100 transações
  if (history.length > 100) history.pop();
  
  await AsyncStorage.setItem('txHistory', JSON.stringify(history));
};

// Exponha na tela de suporte/depuração
const TransactionHistory = () => {
  const [history, setHistory] = useState([]);
  
  useEffect(() => {
    getTransactionHistory().then(setHistory);
  }, []);
  
  return (
    <FlatList
      data={history}
      renderItem={({ item }) => (
        <TouchableOpacity
          onPress={() => {
            Clipboard.setString(item.signature);
            Alert.alert('Copiado', 'Assinatura da transação copiada');
          }}
        >
          <Text>{item.type} - {item.status}</Text>
          <Text style={styles.signature}>{item.signature.slice(0, 20)}...</Text>
        </TouchableOpacity>
      )}
    />
  );
};

// Otimize o uso de RPC

// Ruim: Polling a cada segundo
setInterval(() => connection.getBalance(publicKey), 1000);

// Melhor: Use subscrições WebSocket
connection.onAccountChange(publicKey, (accountInfo) => {
  updateBalance(accountInfo.lamports);
});

// Ainda melhor: Agrupe requisições quando possível
const [balance, tokenAccounts, recentTx] = await Promise.all([
  connection.getBalance(publicKey),
  connection.getParsedTokenAccountsByOwner(publicKey, { programId: TOKEN_PROGRAM_ID }),
  connection.getSignaturesForAddress(publicKey, { limit: 5 })
]);