exports.getMtgSkTradersOffers = (req, res, next) => {
  const cardConditionsMap = {
    1: "MT",
    2: "NM",
    3: "EX",
    4: "GD",
    5: "LP",
    6: "PL",
    7: "PO"
  };

  const buildFilterObj = type => {
    let { language, condition, foil } = req.query;
    language = parseInt(language);
    condition = parseInt(condition);
    foil = parseInt(foil);

    let filterObj = {};

    if (type === "market") {
      if (condition) {
        filterObj["minCondition"] = cardConditionsMap[condition];
      }

      if (language) {
        filterObj["idLanguage"] = language;
      }

      if (foil) {
        filterObj["isFoil"] = foil === 1 ? true : false;
      }
    } else if (type === "local") {
      // metakoment:// tuna by v podstate mohol byt len else, ale pride mi ze to pomaha citatelnosti
      if (condition) {
        filterObj["condition"] = { $lte: condition };
      }
      if (language) {
        filterObj["language.idLanguage"] = language;
      }
      if (foil) {
        filterObj["isFoil"] = foil === 1 ? true : false;
      }
    }

    return filterObj;
  };

  const addPrintingInfoToArticle = (article, printing) => {
    //Local article has article.seller as string, market article has it in article.seller.username, we want string
    let seller = article.seller;
    if (typeof article.seller === "object") {
      seller = article.seller.username;
    }
    //Local article has condition as number, market article as string, we want string
    let condition = article.condition;
    if (typeof article.condition === "number") {
      condition = cardConditionsMap[condition];
    }
    return {
      ...article,
      name: printing.enName,
      expansion: printing.expansionName,
      seller,
      condition,
      rarity: printing.rarity,
      image: printing.image,
      website: printing.website
    };
  };

  const getMtgSkMarketTraders = () => {
    return new Promise((resolve, reject) => {
      User.find({ trading: true }, (err, users) => {
        if (err) reject(err);

        let traders = users.filter(user => user.trading === true);

        let marketTraderNames = [];

        traders.forEach(trader => {
          if (!trader.locally) marketTraderNames.push(trader.cardmarket);
        });

        resolve(marketTraderNames);
      });
    });
  };

  const getPrintingsFromCardmarket = cardName => {
    return new Promise((resolve, reject) => {
      Client.request("GET", "/ws/v2.0/output.json/products/find", {
        search: cardName
      })
        .then(marketResponse => {
          if (marketResponse.status !== 200)
            return next(["Na Cardmarkete sa nenašla táto karta."]);
          let marketResponseJson = JSON.parse(marketResponse.response);
          const printings = marketResponseJson.product;
          resolve(printings);
        })
        .catch(err => {
          reject(err);
        });
    });
  };

  const getCardmarketOffers = (printing, traders, filters) => {
    return new Promise((resolve, reject) => {
      Client.request(
        "GET",
        "/ws/v2.0/output.json/articles/" + printing.idProduct,
        { ...filters, start: 0, maxResults: 1000 }
      )
        .then(marketResponse => {
          if (!marketResponse.response) resolve([]); //If there is no response, there are no articles for given product, so we return empty array
          const marketResponseJson = JSON.parse(marketResponse.response);
          const articles = marketResponseJson.article;

          let mtgSkTradersArticles = articles.filter(article =>
            traders.includes(article.seller.username)
          );

          let mtgSkTradersOffers = mtgSkTradersArticles.map(article =>
            addPrintingInfoToArticle(article, printing)
          );
          resolve(mtgSkTradersOffers);
        })
        .catch(err => {
          reject(err);
        });
    });
  };

  const getLocalOffers = (printing, filters) => {
    return new Promise((resolve, reject) => {
      Article.find(
        { idProduct: printing.idProduct, ...filters },
        null,
        { lean: true }, //returns Object instead of Document
        (err, articles) => {
          if (err) return reject(err);

          let localOffers = articles.map(article =>
            addPrintingInfoToArticle(article, printing)
          );

          resolve(localOffers);
        }
      );
    });
  };

  /**
   * There are two types of traders on MtG.sk: local and market
   * Offers of local traders are stored in local database
   * Offers of market traders are fetched from Cardmarket API
   */
  const getAllOffersForPrinting = (printing, marketTraders) => {
    return new Promise((resolve, reject) => {
      let offersPromises = [
        getLocalOffers(printing, buildFilterObj("local")),
        getCardmarketOffers(printing, marketTraders, buildFilterObj("market"))
      ];

      Promise.all(offersPromises)
        .then(([localOffers, marketOffers]) =>
          resolve([...marketOffers, ...localOffers])
        )
        .catch(err => reject(err));
    });
  };

  let prereqPromises = [
    getMtgSkMarketTraders(),
    getPrintingsFromCardmarket(req.query.cardName)
  ];
  Promise.all(prereqPromises).then(([marketTraders, printings]) => {
    let printingOfferPromises = printings.map(printing => {
      return new Promise((resolve, reject) => {
        getAllOffersForPrinting(printing, marketTraders)
          .then(offers => resolve(offers))
          .catch(err => reject(err));
      });
    });

    Promise.all(printingOfferPromises)
      .then(listOfOffersPerPrinting => {
        let listOfAllOffers = listOfOffersPerPrinting.reduce(
          (acc, val) => acc.concat(val),
          []
        );

        res.send(listOfAllOffers);
      })
      .catch(err => {
        console.log(err);
        res.next(["Vyskytla sa chyba :("]);
      });
  });
};