/**
 * Создайте класс, обладающий следующим поведением:
 * const values = ['hello', 'javascript', 'world'];
 * const instances = values.map(str => new NumberAndString(str));
 *
 * const resultConcatenation = instances.join(' '); // == 'hello javascript world'
 * const resultCharCount = instances.reduce((obj, memo) => memo + obj, 0); // == 20
 *
 * Для реализации используйте протокол [Symbol.toPrimitive]
 * @class NumberAndString
 * @param {String} string value
 */
class NumberAndString {
  constructor(string) {
    this.string = string;
  }

  [Symbol.toPrimitive](hint = 'default') {
    return hint === 'string' ? this.string : this.string.length;
  }
}

/* ============================================= */

/**
 * Сделать функцию, которая reject'ит возвращаемый промис, передавая в качестве ошибки строку 'timeout_error',
 * если он не resolve'ится за указанный timeout, или ведет себя эквивалентно исходному.
 * В учебных целях для этой задачи просьба не использовать Promise.race.
 *
 * @param {Promise} promise исходный промис
 * @param {Number} timeoutInMilliseconds время для timeout в миллисекундах
 * @return {Promise} промис с нужным поведением
 */
function promiseTimeout(promise, timeoutInMilliseconds) {
  return new Promise((resolve, reject) => {
    setTimeout(() => reject(new Error('timeout_error')), timeoutInMilliseconds);
    promise.then(result => resolve(promise), error => reject(error));
  });
}

/* ============================================= */

/**
 * Реализовать функцию, поведение которой аналогично поведению Promise.all,
 * которая возвращает в качестве результата rejected промис c первым reject value или resolve с массивом resolveValues,
 * в соответствущих исходному массиву промисов позициях, если не было ни одного промиса с reject.
 * @param {Array<Promise>} promises - массив с исходными промисами
 * @return {Promise}
 */
function promiseAll(promises) {
  if (!Array.isArray(promises)) {
    throw new Error();
  }

  return new Promise((resolve, reject) => {
    let count = 0,
      res = [];

    if (promises.length === 0) {
      resolve([]);
    }
    for (let i = 0; i < promises.length; ++i) {
      if (promises[i].toString() !== Promise) {
        promises[i] = Promise.resolve(promises[i]);
      }
      promises[i].then(result => {
        count++;
        res[i] = result;
        if (count === promises.length) {
          resolve(res);
        }
      }).catch(error => reject(error));
    }
  });
}

/* ============================================= */

/**
 * Реализовать функцию, поведение которой аналогично поведению Promise.race,
 * которая возвращает в качестве результата промис c первым resolve value или reject value в массиве исходных промисов
 * @param {Array<Promise>} promises - массив с исходными промисами
 * @return {Promise}
 */
function promiseRace(promises) {
  return new Promise((resolve, reject) => {
    for (let i = 0; i < promises.length; ++i) {
      promises[i].then(result => resolve(result), error => reject(error));
    }
  });
}

/* ============================================= */

/**
 * Изменить поведение чисел таким образом, чтобы указанные конструкции были эквивалетны при условии,
 * что римские цифры могут быть любыми.
 * 0..V => [0, 1, 2, 3, 4]
 * 0..VII => [0, 1, 2, 3, 4, 5, 6]
 * 0..X => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 * Подсказка - необходимо использовать Proxy - объекты
 * */
function parseRomanNominal(number) {
  const fontArab = [0, 1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500,
    900, 1000, 4000, 5000, 9000, 10000];
  const fontRoman = ['0', 'I', 'IV', 'V', 'IX', 'X', 'XL', 'L', 'XC',
    'C', 'CD', 'D', 'CM', 'M', 'M&#8577;', '&#8577;', '&#8577;&#8578;', '&#8578;'];

  number = number.toUpperCase();
  let result = 0,
    posit = 0,
    n = fontArab.length - 1;

  while (n >= 0 && posit < number.length) {
    if (number.substr(posit, fontRoman[n].length) === fontRoman[n]) {
      result += fontArab[n];
      posit += fontRoman[n].length;
    } else { n--; }
  }
  return result;
}

const proxy = new Proxy(Number, {
  get(target, prop) {
    prop = parseRomanNominal(prop);
    return Array.from(Array(prop).keys());
  }
});

Object.setPrototypeOf(Number.prototype, proxy);

/* ============================================= */

function delayPromise(promise, timeout) {
  let resolveValue = null;
  let rejectValue = null;

  promise.then(
    value => { resolveValue = value; },
    err => { rejectValue = err; }
  );

  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (resolveValue !== null) {
        resolve(resolveValue);
      } else if (rejectValue !== null) {
        reject(rejectValue);
      } else {
        promise.then(resolve, reject);
      }
    }, timeout);
  });
}

module.exports = {
  NumberAndString,
  promiseTimeout,
  promiseAll,
  promiseRace,
  delayPromise
};