/* Pick up THEME_DIR as parameter passed in */
var THEME_DIR = $("[data-themedir]").first().attr("data-themedir");

(function ($) {
  var queryParser = function (a) {
    var i,
      p,
      b = {};
    if (a === "") {
      return {};
    }
    for (i = 0; i < a.length; i += 1) {
      p = a[i].split("=");
      if (p.length === 2) {
        b[p[0]] = decodeURIComponent(p[1].replace(/\+/g, " "));
      }
    }
    return b;
  };
  $.queryParams = function () {
    return queryParser(window.location.search.substr(1).split("&"));
  };
  $.hashParams = function () {
    return queryParser(window.location.hash.substr(1).split("&"));
  };

  window.Swiftype = window.Swiftype || {};
  Swiftype.root_url = Swiftype.root_url || "https://api.swiftype.com";
  Swiftype.pingUrl = function (endpoint, callback) {
    var to = setTimeout(callback, 350);
    var img = new Image();
    img.onload = img.onerror = function () {
      clearTimeout(to);
      callback();
    };
    img.src = endpoint;
    return false;
  };
  Swiftype.pingSearchResultClick = function (engineKey, docId, callback) {
    var params = {
      t: new Date().getTime(),
      engine_key: engineKey,
      doc_id: docId,
      q: Swiftype.currentQuery,
    };
    var url =
      Swiftype.root_url + "/api/v1/public/analytics/pc?" + $.param(params);
    Swiftype.pingUrl(url, callback);
  };

  $.fn.swiftypeSearch = function (options) {
    var options = $.extend({}, $.fn.swiftypeSearch.defaults, options);

    return this.each(function () {
      var $this = $(this);
      var config = $.meta ? $.extend({}, options, $this.data()) : options;
      $this.data("swiftype-config-search", config);

      $this.selectedCallback = function (data) {
        return function (e) {
          var $el = $(this);
          e.preventDefault();
          Swiftype.pingSearchResultClick(
            config.engineKey,
            data["id"],
            function () {
              config.onComplete($el);
            }
          );
        };
      };

      $this.registerResult = function ($element, data) {
        $element.data("swiftype-item", data);
        $("a", $element).click($this.selectedCallback(data));
      };

      $this.getContentCache = function () {
        return $("#" + contentCacheId);
      };

      var $resultContainer = $(config.resultContainingElement),
        initialContentOfResultContainer = $resultContainer.html(),
        contentCacheId = "st-content-cache",
        $contentCache = $this.getContentCache();

      var setSearchHash = function (query, page) {
        location.hash = "stq=" + encodeURIComponent(query) + "&stp=" + page;
      };

      // fetch categories starts
      var fetchResultCategories = function (query,options) {
        
        const cachedQuery = localStorage.getItem("query") || "";
        
        const cachedProduct = localStorage.getItem("product") || "";
        const currentProduct = localStorage.getItem("stf_product") || "";

        const categoryFilterContainer = $("#st-custom-facets ul.menu");
        const renderedCategories = categoryFilterContainer.children().length;

        if(query !== cachedQuery){
          localStorage.removeItem("selected_category");
        }


        if (cachedProduct === currentProduct && cachedQuery === query) {
          if (renderedCategories > 0) {
            return;
          }
        }


        options = $.extend(
          {
            page: 1,
          },
          options
        );
        var params = {};

        Swiftype.currentQuery = query;
        params["q"] = query;
        params["engine_key"] = config.engineKey;
        params["page"] = 1;

        function handleFunctionParam(field) {
          if (field !== undefined) {
            var evald = field;
            if (typeof evald === "function") {
              evald = evald.call();
            }
            return evald;
          }
          return undefined;
        }

        params["per_page"] = 50;
        params["search_fields"] = handleFunctionParam(config.searchFields);
        params["fetch_fields"] = handleFunctionParam(config.fetchFields);
        params["facets"] = handleFunctionParam(config.facets);
        let filters = {
          page: {
            product: window.searchConfig.page.product,
          },
        };
        params["filters"] = handleFunctionParam(filters);
        params["document_types"] = handleFunctionParam(config.documentTypes);
        params["functional_boosts"] = handleFunctionParam(
          config.functionalBoosts
        );
        params["sort_field"] = handleFunctionParam(config.sortField);
        params["sort_direction"] = handleFunctionParam(config.sortDirection);
        params["spelling"] = handleFunctionParam(config.spelling);
        params["highlight_fields"] = handleFunctionParam(
          config.highlightFields
        );

        $.ajax({
          dataType: "json",
          url:
            Swiftype.root_url + "/api/v1/public/engines/search.json?callback=?",
          data: params,
          xhrFields: { withCredentials: true },
          success: renderCategoryFilters,
        });
      };
      // fetch categories ends


      
      var submitSearch = function (query, options) {
        options = $.extend(
          {
            page: 1,
          },
          options
        );
        var params = {};

        if (!$contentCache.length) {
          $resultContainer.after(
            "<div id='" + contentCacheId + "' style='display: none;'></div>"
          );
          $contentCache.html(initialContentOfResultContainer).hide();
        }
        config.loadingFunction(query, $resultContainer);

        Swiftype.currentQuery = query;
        params["q"] = query;
        params["engine_key"] = config.engineKey;
        params["page"] = options.page;

        function handleFunctionParam(field) {
          if (field !== undefined) {
            var evald = field;
            if (typeof evald === "function") {
              evald = evald.call();
            }
            return evald;
          }
          return undefined;
        }

        let overided_filters;
        let searchCategory = window.searchConfig.page.category;
        let cachedCategory = localStorage.getItem("selected_category") || "";

        if (searchCategory && searchCategory === cachedCategory) {
          overided_filters = {
            page: {
              product: window.searchConfig.page.product,
              category: window.searchConfig.page.category,
            },
          }
        }
        else {
          overided_filters = {
            page: {
              product: window.searchConfig.page.product,
              category:undefined,
            },
          }
        }


        params["per_page"] = handleFunctionParam(config.perPage);
        params["search_fields"] = handleFunctionParam(config.searchFields);
        params["fetch_fields"] = handleFunctionParam(config.fetchFields);
        params["facets"] = handleFunctionParam(config.facets);
        // params["filters"] = handleFunctionParam(config.filters);
        params["filters"] = handleFunctionParam(overided_filters);
        params["document_types"] = handleFunctionParam(config.documentTypes);
        params["functional_boosts"] = handleFunctionParam(
          config.functionalBoosts
        );
        params["sort_field"] = handleFunctionParam(config.sortField);
        params["sort_direction"] = handleFunctionParam(config.sortDirection);
        params["spelling"] = handleFunctionParam(config.spelling);
        params["highlight_fields"] = handleFunctionParam(
          config.highlightFields
        );

        $.ajax({
          dataType: "json",
          url:
            Swiftype.root_url + "/api/v1/public/engines/search.json?callback=?",
          data: params,
          xhrFields: { withCredentials: true },
          success: function(data){renderSearchResults(data);
            renderCategoryFilters(data);
          }
        });
        
        fetchResultCategories(query,options);
      };

      function handleHashchange() {
        var params = $.hashParams();
        if (params.stq) {
          submitSearch(params.stq, {
            page: params.stp,
          });
        } else {
          var $contentCache = $this.getContentCache();
          if ($contentCache.length) {
            $resultContainer.html($contentCache.html());
            $contentCache.remove();
          }
        }
      }

      // Expose this globally for users to force a refresh of search results.
      Swiftype.reloadResults = handleHashchange;

      $(window).on("hashchange", handleHashchange);

      var $containingForm = $this.parents("form");
      if ($containingForm) {
        $containingForm.bind("submit", function (e) {
          e.preventDefault();
          var searchQuery = $this.val();
          setSearchHash(searchQuery, 1);
        });
      }

      // $(".select-with-input .input-dropdown li").on("click", function () {
      //   var text = $(this).text().trim();
      //   console.log("text", text);
      //   if (!text) {
      //     return;
      //   }
      //   var hash = "#stq=" + encodeURIComponent(text);
      //   var absUrl = THEME_DIR + "/../search.html" + hash;
      //   window.location = absUrl;
      // });

      $("form.form-search").on("submit", function () {
        var query = $(".st-search-input", this).val().trim();
        if (!query) {
          return;
        }
        var hash = "#stq=" + encodeURIComponent(query);
        var absUrl = THEME_DIR + "/../search.html" + hash;
        window.location = absUrl;
      });

      $(document).on("click", "[data-hash][data-page]", function (e) {
        e.preventDefault();
        var $this = $(this);
        setSearchHash($.hashParams().stq, $this.data("page"));
      });

      $(document).on(
        "click",
        "[data-hash][data-spelling-suggestion]",
        function (e) {
          e.preventDefault();
          var $this = $(this);
          setSearchHash($this.data("spelling-suggestion"), 1);
        }
      );


      var renderCategoryFilters = function (data) {
        // cancel rendering if category filter is already applied
        // const filterCategory = window.searchConfig.page.category;
        // if (filterCategory) {
        //   console.log("aborting category filter rendering");
        //   return;
        // }
        const query = data.info.page.query;
        const categoryFilterContainer = $("#st-custom-facets ul.menu");
        const renderedCategories = categoryFilterContainer.children().length;
        const cachedQuery = localStorage.getItem("query") || "";
        const cachedProduct = localStorage.getItem("product") || "";
        const currentProduct = localStorage.getItem("stf_product") || "";
        const cachedCategories = localStorage.getItem("categories") || "";
        const currentCategory = window.searchConfig.page.category || "";

        //if (renderedCategories !== 0) {
          // if (cachedProduct === currentProduct && cachedQuery === query) {
          //     if (cachedCategories.includes(currentCategory)) {
          //         return;
          //     }
          // }
      //}

        let categories = [];

        data.records.page.forEach(item => {
          let categoryArray;
          if (item.category) {
            if (typeof item.category === "string") {
              try {
                categoryArray = JSON.parse(item.category.replace(/'/g, '"'));
              } catch (e) {
                categoryArray = [item.category];
              }
            }
            else if (typeof item.category === "object") {
              categoryArray = item.category;
            }
            categories = categories.concat(categoryArray);
          }
        });

        categories = [...new Set(categories)];

        localStorage.setItem("categories", JSON.stringify(categories));
        console.log ("in jquery_swiftype.search.js");
        console.log (window.searchConfig.page.product);
        // localStorage.setItem("product", window.searchConfig.page.product);
        localStorage.setItem("query", query);

        if (categories.length === 0) {
          $("#st-custom-facets h5").hide();
        }
        else{
          $("#st-custom-facets h5").show();
        }

        categoryFilterContainer.empty();

        categories.forEach(category => {
          if (category == "Category1" || category == "Category2" || category.length <= 1){
            return;
          }
          categoryFilterContainer.append(`<li>
          <a>
            <input
              type="checkbox"
              class="search-filter ${category}"
              data-type="string"
              data-value="${category}"
              id="${category}"
            />
            ${category}
            <button class="custom-close-button" onClick="clearFilters()"></button>
          </a>
        </li>`)
        });
      }

      var renderSearchResults = function (data) {
        if (typeof config.preRenderFunction === "function") {
          config.preRenderFunction.call($this, data);
        }

        config.renderResultsFunction($this.getContext(), data);

        if (typeof config.postRenderFunction === "function") {
          config.postRenderFunction.call($this, data);
        }
      };

      $this.getContext = function () {
        return {
          config: config,
          resultContainer: $resultContainer,
          registerResult: $this.registerResult,
        };
      };

      handleHashchange(); // if the swiftype query hash is present onload (maybe the user is pressing the back button), submit a query onload
    });
  };

  var renderPagination = function (ctx, resultInfo) {
    var maxPagesType,
      maxPages = -1,
      config = ctx.config;
    $.each(resultInfo, function (documentType, typeInfo) {
      if (typeInfo.num_pages > maxPages) {
        maxPagesType = documentType;
        maxPages = typeInfo.num_pages;
      }
    });
    var currentPage = resultInfo[maxPagesType].current_page,
      totalPages = resultInfo[maxPagesType].num_pages;

    $(
      config.renderPaginationForType(maxPagesType, currentPage, totalPages)
    ).appendTo(ctx.resultContainer);
  };

  var normalize = function (str) {
    return $.trim(str).toLowerCase();
  };

  function htmlEscape(str) {
    return String(str)
      .replace(/&/g, "&amp;")
      .replace(/"/g, "&quot;")
      .replace(/'/g, "&#39;")
      .replace(/</g, "&lt;")
      .replace(/>/g, "&gt;");
  }

  var defaultRenderResultsFunction = function (ctx, data) {
    var $resultContainer = ctx.resultContainer,
      config = ctx.config;

    $resultContainer.html("");

    $.each(data.records, function (documentType, items) {
      $.each(items, function (idx, item) {
        ctx.registerResult(
          $(config.renderFunction(documentType, item)).appendTo(
            $resultContainer
          ),
          item
        );
      });
    });

    renderPagination(ctx, data.info);
  };

  var defaultRenderFunction = function (document_type, item) {
    return (
      '<div class="st-result"><h3 class="title"><a href="' +
      item["url"] +
      '" class="st-search-result-link">' +
      htmlEscape(item["title"]) +
      "</a></h3></div>"
    );
  };

  var defaultLoadingFunction = function (query, $resultContainer) {
    $resultContainer.html('<p class="st-loading-message">loading...</p>');
  };

  var defaultOnComplete = function (elem) {
    window.location = elem.attr("href");
  };

  var defaultPostRenderFunction = function (data) {
    var totalResultCount = 0;
    var $resultContainer = this.getContext().resultContainer;
    var spellingSuggestion = null;

    if (data["info"]) {
      $.each(data["info"], function (index, value) {
        totalResultCount += value["total_result_count"];
        if (value["spelling_suggestion"]) {
          spellingSuggestion = value["spelling_suggestion"]["text"];
        }
      });
    }

    if (totalResultCount === 0) {
      $resultContainer.html(
        "<div id='st-no-results' class='st-no-results'>No results found.</div>"
      );
    }

    if (spellingSuggestion !== null) {
      $resultContainer.append(
        '<div class="st-spelling-suggestion">Did you mean <a href="#" data-hash="true" data-spelling-suggestion="' +
          spellingSuggestion +
          '">' +
          spellingSuggestion +
          "</a>?</div>"
      );
    }
  };

  var defaultRenderPaginationForType = function (
    type,
    currentPage,
    totalPages
  ) {
    var pages = '<div class="st-page">',
      previousPage,
      nextPage;
    if (currentPage != 1) {
      previousPage = currentPage - 1;
      pages =
        pages +
        '<a href="#" class="st-prev" data-hash="true" data-page="' +
        previousPage +
        '">&laquo; previous</a>';
    }
    if (currentPage < totalPages) {
      nextPage = currentPage + 1;
      pages =
        pages +
        '<a href="#" class="st-next" data-hash="true" data-page="' +
        nextPage +
        '">next &raquo;</a>';
    }
    pages += "</div>";
    return pages;
  };

  $.fn.swiftypeSearch.defaults = {
    attachTo: undefined,
    documentTypes: undefined,
    facets: undefined,
    filters: undefined,
    engineKey: undefined,
    searchFields: undefined,
    functionalBoosts: undefined,
    sortField: undefined,
    sortDirection: undefined,
    fetchFields: undefined,
    highlightFields: undefined,
    preRenderFunction: undefined,
    postRenderFunction: defaultPostRenderFunction,
    loadingFunction: defaultLoadingFunction,
    renderResultsFunction: defaultRenderResultsFunction,
    renderFunction: defaultRenderFunction,
    renderPaginationForType: defaultRenderPaginationForType,
    onComplete: defaultOnComplete,
    perPage: 10,
    spelling: "strict",
  };
})(jQuery);