/** Shopify CDN: Minification failed

Line 16:26 Unexpected "="
Line 22:1 Unexpected ";"
Line 29:7 Expected ":"
Line 30:4 Expected ":"
Line 32:4 Expected ":"
Line 33:4 Expected ":"
Line 34:4 Expected ":"
Line 35:8 Expected ":"
Line 36:1 Unexpected ";"
Line 39:7 Expected ":"
... and 173 more hidden warnings

**/
const PRICE_FILTER_CONFIG = {
  min: 0,
  step: 1,
  currencySymbol: 'د.إ',
  locale: 'en-US',
  debounceDelay: 300,
};

/**
 * Calculate adaptive slider max based on collection max price
 * Implements smart range scaling to support unlimited custom values
 */
const calculateSliderMax = (collectionMax) => {
  const max = Number(collectionMax);
  if (!Number.isFinite(max) || max <= 0) return 5000;

  if (max < 1000) return 5000;
  if (max < 10000) return 50000;
  if (max < 100000) return 500000;
  return Math.max(max * 5, 500000);
};

const formatCurrency = (value) => {
  const number = Number(value);
  if (!Number.isFinite(number)) return `${PRICE_FILTER_CONFIG.currencySymbol} 0`;
  return `${PRICE_FILTER_CONFIG.currencySymbol} ${Math.round(number).toLocaleString(PRICE_FILTER_CONFIG.locale)}`;
};

const parseCurrencyValue = (value) => {
  if (typeof value !== 'string') return null;
  const cleaned = value.replace(/[^0-9.]/g, '');
  if (cleaned === '') return null;
  const parsed = Number(cleaned);
  if (!Number.isFinite(parsed)) return null;
  return Math.max(0, Math.round(parsed));
};

const buildFilterUrl = (params) => {
  const url = new URL(window.location.href);
  url.search = '';

  for (const [key, value] of params.entries()) {
    url.searchParams.append(key, value);
  }

  url.searchParams.delete('page');
  return url.toString();
};

const debounce = (callback, delay = PRICE_FILTER_CONFIG.debounceDelay) => {
  let timeout;
  return (...args) => {
    clearTimeout(timeout);
    timeout = window.setTimeout(() => callback(...args), delay);
  };
};

const querySelectorSafe = (root, selector) => root.querySelector(selector);

const fetchAndReplaceResults = async (url, filterRoot) => {
  const currentResults = document.querySelector('results-list') || document.querySelector('#ResultsList');
  if (!currentResults) return;

  filterRoot.classList.add('premium-price-filter--loading');

  try {
    const response = await fetch(url, {
      headers: { 'X-Requested-With': 'XMLHttpRequest' },
      credentials: 'same-origin',
    });

    if (!response.ok) throw new Error(`Filter request failed: ${response.status}`);
    const html = await response.text();
    const parser = new DOMParser();
    const doc = parser.parseFromString(html, 'text/html');

    const updatedResults = doc.querySelector('results-list') || doc.querySelector('#ResultsList');
    if (updatedResults) {
      currentResults.replaceWith(updatedResults);
      window.initPriceFilter?.();
      window.dispatchEvent(new CustomEvent('price-filter:updated', { detail: { url } }));
    }
  } catch (error) {
    console.error('[PriceFilter]', error);
  } finally {
    filterRoot.classList.remove('premium-price-filter--loading');
  }
};

const getCurrentQueryParams = () => {
  return new URLSearchParams(window.location.search);
};

const setUrlFromParams = (params) => {
  const nextUrl = buildFilterUrl(params);
  window.history.pushState({}, '', nextUrl);
};

/**
 * Update price display with intelligent formatting
 * Cases:
 * - Both selected: ₹500 – ₹5000
 * - Only min: ₹500+
 * - Only max: Up to ₹5000
 * - No filter: (empty)
 */
