const NUM_TRANS_PARTS = 10;
const REIGNS_SUPREME = new Set([
  'Optimus Prime',
  'Predaking',
]);

const TEAMS = new Map([
  ['D', 'Decepticons'],
  ['A', 'Autobots'],
]);

/////

let sampleInput = [
  'Soundwave, D, 8,9,2,6,7,5,6,10',
  'Bluestreak, A, 6,6,7,9,5,2,9,7',
  'Hubcap, A, 4,4,4,4,4,4,4,4',
];

let withOptimus = [
  'Optimus Prime, A, 10,10,8,10,10,10,8,10',
  'Soundwave, D, 8,9,2,6,7,5,6,10',
]

let cataclysmBattle = [
  'Optimus Prime, A, 10,10,8,10,10,10,8,10',
  'Predaking, D, 10, 5, 0, 8,7, 9, 9, 8',
  'Soundwave, D, 8,9,2,6,7,5,6,10',
  'Bluestreak, A, 6,6,7,9,5,2,9,7',
  'Hubcap, A, 4,4,4,4,4,4,4,4',
];

let largeBattle = [
  'Optimus Prime, A, 10,10,8,10,10,10,8,10',
  'Predakung, D, 10, 5, 0, 8,7, 9, 9, 8',
  'Soundwave, D, 8,9,2,6,7,5,6,10',
  'Bluestreak, A, 6,6,7,9,5,2,9,7',
  'Hubcap, A, 4,4,4,4,4,4,4,4',
]

/////
console.log(run(largeBattle));
console.log(run(sampleInput));
console.log(run(cataclysmBattle));

/**
 * This function is the entry point
 * @param  {Array} battleInput  array of strings describing the contestants
 * @return {String}             results
 */
function run(battleInput) {
  let transformers = sortTransformers(makeTransformers(battleInput));
  let teams        = makeTeams(transformers);
  let matchups     = createMatchups(teams);

  let willHaveCataclysm = matchups.reduce(findCataclysm, false);

  if(willHaveCataclysm) {
    return `All transformers destroyed`;
  }

  let results      = matchups.map(fight);
  let destroyed    = results.reduce(findDestroyed, []);
  let alive        = transformers.filter(stillAlive(destroyed));
  let teamResults  = getTeamResults(makeTeams(destroyed));
  let aliveByTeam  = makeTeams(alive);

  return [
    matchups.length == 1 ? '1 battle' : `${matchups.length} battles`,
    teamResults ? `Winning team (${TEAMS.get(teamResults.winner)}): ${teams[teamResults.winner].map(getName).join(', ')}` : 'Battle draw',
    teamResults
      ? `Survivors from the losing team (${TEAMS.get(teamResults.loser)}): ${aliveByTeam[teamResults.loser].map(getName).join(', ')}`
      : `Survivors: ${alive.map(getNameTeam).join(', ')}, Deaders: ${destroyed.map(getNameTeam).join(', ')}`,
  ].join('\n')
}

//// HELPERS

function makeTransformers(input) {
  return Array.isArray(input)
    ? input.map(makeTransformer)
           .filter(Boolean)
    : [];
}

/**
 * Creates a transformer object from an input string
 * @param  {String} input
 * @return {Object}
 */
function makeTransformer(input) {
  let parts = input.split(',')
                   .filter(Boolean)
                   .map((part) => part.trim());
  if(parts.length !== NUM_TRANS_PARTS) { return; }

  let [name, team, ...stats] = parts,
      [strength, intelligence, speed, endurance, rank, courage, firepower, skill] = stats.map(parseFloat);

  return {
    name, team, strength, intelligence, speed, endurance, rank, courage, firepower, skill,
    rating: strength + intelligence + speed + endurance + firepower,
    isSupreme: REIGNS_SUPREME.has(name),
  };
}

function sortTransformers(transformers) {
  return transformers.sort((transA, transB) => {
    let {rankA} = transA,
        {rankB} = transB;

    return rankA - rankB;
  })
}

function makeTeams(transformers) {
  return transformers.reduce((teams, transformer) => {
    teams[transformer.team].push(transformer);
    return teams;
  }, {A: [], D:[]})
}

function createMatchups({D, A}) {
  let numDecep = D.length;
  let numAuto  = A.length;
  let largestTeam  = numAuto > numDecep ? A : D;
  let smallestTeam = numAuto > numDecep ? D : A;

  return largestTeam.reduce((fights, fighterA, index) => {
    let fighterB = smallestTeam[index];

    if(!fighterB) {
      return fights;
    };

    return [...fights, [fighterA, fighterB]];
  }, [])
}

/**
 * The function that actually makes them compete
 * @param  {Object} [transformerA
 * @param  {Object} transformerB]
 * @return {Object}               results from the fight
 */
function fight([transformerA, transformerB]) {
  let transASupreme = transformerA.isSupreme,
      transBSupreme = transformerB.isSupreme;

  if(transASupreme) { return aWins(); }
  if(transBSupreme) { return bWins(); }

  let courageDiff  = transformerA.courage  - transformerB.courage;
  let strengthDiff = transformerA.strength - transformerB.strength;


  if((courageDiff > 3) && (strengthDiff > 2)) {
    return aWins();
  }

  if((courageDiff < -3) && (strengthDiff < -2)) {
    return bWins();
  }

  let skillDiff    = transformerA.skill    - transformerB.skill;

  if((skillDiff > 2)) {
    return aWins();
  }

  if((skillDiff < -2)) {
    return bWins();
  }

  let ratingDiff   = transformerA.rating   - transformerB.rating;

  if(ratingDiff != 0) {
    return ratingDiff > 0
      ? aWins()
      : bWins();
  }

  return {destroyed: [transformerA, transformerB]};

  function aWins() {
    return {
      alive: [transformerA],
      destroyed: [transformerB]
    };
  }

  function bWins() {
    return {
      alive: [transformerB],
      destroyed: [transformerA]
    }
  }
}

function findDestroyed(memo, {destroyed}) {
  return memo.concat(destroyed);
}

function stillAlive(destroyed) {
  return (transformer) => {
    return destroyed.indexOf(transformer) == -1;
  }
}

/**
 * Finds out if Optimus Primer or Predaking are about to fight in a battle
 * @param  {Boolean} hadCataclysm
 * @param  {Object} [transformerA
 * @param  {Object} transformerB]
 * @return {Boolean}
 */
function findCataclysm(hadCataclysm, [transformerA, transformerB]) {
  let transASupreme = transformerA.isSupreme,
      transBSupreme = transformerB.isSupreme;

  return hadCataclysm || (transformerA && transBSupreme);
}

/**
 * Determines which, if any, team won
 * @param  {Array} options.D  array of destroyed decepticons
 * @param  {Array} options.A  array of destroyed autobots
 * @return {Object|undefined}
 */
function getTeamResults({D, A}) {
  if(D.length === A.length) { return; }
  return D.length < A.length
    ? {winner: 'D', loser: 'A'}
    : {winner: 'A', loser: 'D'};
}

function getName({name}) {
  return name;
}

function getNameTeam({name, team}) {
  return `${name}(${team})`;
}