Portfolio Service API

export function formatPortfolioForAI(portfolio: PortfolioData): string {
  if (!portfolio.tokens.length) {
    return `Your wallet is currently empty. No tokens found at address ${maskAddress(portfolio.walletAddress)}.`;
  }

  let response = `📊 **Your Portfolio** (${maskAddress(portfolio.walletAddress)})\n\n`;
  response += `💰 **Total Balance:** $${portfolio.totalBalanceUSD}\n\n`;
  response += `**Holdings:**\n`;

  portfolio.tokens.forEach((token, index) => {
    response += `${index + 1}. **${token.symbol}**: ${token.balance} ($${token.balanceUSD})\n`;
    response += `   Price: $${token.price}\n`;
  });

  response += `\n---\n`;
  response += `_Data is read from blockchain. Prices from Binance API (real-time)._`;

  return response;
}

export function formatTokenBalance(portfolio: PortfolioData, tokenSymbol: string): string {
  const token = portfolio.tokens.find(t => t.symbol === tokenSymbol);
  
  if (!token) {
    return `You don't have any ${tokenSymbol} in your wallet. Your ${tokenSymbol} balance is 0.`;
  }

  return `💰 **${token.symbol} Balance**\n\n` +
         `Amount: ${token.balance} ${token.symbol}\n` +
         `Value: $${token.balanceUSD}\n` +
         `Current Price: $${token.price}\n\n` +
         `_Data from blockchain (${maskAddress(portfolio.walletAddress)})_`;
}

export function isPortfolioQuery(message: string): boolean {
  const portfolioKeywords = /(my portfolio|my balance|my wallet|holdings|how much|how many|kitna|kitne|balance check|show balance|check.*balance|what.*balance)/i;
  const specificTokenQuery = /(how much|how many|kitna|kitne|do i have|i have) (btc|eth|sol|bnb|usdc)/i;
  
  return portfolioKeywords.test(message) || specificTokenQuery.test(message);
}

export function extractTokenQuery(message: string): string | null {
  const match = message.match(/(btc|eth|sol|bnb|usdc|avax|xrp|ton|doge|ada|trx|bitcoin|ethereum|solana)/i);
  
  if (!match) return null;
  
  const token = match[1].toLowerCase();
  const tokenMap: Record<string, string> = {
    'bitcoin': 'BTC', 'btc': 'BTC',
    'ethereum': 'ETH', 'eth': 'ETH',
    'solana': 'SOL', 'sol': 'SOL',
    'binance': 'BNB', 'bnb': 'BNB',
    'ripple': 'XRP', 'xrp': 'XRP',
    'toncoin': 'TON', 'ton': 'TON',
    'avalanche': 'AVAX', 'avax': 'AVAX',
    'dogecoin': 'DOGE', 'doge': 'DOGE',
    'cardano': 'ADA', 'ada': 'ADA',
    'tron': 'TRX', 'trx': 'TRX',
    'usdc': 'USDC'
  };
  
  return tokenMap[token] || null;
}

function maskAddress(address: string): string {
  if (!address) return '';
  return `${address.slice(0, 6)}...${address.slice(-4)}`;
}

// Example:
maskAddress('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1')
// → "0x742d...bEb1"

const handleSendMessage = async (e: React.FormEvent) => {
  // 1. Route query
  debugRoute(userInput);
  const route = routeQuery(userInput);
  
  // 2. Detect trade keywords
  const hasTradeKeyword = /(buy|sell|swap|trade)/i.test(userInput);
  
  // 3. Handle portfolio queries (skip AI)
  if (!hasTradeKeyword && (route.type === 'portfolio' || isPortfolioQuery(userInput))) {
    if (!isConnected || !address) {
      const walletMessage = {
        id: generateChatId(),
        text: '🔒 Please connect your wallet first to view your portfolio.',
        sender: 'ai',
        timestamp: new Date()
      };
      setMessages(prev => [...prev, walletMessage]);
      setIsTyping(false);
      return;
    }
    
    try {
      // Fetch portfolio data (READ-ONLY)
      const portfolio = await getUserPortfolio(address);
      const specificToken = extractTokenQuery(userInput);
      
      // Track mentioned token for context
      if (specificToken) {
        setLastMentionedToken(specificToken);
        console.log(`🎯 Tracking token context: ${specificToken}`);
      }
      
      // Format response
      let responseText: string;
      if (specificToken) {
        responseText = formatTokenBalance(portfolio, specificToken);
      } else {
        responseText = formatPortfolioForAI(portfolio);
      }
      
      // Display immediately (no AI delay)
      setTimeout(() => {
        const portfolioMessage = {
          id: generateChatId(),
          text: responseText,
          sender: 'ai',
          timestamp: new Date()
        };
        
        setMessages(prev => [...prev, portfolioMessage]);
        addMessageToConversation(chatId, portfolioMessage, address);
        setIsTyping(false);
      }, 1500);
      
      return;
    } catch (error) {
      console.error('Portfolio fetch error:', error);
      const errorMessage = {
        id: generateChatId(),
        text: '❌ Unable to fetch portfolio data. Please try again.',
        sender: 'ai',
        timestamp: new Date()
      };
      setMessages(prev => [...prev, errorMessage]);
      setIsTyping(false);
      return;
    }
  }
  
  // ... continue with other query types
};

return {
  totalBalanceUSD: totalUSD.toFixed(2),
  tokens: tokens.sort((a, b) => parseFloat(b.balanceUSD) - parseFloat(a.balanceUSD)),
  walletAddress: address
};