solutions.js

// task 1
const artist_totals = listeningData.reduce((acc, { artist, streams }) => {
  acc[artist] = (acc[artist] || 0) + streams;
  return acc;
}, {});

const task1_result = Object.entries(artist_totals).map(
  ([artist, totalStreams]) => {
    let tier;
    if (totalStreams >= 10000000) {
      tier = "Platinum";
    } else if (totalStreams >= 5000000) {
      tier = "Gold";
    } else {
      tier = "Silver";
    }
    return { artist, totalStreams, tier };
  },
);

const task1_answer = document.getElementById("task1Answer");
task1_answer.innerHTML = JSON.stringify(task1_result, null, 2);

// task 2
const genreAccumulator = listeningData.reduce((acc, song) => {
  if (
    !song ||
    typeof song.genre !== "string" ||
    typeof song.streams !== "number" ||
    typeof song.rating !== "number"
  )
    return acc;
  if (!acc[song.genre])
    acc[song.genre] = { sumStreams: 0, sumRatings: 0, count: 0 };
  acc[song.genre].sumStreams += song.streams;
  acc[song.genre].sumRatings += song.rating;
  acc[song.genre].count += 1;
  return acc;
}, {});

const task2_result = Object.keys(genreAccumulator).reduce((out, genre) => {
  const { sumStreams, sumRatings, count } = genreAccumulator[genre];
  const avgStreams = sumStreams / count;
  const avgRating = sumRatings / count;
  const engagementScore =
    Math.round((avgStreams / 1_000_000) * avgRating * 100) / 100;
  out[genre] = {
    avgStreams: Math.round(avgStreams),
    avgRating: Math.round(avgRating * 100) / 100,
    songCount: count,
    engagementScore,
  };
  return out;
}, {});

const task2_answer = document.getElementById("task2Answer");
task2_answer.innerHTML = JSON.stringify(task2_result, null, 2);

// task 3

const windowSize = 4;
let bestScore = -Infinity;
let bestStart = -1;
let bestWindow = [];

for (let i = 0; i <= listeningData.length - windowSize; i++) {
  let total = 0;
  let valid = true;
  const windowItems = [];

  for (let j = 0; j < windowSize; j++) {
    const item = listeningData[i + j];
    if (
      !item ||
      typeof item.streams !== "number" ||
      typeof item.rating !== "number"
    ) {
      valid = false;
      break;
    }
    total += item.streams / 1000 + item.rating * 500;
    windowItems.push(item); // store full song objects
  }

  if (!valid) continue;

  if (total > bestScore) {
    bestScore = total;
    bestStart = i;
    bestWindow = windowItems;
  }
}

const task3_result =
  bestStart === -1
    ? { startIndex: -1, endIndex: -1, songs: [], totalScore: 0 }
    : {
        startIndex: bestStart,
        endIndex: bestStart + windowSize - 1,
        songs: bestWindow,
        totalScore: Math.round(bestScore * 100) / 100,
      };

const task3_answer = document.getElementById("task3Answer");
task3_answer.innerHTML = JSON.stringify(task3_result, null, 2);

// task 4
const artist_genre_acc = listeningData.reduce((acc, song) => {
  if (
    !song ||
    typeof song.artist !== "string" ||
    typeof song.genre !== "string" ||
    typeof song.streams !== "number"
  ) {
    return acc;
  }

  const { artist, genre, streams } = song;
  if (!acc[artist]) acc[artist] = {};
  if (!acc[artist][genre]) acc[artist][genre] = { sumStreams: 0, count: 0 };
  acc[artist][genre].sumStreams += streams;
  acc[artist][genre].count += 1;

  return acc;
}, {});

const task4_result = Object.keys(artist_genre_acc)
  .map((artist) => {
    const genres_data = artist_genre_acc[artist];
    const genres = Object.keys(genres_data);
    const genre_averages = genres.map((genre) => {
      const { sumStreams, count } = genres_data[genre];
      return { genre: genre, avgStreams: sumStreams / count };
    });

    if (genres.length < 3) return null;

    let best = genre_averages[0];
    for (let i = 1; i < genre_averages.length; i++) {
      if (genre_averages[i].avgStreams > best.avgStreams) {
        best = genre_averages[i];
      }
    }

    return {
      artist,
      genres,
      genreCount: genres.length,
      bestGenre: best.genre,
      bestGenreAvgStreams: Math.round(best.avgStreams),
    };
  })
  .filter(Boolean)
  .sort(
    (a, b) =>
      b.genreCount - a.genreCount ||
      b.bestGenreAvgStreams - a.bestGenreAvgStreams,
  );

const task4_answer = document.getElementById("task4Answer");
task4_answer.innerHTML = JSON.stringify(task4_result, null, 2);

// task 5
const task5_result = listeningData
  .filter((song) => {
    if (
      !song ||
      typeof song.rating !== "number" ||
      typeof song.streams !== "number" ||
      typeof song.duration !== "number"
    ) {
      return false;
    }
    return (
      song.rating >= 4.3 &&
      song.streams >= 2000000 &&
      song.duration >= 180 &&
      song.duration <= 240
    );
  })
  .map((song) => {
    const qualityScore =
      Math.round(song.rating * 2 + (song.streams / 500000) * 100) / 100;
    return {
      title: song.title || null,
      artist: song.artist || null,
      qualityScore,
    };
  })
  .sort((a, b) => b.qualityScore - a.qualityScore)
  .slice(0, 10);

const task5_answer = document.getElementById("task5Answer");
task5_answer.innerHTML = JSON.stringify(task5_result, null, 2);