10. Game Of Epicness

function solve(inputGenerals, battles) {
  const getKingdoms = () => {
    const kingdoms = new Map();

    inputGenerals.forEach((line) => {
      let currentKingdom = kingdoms.get(line.kingdom);
      if (!currentKingdom) {
        kingdoms.set(line.kingdom, []);
        currentKingdom = kingdoms.get(line.kingdom);
      }

      let currentGeneral = currentKingdom.filter((g) => g.general === line.general)[0];
      if (!currentGeneral) {
        currentGeneral = {
          general: line.general,
          army: line.army,
          kingdom: line.kingdom,
          wins: 0,
          loses: 0,
        };

        currentKingdom.push(currentGeneral);
      } else {
        currentGeneral.army += line.army;
      }
    });

    return kingdoms;
  };

  const kingdoms = getKingdoms();

  const getGeneral = (kingdomName, generalName) => {
    const currentKingdom = kingdoms.get(kingdomName);
    if (!currentKingdom) {
      return null;
    }

    const general = currentKingdom.filter((g) => g.general === generalName);
    if (general.length === 0) {
      return null;
    }

    return general[0];
  };


  for (let i = 0; i < battles.length; i++) {
    const attacker = getGeneral(battles[i][0], battles[i][1]);
    const defender = getGeneral(battles[i][2], battles[i][3]);

    if (attacker === null
      || defender === null
      || attacker.kingdom === defender.kingdom
      || attacker.army === defender.army) {
      continue;
    }

    if (attacker.army > defender.army) {
      attacker.wins++;
      attacker.army = Math.floor(attacker.army * 1.10);
      defender.loses++;
      defender.army = Math.floor(defender.army * 0.90);
    } else {
      defender.wins++;
      defender.army = Math.floor(defender.army * 1.10);
      attacker.loses++;
      attacker.army = Math.floor(attacker.army * 0.90);
    }
  }

  // printing
  const [winningKingdom, winningGenerals] = [...kingdoms]
    .sort((a, b) => {
      // Kingdom Wins Descending
      const secondWins = b[1].map((g) => g.wins).reduce((g1, g2) => g1 + g2);
      const firstWins = a[1].map((g) => g.wins).reduce((g1, g2) => g1 + g2);
      const winsDiff = secondWins - firstWins;

      if (winsDiff !== 0) {
        return winsDiff;
      }

      // Kingdom Loses Ascending
      const firstLosses = a[1].map((g) => g.loses).reduce((g1, g2) => g1 + g2);
      const secondLosses = b[1].map((g) => g.loses).reduce((g1, g2) => g1 + g2);
      const lossesDif = firstLosses - secondLosses;
      if (lossesDif !== 0) {
        return lossesDif;
      }

      // Kingdom Name Ascending Alphabetical
      return a[0].localeCompare(b[0]);
    })[0];

  let result = `Winner: ${winningKingdom}\n`;
  winningGenerals
    .sort((a, b) => b.army - a.army)
    .forEach((el) => {
      result += `/\\general: ${el.general}\n`
          + `---army: ${el.army}\n`
          + `---wins: ${el.wins}\n`
          + `---losses: ${el.loses}\n`;
    });

  console.log(result.trim());
}