Get Queue Positions

async function checkQueueStatus(walletAddress) {
  try {
    const response = await fetch(`https://api.strike.markets/positions/${walletAddress}/queue-positions`);
    
    if (response.status === 404) {
      return { message: "No positions in queue", inQueue: false };
    }
    
    const data = await response.json();
    
    return {
      inQueue: true,
      position: data.queuePosition,
      usdAhead: parseFloat(data.usdAhead),
      estimatedWait: estimateWaitTime(data.queuePosition, data.usdAhead)
    };
  } catch (error) {
    console.error('Failed to check queue status:', error);
    return { error: 'Failed to fetch queue information' };
  }
}

function estimateWaitTime(position, usdAhead) {
  if (usdAhead < 1000) return 'Within 6 hours';
  if (usdAhead < 5000) return '6-24 hours';
  if (usdAhead < 20000) return '1-3 days';
  return 'Several days';
}

class QueueMonitor {
  constructor(walletAddress, onUpdate) {
    this.walletAddress = walletAddress;
    this.onUpdate = onUpdate;
    this.lastPosition = null;
    this.lastAmount = null;
  }
  
  async start() {
    this.check();
    this.timer = setInterval(() => this.check(), 30000); // Check every 30 seconds
  }
  
  stop() {
    if (this.timer) clearInterval(this.timer);
  }
  
  async check() {
    try {
      const response = await fetch(`https://api.strike.markets/positions/${this.walletAddress}/queue-positions`);
      
      if (response.status === 404) {
        // Not in queue anymore - likely paid out!
        if (this.lastPosition !== null) {
          this.onUpdate({ 
            event: 'payout_completed',
            message: 'Your payout has been processed!' 
          });
          this.stop();
        }
        return;
      }
      
      const data = await response.json();
      
      if (this.lastPosition !== null) {
        if (data.queuePosition < this.lastPosition) {
          this.onUpdate({
            event: 'position_improved',
            oldPosition: this.lastPosition,
            newPosition: data.queuePosition,
            message: `Moved up in queue: position ${this.lastPosition} → ${data.queuePosition}`
          });
        }
        
        const amountChange = this.lastAmount - parseFloat(data.usdAhead);
        if (amountChange > 10) { // More than 10 USD processed
          this.onUpdate({
            event: 'queue_processed',
            amountProcessed: amountChange,
            remaining: data.usdAhead,
            message: `$${amountChange.toFixed(2)} processed ahead of you`
          });
        }
      }
      
      this.lastPosition = data.queuePosition;
      this.lastAmount = parseFloat(data.usdAhead);
      
      this.onUpdate({
        event: 'status_update',
        position: data.queuePosition,
        usdAhead: data.usdAhead
      });
      
    } catch (error) {
      this.onUpdate({
        event: 'error',
        message: 'Failed to check queue status'
      });
    }
  }
}

// Usage
const monitor = new QueueMonitor(walletAddress, (update) => {
  console.log('Queue update:', update);
  
  switch(update.event) {
    case 'payout_completed':
      showNotification('Payout completed!', 'success');
      break;
    case 'position_improved':
      showNotification(`Moved to position ${update.newPosition}`, 'info');
      break;
    case 'queue_processed':
      showNotification(`$${update.amountProcessed} processed`, 'info');
      break;
  }
});

monitor.start();

function QueueProgressBar({ queuePosition, usdAhead }) {
  const getProgressData = () => {
    const totalEstimated = usdAhead + 1000; // Estimate total queue size
    const progress = (1000 / totalEstimated) * 100;
    
    return {
      progress: Math.max(progress, 5), // Minimum 5% to show some progress
      positionText: `Position ${queuePosition} in queue`,
      amountText: `$${parseFloat(usdAhead).toFixed(2)} ahead`,
      estimatedTime: getEstimatedTime(usdAhead)
    };
  };
  
  const getEstimatedTime = (amount) => {
    if (amount < 1000) return 'Within 6 hours';
    if (amount < 5000) return '6-24 hours';
    if (amount < 20000) return '1-3 days';
    return 'Several days';
  };
  
  const data = getProgressData();
  
  return (
    <div className="queue-progress">
      <div className="progress-header">
        <span className="position">{data.positionText}</span>
        <span className="amount">{data.amountText}</span>
      </div>
      <div className="progress-bar">
        <div 
          className="progress-fill" 
          style={{ width: `${data.progress}%` }}
        />
      </div>
      <div className="estimated-time">
        Estimated payout time: {data.estimatedTime}
      </div>
    </div>
  );
}

async function getQueueAnalytics(walletAddress) {
  try {
    const response = await fetch(`https://api.strike.markets/positions/${walletAddress}/queue-positions`);
    
    if (response.status === 404) {
      return { inQueue: false, message: "No positions in payout queue" };
    }
    
    const data = await response.json();
    const usdAhead = parseFloat(data.usdAhead);
    
    // Calculate analytics
    const analytics = {
      queuePosition: data.queuePosition,
      usdAhead: usdAhead,
      priority: getPriority(data.queuePosition),
      estimatedHours: estimateHours(usdAhead),
      percentileRank: calculatePercentile(data.queuePosition, usdAhead),
      recommendedAction: getRecommendation(data.queuePosition, usdAhead)
    };
    
    return analytics;
  } catch (error) {
    return { error: 'Failed to fetch queue analytics' };
  }
}

function getPriority(position) {
  if (position <= 5) return 'HIGH';
  if (position <= 20) return 'MEDIUM';
  return 'LOW';
}

function estimateHours(usdAhead) {
  if (usdAhead < 1000) return '1-6';
  if (usdAhead < 5000) return '6-24';
  if (usdAhead < 20000) return '24-72';
  return '72+';
}

function calculatePercentile(position, amount) {
  // Simplified percentile calculation
  // In practice, you might track historical queue data
  const score = (1 / position) * 100 + (1 / (amount / 1000)) * 100;
  return Math.min(Math.max(score, 1), 99).toFixed(1);
}

function getRecommendation(position, amount) {
  if (position <= 3) return 'Your payout should process very soon. No action needed.';
  if (amount < 5000) return 'You should be paid within 24 hours. Monitor progress.';
  if (amount < 20000) return 'Payout may take 1-3 days. Consider smaller position sizes in future.';
  return 'Significant queue ahead. Consider risk management for future trades.';
}