// Нужно найти путь из  start -> end
// На вход подается функция  fetchTicket(from): Promise<string[]> - возвращает достижимые вершины
// Нельзя использовать async/await и генераторы
// Пример данных
const paths = {
  'A': ['B'],
  'B': ['C'],
  'C': ['D', 'A'],
  'D': ['B'],
}

// Функция полученния данных
function fetchTicket(from) {
  return new Promise((resolve) => resolve(paths[from]));
}

// Цикл на промисах
function loop(promise, step) {
  return promise.
    then(step)
    .then((stepResult) => {
      return !stepResult.done ? loop(Promise.resolve(stepResult.state), step) : stepResult.state;
    })
}

function bfsPromise (fetchData, start, end) {
  const q = [start];
  const visited = {};
  const parent = [];
  parent[start] = null;

  const startState = {
    q,
    visited,
    fetchData,
    parent,
    end,
    start,
  };

  // Шаг одного цикла
  const step = (state) => {
    if (state.q.length === 0) {
      return {
        done: true,
        state,
      }
    }

    const current = state.q.pop();

    return fetchData(current)
      .then((nodes) => {
        nodes.forEach((node) => {
          if (node === state.end || visited[node]) {
            if (node === state.end) {
              state.parent[node] = current;
              state.q = [];
            }

            return;
          }

          visited[node] = true;
          state.parent[node] = current;
          state.q.push(node);
        });

        return {
          done: false,
          state,
        }
      });
  }

  return loop(Promise.resolve(startState), step);
}

function buildPath(statePromise) {
  return statePromise.then((state) => {
    state.q = null;
    state.visited = null;
    const result = [];

    let node = state.end;
    let path = [node];
    let isContainStart = false;

    while(state.parent[node]) {
      node = state.parent[node];

      isContainStart = node === state.start;
      path.push(node);
    }

    if (!isContainStart) {
      return 'no way';
    }

    // Очень долгая операция
    return path.reverse();
  });
}

// Функция решения
function solve (start, end, fetchFlights) {
  if (start === end) {
    return Promise.resolve([start]);
  }

  return buildPath(bfsPromise(fetchFlights, start, end));
}

// пример работы
solve('A', 'C', fetchTicket).then(console.log);