const updatePriceDisplay = ({ minSlider, maxSlider, displayElement, sliderMin, sliderMax }) => {
  const minValue = Number(minSlider.value);
  const maxValue = Number(maxSlider.value);

  if (minValue === sliderMin && maxValue === sliderMax) {
    displayElement.textContent = '';
    return;
  }

  if (minValue > sliderMin && maxValue < sliderMax) {
    displayElement.textContent = `${formatCurrency(minValue)} – ${formatCurrency(maxValue)}`;
    return;
  }

  if (minValue > sliderMin) {
    displayElement.textContent = `${formatCurrency(minValue)}+`;
    return;
  }

  if (maxValue < sliderMax) {
    displayElement.textContent = `Up to ${formatCurrency(maxValue)}`;
    return;
  }

  displayElement.textContent = '';
};

const updateTrackFill = ({ minSlider, maxSlider, trackActive, sliderMin, sliderMax }) => {
  const minValue = Number(minSlider.value);
  const maxValue = Number(maxSlider.value);
  const range = sliderMax - sliderMin;

  const leftPercent = ((minValue - sliderMin) / range) * 100;
  const rightPercent = ((sliderMax - maxValue) / range) * 100;

  trackActive.style.left = `${leftPercent}%`;
  trackActive.style.right = `${rightPercent}%`;
};

const syncTextInputs = ({ minSlider, maxSlider, minTextInput, maxTextInput, sliderMin, sliderMax }) => {
  const minValue = Number(minSlider.value);
  const maxValue = Number(maxSlider.value);

  minTextInput.value = minValue === sliderMin ? '' : minValue;
  maxTextInput.value = maxValue === sliderMax ? '' : maxValue;
};

const syncHiddenInputs = ({ minSlider, maxSlider, hiddenMinInput, hiddenMaxInput, sliderMin, sliderMax }) => {
  const minValue = Number(minSlider.value);
  const maxValue = Number(maxSlider.value);

  // Only set hidden inputs if not at default range
  if (minValue > sliderMin) {
    hiddenMinInput.value = minValue;
  } else {
    hiddenMinInput.value = '';
  }

  if (maxValue < sliderMax) {
    hiddenMaxInput.value = maxValue;
  } else {
    hiddenMaxInput.value = '';
  }
};

/**
 * Dynamically expand slider max if user enters a larger value
 */
const expandSliderIfNeeded = ({ minSlider, maxSlider, userValue, isMax }) => {
  const sliderMax = Number(maxSlider.max);
  const numValue = Number(userValue);

  if (numValue > sliderMax) {
    // Expand slider max to accommodate user input
    const newMax = Math.ceil(numValue * 1.2); // Add 20% buffer
    minSlider.max = newMax;
    maxSlider.max = newMax;
    return newMax;
  }

  return sliderMax;
};

const getFilterParams = ({ minSlider, maxSlider, sortSelect, sliderMin, sliderMax }) => {
  const params = getCurrentQueryParams();
  const minValue = Number(minSlider.value);
  const maxValue = Number(maxSlider.value);

  if (minValue > sliderMin) {
    params.set('filter.v.price.gte', String(minValue));
  } else {
    params.delete('filter.v.price.gte');
  }

  if (maxValue < sliderMax) {
    params.set('filter.v.price.lte', String(maxValue));
  } else {
    params.delete('filter.v.price.lte');
  }

  const sortValue = sortSelect?.value;
  if (sortValue) {
    params.set('sort_by', sortValue);
  } else {
    params.delete('sort_by');
  }

  return params;
};

