ff-football-2024.js

/*
    Buy-in: $200
    $2400 total pot

    1st: $1000
    2nd: $400
    3rd: $200
    Streak (Longest consecutive win streak): $30
    Survivor (Every week the lowest-scoring team is eliminated. Winner is last one standing after week 11): $30

    Highest total points in season: $200
    Highest points per week: $30/week/17 wk

    Ceiling (Most points scored in a week/17 wk): $30
*/
const fs = require("fs");

/* 
    Note: this file is generated from the Yahoo Fantasy Helper website
    https://fhelper.azurewebsites.net/

    The requested Report Type is "Matchups" and file format is "JSON"
*/
const SOURCE_FILEPATH = "./prod.json";
const COLUMN_WEEK = "Week";
const COLUMN_TEAM_1 = "Team 1 Name";
const COLUMN_TEAM_2 = "Team 2 Name";
const COLUMN_TEAM_1_POINTS = "Team 1 Points";
const COLUMN_TEAM_2_POINTS = "Team 2 Points";

const HIGHEST_POINTS_PER_WEEK_PAYOUT = 30;

function createdSortedMapDesc(map) {
  return new Map([...map.entries()].sort((a, b) => b[1] - a[1]));
}

/*

    Highest points per week: $20/week/17 wk

    return {
        "<name>": "<money-paid>"
    }
*/
function calculateHighestPointsPerWeekPayouts(weekToHighestScoringTeamMap) {
  const nameToPayoutsMap = new Map();
  const weeklyHighestScoringTeams = Array.from(
    weekToHighestScoringTeamMap.values()
  );

  for (const { name } of weeklyHighestScoringTeams) {
    if (nameToPayoutsMap.has(name)) {
      let existingPayout = nameToPayoutsMap.get(name);
      existingPayout += HIGHEST_POINTS_PER_WEEK_PAYOUT;
      nameToPayoutsMap.set(name, existingPayout);
    } else {
      nameToPayoutsMap.set(name, HIGHEST_POINTS_PER_WEEK_PAYOUT);
    }
  }

  return nameToPayoutsMap;
}

/*
  Script starts here  
*/
const matchupData = JSON.parse(fs.readFileSync(SOURCE_FILEPATH, "utf8"));
const rowCount = matchupData[COLUMN_WEEK].length;

let teamToCurrentWinStreakMap = new Map();
let teamToWeeklyScoresMap = new Map();

let teamToLongestWinStreakMap = new Map();
let teamToTotalPointsMap = new Map();
let weekToHighestScoringTeamMap = new Map();
let ceilingWinner = {
  name: null,
  points: -1,
};
let weekCount = 0;
const survivorPool = new Set();

