const chefs = [
  { name: 'jeff', min: 0, max: 20 },
  { name: 'nick', min: 5, max: 35 },
  { name: 'alexis', min: 0, max: 20 },
  { name: 'bob', min: 10, max: 30 },
  { name: 'will', min: 5, max: 65 },
  { name: 'alessandra', min: 15, max: 50 },
  { name: 'john', min: 0, max: 60 },
  { name: 'gideon', min: 5, max: 50 },
  { name: 'elaine', min: 15, max: 30 },
  { name: 'stefan', min: 0, max: 80 },
  { name: 'lloyd', min: 5, max: 35 },
  { name: 'theresa', min: 5, max: 35 },
  { name: 'ian', min: 0, max: 40 },
  { name: 'sarah', min: 0, max: 40 },
  { name: 'jason', min: 0, max: 40 },
  { name: 'bryan', min: 0, max: 30 },
  { name: 'cassie', min: 5, max: 60 },
  { name: 'rick', min: 0, max: 30 },
  { name: 'jess', min: 5, max: 40 },
  { name: 'brandon', min: 0, max: 45 }
];

const addCount = arr => arr.map(obj => Object.assign(obj, { count: 0 } ));

const handleError = (type, val) => {
  switch (type) {
    case 'UNFULFILLED':
      return console.log('Insufficient orders were received to fulfill all client minimum requirements.');
    case 'INVALID':
      return console.log('Invalid argument(s) passed for order count and/or array.');
    case 'SURPLUS':
      return console.log(`An order sum larger than what could be distributed was received. There are ${val} remaining orders to be filled.`);
  }
}

const fulfillMin = (arr, orders) => {
  let error;
  let ordersRemaining = arr.reduce((acc, curr) => {
    if (curr.min > 0 && acc > 0) {
      curr.count += curr.min;
      return acc -= curr.min;
    }
    return acc;
  }, orders);

  error = !ordersRemaining ? handleError('UNFULFILLED') : null;
  return [ arr, ordersRemaining, error ];
}

const assignOrders = (arr, ordersRemaining) => {
  var fulfilled = {};
  let accumulator = arr.reduce((acc, curr) => {
    if (curr.count < curr.max && acc - 1 > -1) {
      curr.count += 1;
      return --acc;
    } else if (curr.count === curr.max && !fulfilled[curr.name]) {
      fulfilled[curr.name] = true;
      return acc;
    }
    return acc;
  }, ordersRemaining);

  return [ accumulator, (Object.keys(fulfilled).length === arr.length) ];
}

const fulfillAll = args => {
  let [ arr, accumulator, error ] = args;
  if (error) return [ arr, accumulator, error ];

  let fulfilled = false;

  while (accumulator !== 0 && !fulfilled) {
    [ accumulator, fulfilled ] = assignOrders(arr, accumulator);
  }
  return accumulator ? [ arr, accumulator, handleError('SURPLUS', accumulator) ] : [ arr, accumulator ];
}

const calculateTotalOrdersAssigned = arr => {
  let sum = 0;
  for (let i = 0; i < arr.length; i++) {
    sum += arr[i].count;
  }
  return sum;
}

const delegateOrders = (arr, orders) => {
  if (!Array.isArray(arr) || orders < 1) return handleError('INVALID');

  let [ res, remainder, error ] = fulfillAll(fulfillMin(addCount(arr), orders));

  return error ? error : calculateTotalOrdersAssigned(res);
}

delegateOrders(chefs, 20); // min orders not fulfilled
delegateOrders(chefs, 601); // normal test case
delegateOrders(chefs, 852); // surplus of orders
delegateOrders({}, 315); // invalid array argument
delegateOrders(chefs, -2); // invalid order count