const bindDualRangeSlider = (filterRoot) => {
  const minSlider = querySelectorSafe(filterRoot, '[data-price-filter-slider-min]');
  const maxSlider = querySelectorSafe(filterRoot, '[data-price-filter-slider-max]');
  const trackActive = querySelectorSafe(filterRoot, '[data-price-filter-track-active]');
  const displayElement = querySelectorSafe(filterRoot, '[data-price-filter-display]');
  const minTextInput = querySelectorSafe(filterRoot, '[data-price-filter-input-min-text]');
  const maxTextInput = querySelectorSafe(filterRoot, '[data-price-filter-input-max-text]');
  const hiddenMinInput = querySelectorSafe(filterRoot, '[data-price-filter-hidden-min]');
  const hiddenMaxInput = querySelectorSafe(filterRoot, '[data-price-filter-hidden-max]');
  const applyButton = querySelectorSafe(filterRoot, '[data-price-filter-apply]');
  const sortSelect = querySelectorSafe(filterRoot, '[data-price-filter-sort]');

  if (!minSlider || !maxSlider || !trackActive || !displayElement) return;

  // Get initial slider bounds from data attributes or Liquid
  const collectionMax = Number(filterRoot.dataset.rangeMax) || 5000;
  const sliderMin = PRICE_FILTER_CONFIG.min;
  const sliderMax = calculateSliderMax(collectionMax);

  // Set initial slider max
  minSlider.max = sliderMax;
  maxSlider.max = sliderMax;

  // Prevent slider overlap
  const preventOverlap = () => {
    const minValue = Number(minSlider.value);
    const maxValue = Number(maxSlider.value);

    if (minValue > maxValue) {
      if (minSlider === document.activeElement) {
        maxSlider.value = minValue;
      } else {
        minSlider.value = maxValue;
      }
    }
  };

  // Update display and track on input
  const updateDisplay = () => {
    preventOverlap();
    updatePriceDisplay({ minSlider, maxSlider, displayElement, sliderMin, sliderMax: Number(maxSlider.max) });
    updateTrackFill({ minSlider, maxSlider, trackActive, sliderMin, sliderMax: Number(maxSlider.max) });
    syncTextInputs({ minSlider, maxSlider, minTextInput, maxTextInput, sliderMin, sliderMax: Number(maxSlider.max) });
    syncHiddenInputs({ minSlider, maxSlider, hiddenMinInput, hiddenMaxInput, sliderMin, sliderMax: Number(maxSlider.max) });
  };

  // Debounced filter update
  const updateAndFilter = debounce(async () => {
    setUrlFromParams(getFilterParams({ minSlider, maxSlider, sortSelect, sliderMin, sliderMax: Number(maxSlider.max) }));
    await fetchAndReplaceResults(window.location.href, filterRoot);
  }, PRICE_FILTER_CONFIG.debounceDelay);

  // Slider events
  minSlider.addEventListener('input', updateDisplay);
  maxSlider.addEventListener('input', updateDisplay);
  minSlider.addEventListener('change', updateAndFilter);
  maxSlider.addEventListener('change', updateAndFilter);

  // Text input sync with dynamic range expansion
  if (minTextInput) {
    minTextInput.addEventListener('input', () => {
      const value = parseCurrencyValue(minTextInput.value);
      if (value !== null) {
        minSlider.value = value;
        updateDisplay();
      }
    });

    minTextInput.addEventListener('blur', () => {
      const value = parseCurrencyValue(minTextInput.value);
      if (value !== null) {
        minSlider.value = value;
        updateDisplay();
        updateAndFilter();
      }
    });
  }

  if (maxTextInput) {
    maxTextInput.addEventListener('input', () => {
      const value = parseCurrencyValue(maxTextInput.value);
      if (value !== null) {
        const newMax = expandSliderIfNeeded({ minSlider, maxSlider, userValue: value, isMax: true });
        maxSlider.value = value;
        updateDisplay();
      }
    });

    maxTextInput.addEventListener('blur', () => {
      const value = parseCurrencyValue(maxTextInput.value);
      if (value !== null) {
        expandSliderIfNeeded({ minSlider, maxSlider, userValue: value, isMax: true });
        maxSlider.value = value;
        updateDisplay();
        updateAndFilter();
      }
    });
  }

  // Apply button
  if (applyButton) {
    applyButton.addEventListener('click', () => {
      updateDisplay();
      updateAndFilter();
    });
  }

  // Sort select
  if (sortSelect) {
    sortSelect.addEventListener('change', updateAndFilter);
  }

  // Initial display
  updateDisplay();
};

const initPriceFilter = (context = document) => {
  const filters = context.querySelectorAll('[data-price-filter]');
  filters.forEach((filterRoot) => {
    if (filterRoot.dataset.priceFilterInitialized === 'true') return;
    bindDualRangeSlider(filterRoot);
    filterRoot.dataset.priceFilterInitialized = 'true';
  });
};

window.initPriceFilter = initPriceFilter;

document.addEventListener('DOMContentLoaded', () => initPriceFilter());
window.addEventListener('popstate', () => initPriceFilter());