script.js

// script.js

// Data processing functions

function processTeamTypes(pokemonEntries) {
  const teamTypes = new Set();
  const teamWeaknesses = [];
  const teamResistances = new Set();
  const teamImmunities = new Set();
  const teamOffensiveStrengths = new Set();
  const pokemonWeaknesses = [];

  // Aggregate team data
  pokemonEntries.forEach((entry) => {
    const types = entry.types;
    const weaknessesSet = new Set();

    types.forEach((t) => {
      teamTypes.add(t);

      (typeWeaknesses[t] || []).forEach((w) => weaknessesSet.add(w));
      (typeResistances[t] || []).forEach((r) => teamResistances.add(r));
      (typeImmunities[t] || []).forEach((i) => teamImmunities.add(i));
      (typeStrengths[t] || []).forEach((s) => teamOffensiveStrengths.add(s));
    });

    pokemonWeaknesses.push(weaknessesSet);
    teamWeaknesses.push(weaknessesSet);
  });

  const allTeamWeaknesses = [];
  teamWeaknesses.forEach((weakSet) => weakSet.forEach((w) => allTeamWeaknesses.push(w)));

  const coveredTypesDefensively = new Set([...teamResistances, ...teamImmunities]);
  const adjustedWeaknessesDefensive = [...new Set(allTeamWeaknesses)].filter(
    (w) => !coveredTypesDefensively.has(w)
  );

  const adjustedWeaknesses = adjustedWeaknessesDefensive.filter(
    (w) => !teamOffensiveStrengths.has(w)
  );

  const recommend = pokemonEntries.length < 3;

  let allRecommendedTypes = recommendTypes(
    new Set(adjustedWeaknesses),
    teamTypes,
    teamWeaknesses,
    teamResistances,
    teamImmunities,
    teamOffensiveStrengths,
    pokemonWeaknesses
  );

  console.log("All recommended types before filtering:", allRecommendedTypes);

  const safeRecommendations = [];
  const riskyRecommendations = [];

  allRecommendedTypes.forEach((rec) => {
    const weaknessesOfType = typeWeaknesses[rec.type] || [];
    const coversWeakness = weaknessesOfType.some((w) => teamOffensiveStrengths.has(w));
    // Synergistic only if: covers at least one of its own weaknesses AND doesn't worsen net weaknesses
    const isSynergistic = coversWeakness && rec.weaknessChange <= 0;

    if (isSynergistic) {
      safeRecommendations.push(rec);
    } else {
      riskyRecommendations.push(rec);
    }
  });

  console.log("Safe recommendations:", safeRecommendations);
  console.log("Risky recommendations:", riskyRecommendations);

  return {
    teamTypes: Array.from(teamTypes),
    adjustedWeaknessesDefensive,
    teamOffensiveStrengths: Array.from(teamOffensiveStrengths),
    adjustedWeaknesses,
    recommendedTypes: recommend ? safeRecommendations : [],
    alternativeTypes: recommend ? riskyRecommendations : [],
    recommend,
    pokemonEntries,
    grade: pokemonEntries.length === 3 ? calculateGrade(adjustedWeaknesses.length) : null,
    sharedWeaknesses: findSharedWeaknesses(pokemonWeaknesses),
  };
}

