'use strict';

const fetch = require('node-fetch');

// In the real world here may be some function
// that is very complex and error prone!
const isJsonValidDangerous = (json) => json.ok === true;

const is4xx = (res) => 400 <= res.status && res.status < 500;
const reject4xxAsync = async (res) => {

  if (is4xx(res)) {
    return res.text()
      .then(
        (text) => {

          // Throwing error inside promise callback results in a promise rejection
          // with the thrown error as a rejected value.
          throw new Error(`${res.status}: ${text}`);
        },
      );
  }
  return res;
};
const reportErrorAsync = (err) => {

  console.log('Reporting error:', err);
  // This function always resolves, even if reporting fails.
  // Example of implementation:
  // return fetch(...)
  //   .catch((reportingErr) => {/* Show error to the user in a robust way. */})
  //   .catch(() => {/* Suppress. */});
  return Promise.resolve();
};

/*
==========================================
Way 1: .then(...) with the second argument
==========================================
Con: Doesn't handle all errors, see the comment below.
*/
const doesHaveValidJsonAsync1 = async (url) =>
  fetch(url)
    .then(reject4xxAsync)
    .then((res) => res.json())
    .then(
      isJsonValidDangerous, // May throw an error, which won't be handled!
      (err) => reportErrorAsync(err)
        .then(() => false), // After reporting we want to resolve with `false`.
    );

/*
==================
Way 2: .catch(...)
==================
Pro: Handles all errors.
*/
const doesHaveValidJsonAsync2 = async (url) =>
  fetch(url)
    .then(reject4xxAsync)
    .then((res) => res.json())
    .then(isJsonValidDangerous) // May throw an error, will be handled by the next line.
    .catch(
      (err) => reportErrorAsync(err)
        .then(() => false),
    );

/*
==============================================
Way 3.1: try...catch + many awaits - then(...)
==============================================
Con: Imperative code (vs. expressions) may be less composable (practical example needed).
Con: `await` may be not supported on your target browser in contrast to promises, which are older.
Pro: Some people find it easier to read compared to a chain of then/catch.
*/
const doesHaveValidJsonAsync3_1 = async (url) => {

  try {
    const res     = await fetch(url);
    const goodRes = await reject4xxAsync(res);
    const json    = await goodRes.json();
    return isJsonValidDangerous(json);
    // Or if you like nesting: return isJsonValidDangerous(await goodRes.json());
  } catch(err) {
    await reportErrorAsync(err);
    return false;
  }
};
/*
=================================================
Way 3.2: try...catch + mixing await and then(...)
=================================================
Pros & cons: See way 3.1.
Con: Some people advocate against mixing await and then/catch.
*/
const doesHaveValidJsonAsync3_2 = async (url) => {

  try {
    // At least one `await` is needed for a rejection to be thrown and caught by try...catch.
    const ifValid = await fetch(url)
      .then(reject4xxAsync)
      .then((res) => res.json())
      .then(isJsonValidDangerous);
    return ifValid;
    // A shorter variant: return await fetch(...)...
  } catch(err) {
    await reportErrorAsync(err);
    return false;
  }
};

(async () => {

  //=======
  // Tests
  //=======

  // For manual testing:
  /*
  { // <- namespace opens.
    const url = 'https://gist.githubusercontent.com/ilyaigpetrov/96a4491877f4bd14f95cf41134de1990/raw/f00434edd42b7029fec587507ec585e42930c730/zzz-test-ok.json';
    const ifValid = await doesHaveValidJsonAsync3_2(url);
    console.log(`${url} has`, ifValid ? 'valid json' : 'NO valid json');
  }
  */

  // Non-manual tests.
  const funcs = [
    doesHaveValidJsonAsync1,
    doesHaveValidJsonAsync2,
    doesHaveValidJsonAsync3_1,
    doesHaveValidJsonAsync3_2,
  ];
  const runTestAsync = async (testName, url, expected, message) => {

    console.log(`Test "${testName}" started.`);
    const promises = funcs.map(async (func) => {

      const actual = await func(url);
      console.assert(
        actual === expected,
        `${func.name}: ${message}`,
      );
    });
    await Promise.all(promises);
    console.log(`Test "${testName}" finished.\n`);
  };
  console.log(/* Empty line. */);

  // Test 1: Valid JSON
  const urlOk = 'https://gist.github.com/ilyaigpetrov/96a4491877f4bd14f95cf41134de1990/raw/3bbe333cecd0f17b1189e8ede558b69587d44269/zzz-test-1-ok.json';
  await runTestAsync(
    'Valid JSON',
    urlOk,
    true,
    '`true` must be returned for a valid JSON structure.',
  );

  // Test 2: Non Valid JSON
  const urlNotOk = 'https://gist.github.com/ilyaigpetrov/96a4491877f4bd14f95cf41134de1990/raw/3bbe333cecd0f17b1189e8ede558b69587d44269/zzz-test-2-not-ok.json';
  await runTestAsync(
    'Non Valid JSON',
    urlNotOk,
    false,
    '`false` must be returned for a non-valid JSON structure.',
  );

  // Test 3: 4xx
  await runTestAsync(
    '4xx',
    'https://httpstat.us/403',
    false,
    '`false` must be returned for 4xx.',
  );
})();