for (let i = 0; i < rowCount; i++) {
  const week = matchupData[COLUMN_WEEK][i];
  const firstTeam = matchupData[COLUMN_TEAM_1][i];
  const secondTeam = matchupData[COLUMN_TEAM_2][i];
  const firstTeamPoints = parseFloat(matchupData[COLUMN_TEAM_1_POINTS][i]);
  const secondTeamPoints = parseFloat(matchupData[COLUMN_TEAM_2_POINTS][i]);
  const winner = firstTeamPoints > secondTeamPoints ? firstTeam : secondTeam;
  const looser = firstTeamPoints < secondTeamPoints ? firstTeam : secondTeam;
  const winningScore =
    winner === firstTeam ? firstTeamPoints : secondTeamPoints;
  const firstTeamWeekData = {
    name: firstTeam,
    points: firstTeamPoints,
  };
  const secondTeamWeekData = {
    name: secondTeam,
    points: secondTeamPoints,
  };

  if (teamToCurrentWinStreakMap.has(winner)) {
    const currentWinStreak = teamToCurrentWinStreakMap.get(winner);
    teamToCurrentWinStreakMap.set(winner, currentWinStreak + 1);
  } else {
    teamToCurrentWinStreakMap.set(winner, 1);
  }
  if (teamToCurrentWinStreakMap.has(looser)) {
    const currentWinStreak = teamToCurrentWinStreakMap.get(looser);

    if (teamToLongestWinStreakMap.has(looser)) {
      const longestWinStreak = teamToLongestWinStreakMap.get(looser);
      if (currentWinStreak > longestWinStreak) {
        teamToLongestWinStreakMap.set(looser, currentWinStreak);
      }
    } else {
      teamToLongestWinStreakMap.set(looser, currentWinStreak);
    }

    teamToCurrentWinStreakMap.delete(looser);
  }

  for (const team of [firstTeamWeekData, secondTeamWeekData]) {
    const { name, points } = team;

    survivorPool.add(name);

    if (teamToTotalPointsMap.has(name)) {
      const totalPoints = teamToTotalPointsMap.get(name);
      const updatedTotalPoints = totalPoints + points;
      teamToTotalPointsMap.set(name, updatedTotalPoints);
    } else {
      teamToTotalPointsMap.set(name, points);
    }

    if (teamToWeeklyScoresMap.has(name)) {
      const currentWeeklyScoresList = teamToWeeklyScoresMap.get(name);
      const updatedWeeklyScoresList = currentWeeklyScoresList.concat([points]);
      teamToWeeklyScoresMap.set(name, updatedWeeklyScoresList);
    } else {
      teamToWeeklyScoresMap.set(name, [points]);
    }
  }

  if (weekToHighestScoringTeamMap.has(week)) {
    const currentHighestScoringTeam = weekToHighestScoringTeamMap.get(week);

    if (winningScore > currentHighestScoringTeam.points) {
      weekToHighestScoringTeamMap.set(week, {
        name: winner,
        points: winningScore,
      });
    }
  } else {
    weekToHighestScoringTeamMap.set(week, {
      name: winner,
      points: winningScore,
    });
  }

  if (
    !ceilingWinner.name ||
    (ceilingWinner.name && winningScore > ceilingWinner.points)
  ) {
    ceilingWinner = {
      name: winner,
      points: winningScore,
    };
  }

  weekCount = week;
}

for (const team of Array.from(teamToCurrentWinStreakMap.keys())) {
  const currentWinStreak = teamToCurrentWinStreakMap.get(team);
  const longestWinStreak = teamToLongestWinStreakMap.get(team);

  if (currentWinStreak > longestWinStreak || longestWinStreak === undefined) {
    teamToLongestWinStreakMap.set(team, currentWinStreak);
  }
}

for (let week = 0; week < weekCount && survivorPool.size > 1; week++) {
  let lowestScoringTeam = {
    points: -1,
    name: null,
  };
  const survivors = Array.from(survivorPool.values());

  for (const team of survivors) {
    const points = teamToWeeklyScoresMap.get(team)[week];

    if (!lowestScoringTeam.name || points < lowestScoringTeam.points) {
      lowestScoringTeam = {
        points: points,
        name: team,
      };
    }
  }

  survivorPool.delete(lowestScoringTeam.name);
}

console.log("Streak (Longest consecutive win streak)");
console.log("====================================================");
console.log(createdSortedMapDesc(teamToLongestWinStreakMap));
console.log("\n");
console.log(
  "Survivor (Every week the lowest-scoring team is eliminated. Winner is last one standing after week 11)"
);
console.log("====================================================");
console.log(survivorPool);
console.log("\n");
console.log("Highest total points in season");
console.log("====================================================");
console.log(createdSortedMapDesc(teamToTotalPointsMap));
console.log("\n");
console.log("Highest points per week");
console.log("====================================================");
console.log(weekToHighestScoringTeamMap);
console.log("\n");
console.log("\n");
console.log("====================");
console.log("== Highest points per week Payouts (in $) ==");
console.log("====================");
console.log(
  createdSortedMapDesc(
    calculateHighestPointsPerWeekPayouts(weekToHighestScoringTeamMap)
  )
);
console.log("\n");
console.log("Ceiling (Most points scored in a week/17 wk)");
console.log("====================================================");
console.log(ceilingWinner);
console.log("\n");