function recommendTypes(
  adjustedWeaknessesSet,
  teamTypes,
  teamWeaknesses,
  teamResistances,
  teamImmunities,
  teamOffensiveStrengths,
  pokemonWeaknesses
) {
  const recommended = [];
  const originalAdjustedWeaknesses = Array.from(adjustedWeaknessesSet);
  const allTypes = Object.keys(typeStrengths);

  // Precompute current team weakness counts to assess shared changes
  const teamWeaknessCounts = {};
  teamWeaknesses.forEach((weakSet) => {
    weakSet.forEach((w) => {
      teamWeaknessCounts[w] = (teamWeaknessCounts[w] || 0) + 1;
    });
  });

  allTypes.forEach((type) => {
    if (teamTypes.has(type)) return;

    // Must cover at least one adjusted weakness
    const coverage = (typeStrengths[type] || []).filter((s) => adjustedWeaknessesSet.has(s)).length;
    if (coverage === 0) return;

    // Simulate adding the type
    const newTeamTypes = new Set([...teamTypes, type]);
    const newAdjustedWeaknesses = getAdjustedWeaknesses(newTeamTypes);

    const weaknessChange = newAdjustedWeaknesses.length - originalAdjustedWeaknesses.length;
    const finalWeakLen = newAdjustedWeaknesses.length; // how many adjusted weaknesses after adding this type

    const newTypeWeaknesses = new Set(typeWeaknesses[type] || []);

    // How many weaknesses would become "shared" (count 1 -> 2) if we add this type?
    let sharedIncrease = 0;
    for (const w of newTypeWeaknesses) {
      if ((teamWeaknessCounts[w] || 0) === 1) sharedIncrease += 1;
    }

    // Hard guard: if it worsens an ALREADY shared weakness (>=2), skip entirely
    for (const w of newTypeWeaknesses) {
      if ((teamWeaknessCounts[w] || 0) >= 2) {
        return;
      }
    }

    recommended.push({ type, coverage, weaknessChange, sharedIncrease, finalWeakLen });
  });

  // Sort so Bug > Fire > Ice in Electric+Water:
  //  - S (finalWeakLen 0) before A (1)
  //  - fewer new shared weaknesses first
  //  - better net change
  //  - more coverage
  //  - alpha
  recommended.sort(
    (a, b) =>
      a.finalWeakLen - b.finalWeakLen ||
      (a.sharedIncrease ?? 0) - (b.sharedIncrease ?? 0) ||
      a.weaknessChange - b.weaknessChange ||
      b.coverage - a.coverage ||
      a.type.localeCompare(b.type)
  );

  return recommended;
}

function getAdjustedWeaknesses(teamTypes) {
  const teamWeaknesses = new Set();
  const teamResistances = new Set();
  const teamImmunities = new Set();
  const teamOffensiveStrengths = new Set();

  teamTypes.forEach((t) => {
    (typeWeaknesses[t] || []).forEach((w) => teamWeaknesses.add(w));
    (typeResistances[t] || []).forEach((r) => teamResistances.add(r));
    (typeImmunities[t] || []).forEach((i) => teamImmunities.add(i));
    (typeStrengths[t] || []).forEach((s) => teamOffensiveStrengths.add(s));
  });

  const coveredTypesDefensively = new Set([...teamResistances, ...teamImmunities]);
  const adjustedWeaknessesDefensive = [...teamWeaknesses].filter(
    (w) => !coveredTypesDefensively.has(w)
  );

  return adjustedWeaknessesDefensive.filter((w) => !teamOffensiveStrengths.has(w));
}

function findSharedWeaknesses(pokemonWeaknesses) {
  const weaknessCount = {};
  pokemonWeaknesses.forEach((weaknesses) => {
    weaknesses.forEach((w) => {
      weaknessCount[w] = (weaknessCount[w] || 0) + 1;
    });
  });
  return Object.keys(weaknessCount).filter((w) => weaknessCount[w] >= 2);
}

function calculateGrade(numWeaknesses) {
  if (numWeaknesses === 0) return "S";
  if (numWeaknesses === 1) return "A";
  if (numWeaknesses === 2) return "B";
  if (numWeaknesses === 3) return "C";
  return "D";
}

