// Prediction algorithm based on team statistics
const calculateFootballPrediction = (event) => {
  // Base stats for simulation
  const homeAdvantage = 2.5
  
  // Generate realistic team ratings (0-100 scale)
  const homeRating = 75 + Math.random() * 20
  const awayRating = 70 + Math.random() * 20
  
  // Calculate expected scores
  const baseScore = 21
  const homeExpected = baseScore + (homeRating - 65) * 0.4 + homeAdvantage
  const awayExpected = baseScore + (awayRating - 65) * 0.4
  
  // Add variance
  const homeScore = Math.round(homeExpected + (Math.random() - 0.5) * 14)
  const awayScore = Math.round(awayExpected + (Math.random() - 0.5) * 14)
  
  // Determine winner
  let winner
  if (homeScore > awayScore) winner = 'home'
  else if (awayScore > homeScore) winner = 'away'
  else winner = 'tie'
  
  // Calculate confidence based on score difference
  const scoreDiff = Math.abs(homeScore - awayScore)
  const confidence = Math.min(95, 50 + scoreDiff * 3 + Math.random() * 10)
  
  // Generate player stats
  const homeStats = {
    passingYards: Math.round(180 + Math.random() * 150),
    rushingYards: Math.round(80 + Math.random() * 120),
    touchdowns: Math.round(2 + Math.random() * 3),
    sacks: Math.round(1 + Math.random() * 4),
    interceptions: Math.round(Math.random() * 2),
    qbRating: (80 + Math.random() * 40).toFixed(1)
  }
  
  const awayStats = {
    passingYards: Math.round(180 + Math.random() * 150),
    rushingYards: Math.round(80 + Math.random() * 120),
    touchdowns: Math.round(2 + Math.random() * 3),
    sacks: Math.round(1 + Math.random() * 4),
    interceptions: Math.round(Math.random() * 2),
    qbRating: (80 + Math.random() * 40).toFixed(1)
  }
  
  // Adjust stats based on score
  if (winner === 'home') {
    homeStats.touchdowns = Math.max(homeStats.touchdowns, awayStats.touchdowns)
    homeStats.passingYards += Math.round(Math.random() * 30)
  } else if (winner === 'away') {
    awayStats.touchdowns = Math.max(awayStats.touchdowns, homeStats.touchdowns)
    awayStats.passingYards += Math.round(Math.random() * 30)
  }
  
  const keyFactors = [
    `${event.homeTeam.name}'s home field advantage provides a significant boost`,
    `Recent form favors the ${homeRating > awayRating ? event.homeTeam.name : event.awayTeam.name}`,
    `Quarterback matchup analysis shows slight edge to ${Math.random() > 0.5 ? event.homeTeam.name : event.awayTeam.name}`,
    `Defensive efficiency metrics indicate ${scoreDiff > 7 ? 'low-scoring affair' : 'competitive game'}`
  ]
  
  return {
    score: { home: homeScore, away: awayScore },
    winner,
    confidence: Math.round(confidence),
    homeStats,
    awayStats,
    keyFactors
  }
}

const calculateBaseballPrediction = (event) => {
  const homeAdvantage = 0.3
  
  const homeRating = 0.520 + Math.random() * 0.100
  const awayRating = 0.500 + Math.random() * 0.100
  
  // Expected runs based on team quality
  const homeExpected = 4.5 + (homeRating - 0.500) * 20 + homeAdvantage
  const awayExpected = 4.5 + (awayRating - 0.500) * 20
  
  const homeScore = Math.round(homeExpected + (Math.random() - 0.5) * 4)
  const awayScore = Math.round(awayExpected + (Math.random() - 0.5) * 4)
  
  // Ensure no negative scores
  const finalHomeScore = Math.max(0, homeScore)
  const finalAwayScore = Math.max(0, awayScore)
  
  let winner
  if (finalHomeScore > finalAwayScore) winner = 'home'
  else if (finalAwayScore > finalHomeScore) winner = 'away'
  else winner = 'tie'
  
  const scoreDiff = Math.abs(finalHomeScore - finalAwayScore)
  const confidence = Math.min(92, 48 + scoreDiff * 8 + Math.random() * 8)
  
  const homeStats = {
    battingAverage: (0.250 + Math.random() * 0.050).toFixed(3),
    homeRuns: Math.round(1 + Math.random() * 3),
    rbis: Math.round(3 + Math.random() * 5),
    era: (3.5 + Math.random() * 2).toFixed(2),
    strikeouts: Math.round(6 + Math.random() * 8),
    hits: Math.round(6 + Math.random() * 6)
  }
  
  const awayStats = {
    battingAverage: (0.250 + Math.random() * 0.050).toFixed(3),
    homeRuns: Math.round(1 + Math.random() * 3),
    rbis: Math.round(3 + Math.random() * 5),
    era: (3.5 + Math.random() * 2).toFixed(2),
    strikeouts: Math.round(6 + Math.random() * 8),
    hits: Math.round(6 + Math.random() * 6)
  }
  
  const keyFactors = [
    `Starting pitcher matchup favors ${Math.random() > 0.5 ? event.homeTeam.name : event.awayTeam.name}`,
    `Ballpark factors suggest ${homeStats.homeRuns > 2 ? 'power display' : 'pitcher-friendly conditions'}`,
    `Bullpen depth analysis gives edge to ${homeRating > awayRating ? 'home team' : 'visitors'}`,
    `Recent head-to-head trends indicate competitive contest`
  ]
  
  return {
    score: { home: finalHomeScore, away: finalAwayScore },
    winner,
    confidence: Math.round(confidence),
    homeStats,
    awayStats,
    keyFactors
  }
}

