Interpreting Analytics

computeRanks: teams => {
  const ranks = Array.from({ length: teams.length }, () => ({}));
  
  CONFIG.COLS.forEach(([id, , dir]) => {
    const vals = teams.map((t, i) => ({ num: parseFloat(t.statMap[id]), i }));
    vals.sort((a, b) => {
      if (isNaN(a.num)) return 1;
      if (isNaN(b.num)) return -1;
      return dir === 'high' ? b.num - a.num : a.num - b.num;
    });
    
    let curr = 0, prev = null;
    vals.forEach(({ num, i }, idx) => {
      if (isNaN(num)) { 
        ranks[i][id] = '-'; 
        return;
      }
      if (prev === null || num !== prev) { 
        curr = idx + 1; 
        prev = num; 
      }
      ranks[i][id] = curr;
    });
  });
  
  return ranks;
}

ordinal: n => {
  const s = ['th', 'st', 'nd', 'rd'], v = n % 100;
  return n + (s[(v - 20) % 10] || s[v] || s[0]);
}

if (prev === null || num !== prev) { 
  curr = idx + 1;  // New rank
  prev = num; 
}
ranks[i][id] = curr;  // Same rank if values match

recordVsUser: (baseTeam, oppTeam) => {
  let w = 0, l = 0;
  CONFIG.COLS.forEach(([id, , dir]) => {
    const u = parseFloat(baseTeam[id]);
    const o = parseFloat(oppTeam[id]);
    if (isNaN(u) || isNaN(o) || u === o) return;  // Skip ties
    (dir === 'high' ? u > o : u < o) ? w++ : l++;
  });
  return `${w} - ${l}`;
}

let cls = '';
if (raw !== '–' && baseTeam.statMap[id] !== '–') {
  const a = parseFloat(raw), b = parseFloat(baseTeam.statMap[id]);
  if (!isNaN(a) && !isNaN(b) && a !== b) {
    cls = (dir === 'high' ? b > a : b < a) ? 'better' : 'worse';
  }
}

generateCategoryAnalysis: (teams, ranks, selectedTeamIndex = 0) => {
  const totalTeams = teams.length;
  const weakCategories = [];
  const strongCategories = [];
  const myRanks = ranks[selectedTeamIndex];

  CONFIG.COLS.forEach(([id, name, sortDir]) => {
    const rank = myRanks[id];
    if (rank && rank !== '-' && typeof rank === 'number') {
      const weakThreshold = Math.ceil(totalTeams * 0.7);    // Bottom 30%
      const strongThreshold = Math.ceil(totalTeams * 0.3);  // Top 30%
      
      if (rank >= weakThreshold) {
        weakCategories.push({ name, rank, id });
      } else if (rank <= strongThreshold) {
        strongCategories.push({ name, rank, id });
      }
    }
  });

  weakCategories.sort((a, b) => b.rank - a.rank);
  strongCategories.sort((a, b) => a.rank - b.rank);
  
  return { weakCategories, strongCategories, totalTeams };
}

formatAnalysisSummary: (analysis, mode = 'weekly') => {
  const { weakCategories, strongCategories, teamName } = analysis;
  let summary = `<div class="analysis-content">`;

  if (strongCategories.length > 0) {
    const strongList = strongCategories.slice(0, 3).map(cat => 
      `<strong>${cat.name}</strong> (${Utils.ordinal(cat.rank)})`
    ).join(', ');
    summary += `<div class="strength-summary">
      <span class="highlight positive">Strongest categories:</span> ${strongList}
    </div>`;
  }

  if (weakCategories.length > 0) {
    const weakList = weakCategories.slice(0, 3).map(cat => 
      `<strong>${cat.name}</strong> (${Utils.ordinal(cat.rank)})`
    ).join(', ');
    summary += `<div class="weakness-summary">
      <span class="highlight negative">Areas to improve:</span> ${weakList}
    </div>`;
  }

  return summary + `</div>`;
}

weeklyStats: [
  { week: 1, stats: { '12': 105.2, '15': 45.3, ... } },
  { week: 2, stats: { '12': 108.7, '15': 43.1, ... } },
  // ...
]

formatStatValue: (id, value) => {
  if (CONFIG.PERCENTAGE_STATS.includes(id)) {
    const num = parseFloat(value);
    if (isNaN(num)) return value;
    return num.toFixed(3).replace(/^0\./, '.');  // ".453" instead of "0.453"
  }
  return value;
}

const impactVal = aggregatedStats.impact[statId] || 0;
const isPercentage = statMapInfo.type === 'percentage';
const isLowGood = sortDir === 'low';

let impactClass = '';
const diffThreshold = isPercentage ? 0.0001 : 0.01;
if (Math.abs(impactVal) > diffThreshold) { 
  if ((isLowGood && impactVal < 0) || (!isLowGood && impactVal > 0)) {
    impactClass = 'team-improves';
  } else {
    impactClass = 'team-declines';
  }
}

const currentRank = rankingAnalysis.currentRanks[statId];
const rankDisplay = currentRank && currentRank !== '-' 
  ? Utils.ordinal(currentRank) 
  : 'N/A';

tableHTML += `<td style="text-align: center; font-weight: 600;">${rankDisplay}</td>`;

generateStrategicInsightsHTML: (insights) => {
  if (insights.improvesWeakCategories) {
    html += `<div class="insight-item positive">
      <strong>Strengthens weak areas:</strong> 
      This trade improves ${insights.weakCategoriesImproved.join(', ')}
    </div>`;
  }
  
  if (insights.sacrificesStrengths) {
    html += `<div class="insight-item warning">
      <strong>Warning:</strong> 
      You're giving up advantages in ${insights.strongCategoriesLost.join(', ')}
    </div>`;
  }
}

NBA_STAT_MAP: {
  '12': { nbaKey: 'PTS', type: 'counting', precision: 1 },
  '15': { nbaKey: 'REB', type: 'counting', precision: 1 },
  '16': { nbaKey: 'AST', type: 'counting', precision: 1 }
}

'5': { 
  type: 'percentage', 
  components: { made: 'FGM', attempted: 'FGA' }, 
  nbaKey: 'FG_PCT', 
  precision: 3 
}