document.addEventListener("DOMContentLoaded", () => {
  const typesForm = document.getElementById("types-form");
  const validTypesDiv = document.getElementById("valid-types");
  const errorMessageDiv = document.getElementById("error-message");
  const resultsDiv = document.getElementById("results");

  validTypesDiv.textContent = `Valid types are: ${Object.keys(typeWeaknesses).sort().join(", ")}`;

  typesForm.addEventListener("submit", (e) => {
    e.preventDefault();
    errorMessageDiv.innerHTML = "";
    resultsDiv.innerHTML = "";

    const pokemonEntries = [];
    for (let i = 1; i <= 3; i++) {
      const typeInput = document.getElementById(`types${i}`).value;
      if (typeInput) {
        const types = typeInput
          .split(",")
          .map((t) => t.trim().charAt(0).toUpperCase() + t.trim().slice(1).toLowerCase())
          .filter((t) => t);

        const invalidTypes = types.filter((t) => !Object.keys(typeWeaknesses).includes(t));
        if (invalidTypes.length > 0) {
          const alertDiv = document.createElement("div");
          alertDiv.className = "alert alert-danger";
          alertDiv.textContent = `Invalid types entered: ${invalidTypes.join(", ")}`;
          errorMessageDiv.appendChild(alertDiv);
          return;
        }

        pokemonEntries.push({ types });
      }
    }

    if (pokemonEntries.length === 0) {
      const alertDiv = document.createElement("div");
      alertDiv.className = "alert alert-danger";
      alertDiv.textContent = "No types entered.";
      errorMessageDiv.appendChild(alertDiv);
      return;
    }

    const result = processTeamTypes(pokemonEntries);
    displayResults(result);
  });

  function displayResults(result) {
    resultsDiv.innerHTML = "";

    const headings = [
      "Your Team's Types:",
      "Weaknesses (Defensive):",
      "Offensive Strengths:",
      "Adjusted Weaknesses (After Offensive Coverage):",
    ];

    const data = [
      result.teamTypes,
      result.adjustedWeaknessesDefensive,
      result.teamOffensiveStrengths,
      result.adjustedWeaknesses,
    ];

    if (result.recommend) {
      headings.push("Recommended Types (Synergistic):");
      data.push(result.recommendedTypes);

      if (result.alternativeTypes.length > 0) {
        headings.push("Alternative Suggestions (Use with Caution):");
        data.push(result.alternativeTypes);
      }
    }

    if (result.grade !== null) {
      headings.push("Team Grade:");
      data.push(result.grade);
    }

    headings.forEach((headingText, index) => {
      const heading = document.createElement("h3");
      heading.textContent = headingText;
      resultsDiv.appendChild(heading);

      const paragraph = document.createElement("p");
      const value = data[index];

      if (Array.isArray(value)) {
        if (value.length > 0) {
          const list = document.createElement("ul");
          value.forEach((item) => {
            const listItem = document.createElement("li");
            listItem.textContent = item.type ? `${item.type} (${item.coverage})` : item;

            if (headingText.includes("Alternative")) {
              listItem.style.color = "orange";
            } else if (headingText.includes("Recommended")) {
              listItem.style.color = "green";
            }

            list.appendChild(listItem);
          });
          paragraph.appendChild(list);

          if (headingText.includes("Alternative")) {
            const note = document.createElement("small");
            note.style.color = "orange";
            note.textContent = "⚠️ These types may open new weaknesses that your team cannot currently counter.";
            paragraph.appendChild(note);
          }
        } else {
          paragraph.textContent = "None";
        }
      } else if (value) {
        paragraph.textContent = Array.isArray(value) ? value.join(", ") : value;

        // 🎉 Confetti trigger for S grade
        if (headingText === "Team Grade:" && value === "S" && typeof confetti === "function") {
          const duration = 2000;
          const animationEnd = Date.now() + duration;
          const colors = ["#FF0000", "#FFA500", "#FFFF00", "#00FF00", "#00FFFF", "#0000FF", "#FF00FF"];

          (function frame() {
            confetti({
              particleCount: 50,
              spread: 120,
              startVelocity: 30,
              decay: 0.9,
              colors: colors,
              origin: { x: Math.random(), y: 0.5 + Math.random() * 0.5 },
            });
            if (Date.now() < animationEnd) requestAnimationFrame(frame);
          })();
        }
      } else {
        paragraph.textContent = "None";
      }

      resultsDiv.appendChild(paragraph);
    });

    if (result.sharedWeaknesses && result.sharedWeaknesses.length > 0) {
      const warningHeading = document.createElement("h3");
      warningHeading.textContent = "Warning:";
      resultsDiv.appendChild(warningHeading);

      const warningParagraph = document.createElement("p");
      warningParagraph.style.color = "red";
      warningParagraph.textContent = `Two or more of your Pokémon are weak to the following types: ${result.sharedWeaknesses.join(", ")}`;
      resultsDiv.appendChild(warningParagraph);
    }
  }
});