const calculateBasketballPrediction = (event) => {
  const homeAdvantage = 3.5
  
  const homeOffense = 112 + Math.random() * 10
  const homeDefense = 108 + Math.random() * 8
  const awayOffense = 110 + Math.random() * 10
  const awayDefense = 109 + Math.random() * 8
  
  const homeExpected = (homeOffense + awayDefense) / 2 + homeAdvantage
  const awayExpected = (awayOffense + homeDefense) / 2
  
  const homeScore = Math.round(homeExpected + (Math.random() - 0.5) * 20)
  const awayScore = Math.round(awayExpected + (Math.random() - 0.5) * 20)
  
  let winner
  if (homeScore > awayScore) winner = 'home'
  else if (awayScore > homeScore) winner = 'away'
  else winner = 'tie'
  
  const scoreDiff = Math.abs(homeScore - awayScore)
  const confidence = Math.min(90, 50 + scoreDiff * 1.5 + Math.random() * 10)
  
  const homeStats = {
    points: homeScore,
    rebounds: Math.round(42 + Math.random() * 12),
    assists: Math.round(22 + Math.random() * 10),
    steals: Math.round(6 + Math.random() * 6),
    blocks: Math.round(4 + Math.random() * 5),
    threePointers: Math.round(10 + Math.random() * 8),
    fieldGoalPct: (44 + Math.random() * 8).toFixed(1) + '%'
  }
  
  const awayStats = {
    points: awayScore,
    rebounds: Math.round(42 + Math.random() * 12),
    assists: Math.round(22 + Math.random() * 10),
    steals: Math.round(6 + Math.random() * 6),
    blocks: Math.round(4 + Math.random() * 5),
    threePointers: Math.round(10 + Math.random() * 8),
    fieldGoalPct: (44 + Math.random() * 8).toFixed(1) + '%'
  }
  
  const keyFactors = [
    `Pace of play projection: ${homeStats.points + awayStats.points > 220 ? 'fast-paced' : 'methodical'} game expected`,
    `Three-point shooting efficiency crucial for ${Math.random() > 0.5 ? event.homeTeam.name : event.awayTeam.name}`,
    `Rebounding battle likely decided by ${homeStats.rebounds > awayStats.rebounds ? 'home team' : 'visitors'}`,
    `Star player matchup analysis shows even competition`
  ]
  
  return {
    score: { home: homeScore, away: awayScore },
    winner,
    confidence: Math.round(confidence),
    homeStats,
    awayStats,
    keyFactors
  }
}

export default function handler(req, res) {
  if (req.method !== 'POST') {
    return res.status(405).json({ error: 'Method not allowed' })
  }

  const { sport, event } = req.body

  if (!sport || !event || !['football', 'baseball', 'basketball'].includes(sport)) {
    return res.status(400).json({ error: 'Invalid request' })
  }

  // Simulate API processing time
  setTimeout(() => {
    let prediction
    
    switch (sport) {
      case 'football':
        prediction = calculateFootballPrediction(event)
        break
      case 'baseball':
        prediction = calculateBaseballPrediction(event)
        break
      case 'basketball':
        prediction = calculateBasketballPrediction(event)
        break
    }
    
    res.status(200).json(prediction)
  }, 1500) // 1.5s delay for realism
}