const request = require("request");
const util = require("util");
const rp = util.promisify(request);
const sleep = util.promisify(setTimeout);
const cheerio = require('cheerio');
const { URL } = require('url');

let seenLinks = {};
let rootNode = {};
let currentNode = {};
let linksQueue = [];
let printList = [];
let previousDepth = 0;
let maxCrawlingDepth = 5;
let options = null;
let mainDomain = null;
let mainParsedUrl = null;

class CreateLink {
  constructor(linkURL, depth, parent) {
    this.url = linkURL;
    this.depth = depth;
    this.parent = parent;
    this.children = [];
  }
}

// ваши учетные данные для ScrapingBot
let username = "yourUsername",
  apiKey = "yourApiKey",
  apiEndPoint = "http://api.scraping-bot.io/scrape/raw-html",
  auth = "Basic " + Buffer.from(username + ":" + apiKey).toString("base64");

let requestOptions = {
  method: 'POST',
  url: apiEndPoint,
  json: {
    url: "this will be replaced in the findLinks function", // опции ScrapingBot
    options: {
      useChrome: false, // если вы хотите использовать безголовый Chrome, ВНИМАНИЕ, для этой опции будет использоваться два вызова API
      premiumProxy: false, // если вы хотите использовать премиум-прокси для разблокировки Amazon, LinkedIn (потребуется 10 вызовов)
    }
  },
  headers: {
    Accept: 'application/json',
    Authorization: auth
  }
}

// Запуск приложения, здесь вы должны указать адрес, с которого хотите начать сканирование
// второй параметр - это глубина, с 1 он будет сканировать все ссылки, найденные на первой странице, но не находить ссылки на других страницах
// если вы установите 2, он будет сканировать все ссылки на первой странице и все ссылки на страницах второго уровня, будьте осторожны с этим на огромном веб-сайте, это будет представлять огромное количество страниц для сканирования
// рекомендуется ограничить до 5 уровней
crawlBFS("https://www.scraping-bot.io/", 1);

async function crawlBFS(startURL, maxDepth = 5) {
  try {
    mainParsedUrl = new URL(startURL);
  } catch (e) {
    console.log("URL is not valid", e);
    return;
  }
  mainDomain = mainParsedUrl.hostname;
  maxCrawlingDepth = maxDepth;
  startLinkObj = new CreateLink(startURL, 0, null);
  rootNode = currentNode = startLinkObj;
  addToLinkQueue(currentNode);
  await findLinks(currentNode);
}

async function findLinks(linkObj) {
  requestOptions.json.url = linkObj.url;
  console.log("Scraping URL : " + linkObj.url);
  let response;
  try {
    response = await rp(requestOptions);
    if (response.statusCode !== 200) {
      if (response.statusCode === 401 || response.statusCode === 405) {
        console.log("autentication failed check your credentials");
      } else {
        console.log("an error occurred check the URL" + response.statusCode, response.body);
      }
      return;
    }
    let $ = cheerio.load(response.body);
    let links = $('body').find('a').filter(function (i, el) {
      return $(this).attr('href') != null;
    }).map(function (i, x) {
      return $(this).attr('href');
    });

    if (links.length > 0) {
      links.map(function (i, x) {
        let reqLink = checkDomain(x);
        if (reqLink) {
          if (reqLink != linkObj.url) {
            newLinkObj = new CreateLink(reqLink, linkObj.depth + 1, linkObj);
            addToLinkQueue(newLinkObj);
          }
        }
      });
    } else {
      console.log("No more links found for " + requestOptions.url);
    }

    let nextLinkObj = getNextInQueue();
    if (nextLinkObj && nextLinkObj.depth <= maxCrawlingDepth) {
      let minimumWaitTime = 500; // полсекунды
      let maximumWaitTime = 5000; // максимум пять секунд
      let waitTime = Math.round(minimumWaitTime + (Math.random() * (maximumWaitTime - minimumWaitTime)));
      console.log("wait for " + waitTime + " milliseconds");
      await sleep(waitTime);
      await crawl(nextLinkObj);
    } else {
      setRootNode();
      printTree();
    }
  } catch (err) {
    console.log("Something Went Wrong...", err);
  }
}

function setRootNode() {
  while (currentNode.parent != null) {
    currentNode = currentNode.parent;
  }
  rootNode = currentNode;
}

function printTree() {
  addToPrintDFS(rootNode);
  console.log(printList.join("\n|"));
}

function addToPrintDFS(node) {
  let spaces = Array(node.depth * 3).join("-");
  printList.push(spaces + node.url);
  if (node.children) {
    node.children.map(function (i, x) {
      {
        addToPrintDFS(i);
      }
    });
  }
}

function checkDomain(linkURL) {
  let parsedUrl;
  let fullUrl = true;
  try {
    parsedUrl = new URL(linkURL);
  } catch (error) {
    fullUrl = false;
  }
  if (fullUrl === false) {
    if (linkURL.indexOf("/") === 0) {
      return mainParsedUrl.protocol + "//" + mainParsedUrl.hostname + linkURL.split("#")[0];
    } else if (linkURL.indexOf("#") === 0) {
      return;
    } else {
      let path = currentNode.url.match('.*\/')[0];
      return path + linkURL;
    }
  }
  let mainHostDomain = parsedUrl.hostname;
  if (mainDomain == mainHostDomain) {
    parsedUrl.hash = "";
    return parsedUrl.href;
  } else {
    return;
  }
}

function addToLinkQueue(linkobj) {
  if (!linkInSeenListExists(linkobj)) {
    if (linkobj.parent != null) {
      linkobj.parent.children.push(linkobj);
    }
    linksQueue.push(linkobj);
    addToSeen(linkobj);
  }
}

function getNextInQueue() {
  let nextLink = linksQueue.shift();
  if (nextLink && nextLink.depth > previousDepth) {
    previousDepth = nextLink.depth;
    console.log(`------- CRAWLING ON DEPTH LEVEL ${previousDepth} --------`);
  }
  return nextLink;
}

function peekInQueue() {
  return linksQueue[0];
}

function addToSeen(linkObj) {
  seenLinks[linkObj.url] = linkObj;
}

function linkInSeenListExists(linkObj) {
  return seenLinks[linkObj.url] == null ? false : true;
}