/**
 * Free single-product out-of-stock availability resolution.
 *
 * Re-implements the premium extension/optionState.ts contract for the free
 * bundle WITHOUT importing from src/frontend/extension/. It consumes the SAME
 * server-emitted markers as the premium path:
 *
 *  - <option data-b3-wvs-out-of-stock="1">   (per out-of-stock option)
 *  - <select data-b3-wvs-out-of-stock-values='["Red","Blue"]'>   (JSON list)
 *  - <select data-b3-wvs-stock-blocks-selection="1|0">           (disable hint)
 *
 * Two modes mirror the premium resolver:
 *  - Static mode: the variations form carries data-product_variations JSON;
 *    availability is computed client-side from the full variation matrix and
 *    the current sibling selections.
 *  - AJAX-threshold mode: large variable products ship no inline variations, so
 *    we start from the server's baseline out-of-stock list (data attribute) and
 *    progressively mark options back in stock as WooCommerce reports
 *    found_variation events.
 *
 * @package B3VariationSwatches
 */

type Variation = {
  variation_id: number;
  attributes: Record<string, string>;
  is_in_stock: boolean;
  is_purchasable: boolean;
};

type CurrentSelections = Record<string, string>;

// Per-form cache of attribute:value combinations learned from found_variation
// events in AJAX-threshold mode.
const ajaxStateCache = new Map<string, boolean>();
const formObserverCounts = new Map<string, number>();

const variationCountsAsAvailable = (variation: Variation): boolean =>
  Boolean(variation.is_in_stock) && Boolean(variation.is_purchasable);

const getFormId = (form: HTMLFormElement): string => {
  let id = form.dataset.b3WvsFormId;
  if (!id) {
    id = `b3wvs_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
    form.dataset.b3WvsFormId = id;
  }
  return id;
};

const isAjaxMode = (form: HTMLFormElement): boolean => {
  const variationsData = form.getAttribute("data-product_variations");
  return !variationsData || variationsData === "false";
};

const getVariationsFromForm = (form: HTMLFormElement): Variation[] => {
  const variationsData = form.getAttribute("data-product_variations");
  if (!variationsData) return [];

  try {
    const parsed = JSON.parse(variationsData);
    return Array.isArray(parsed) ? (parsed as Variation[]) : [];
  } catch {
    return [];
  }
};

const getCurrentSelections = (form: HTMLFormElement): CurrentSelections => {
  const selections: CurrentSelections = {};
  const selects = form.querySelectorAll<HTMLSelectElement>(
    'select[name^="attribute_"]',
  );

  selects.forEach((select) => {
    const attrName = select.getAttribute("name") || "";
    selections[attrName] = select.value;
  });

  return selections;
};

const getVariationAttributeValue = (
  variation: Variation,
  attributeName: string,
): string | undefined => {
  if (attributeName in variation.attributes) {
    return variation.attributes[attributeName];
  }

  const lowerName = attributeName.toLowerCase();
  for (const key of Object.keys(variation.attributes)) {
    if (key.toLowerCase() === lowerName) {
      return variation.attributes[key];
    }
  }

  const normalizedName = attributeName.toLowerCase().replace(/\s+/g, "-");
  for (const key of Object.keys(variation.attributes)) {
    const normalizedKey = key.toLowerCase().replace(/\s+/g, "-");
    if (normalizedKey === normalizedName) {
      return variation.attributes[key];
    }
  }

  return undefined;
};

const variationMatchesSelections = (
  variation: Variation,
  selections: CurrentSelections,
  excludeAttribute?: string,
): boolean => {
  for (const attrName of Object.keys(selections)) {
    if (
      excludeAttribute &&
      attrName.toLowerCase() === excludeAttribute.toLowerCase()
    ) {
      continue;
    }

    const selectedValue = selections[attrName];
    const variationValue =
      getVariationAttributeValue(variation, attrName) ?? "";

    if (!selectedValue || selectedValue === "") continue;
    if (!variationValue || variationValue === "") continue;

    if (selectedValue.toLowerCase() !== variationValue.toLowerCase()) {
      return false;
    }
  }

  return true;
};

const isOptionAvailable = (
  attributeName: string,
  optionValue: string,
  variations: Variation[],
  currentSelections: CurrentSelections,
): boolean => {
  for (const variation of variations) {
    const variationAttrValue = getVariationAttributeValue(
      variation,
      attributeName,
    );
    if (variationAttrValue === undefined) {
      continue;
    }

    const isAny = variationAttrValue === "";
    const valueMatches =
      isAny || variationAttrValue.toLowerCase() === optionValue.toLowerCase();
    if (!valueMatches) {
      continue;
    }

    if (
      !variationMatchesSelections(variation, currentSelections, attributeName)
    ) {
      continue;
    }

    if (variationCountsAsAvailable(variation)) {
      return true;
    }
  }

  return false;
};

const computeUnavailableOptions = (
  attributeName: string,
  optionValues: string[],
  variations: Variation[],
  currentSelections: CurrentSelections,
): Set<string> => {
  const unavailable = new Set<string>();

  for (const optionValue of optionValues) {
    if (!optionValue) continue;

    if (
      !isOptionAvailable(
        attributeName,
        optionValue,
        variations,
        currentSelections,
      )
    ) {
      unavailable.add(optionValue);
    }
  }

  return unavailable;
};

const parseServerUnavailableValues = (
  select: HTMLSelectElement,
): Set<string> => {
  const raw = select.dataset.b3WvsOutOfStockValues;
  if (!raw) return new Set<string>();

  try {
    const parsed = JSON.parse(raw);
    if (Array.isArray(parsed)) {
      return new Set(parsed.map((value) => String(value).toLowerCase()));
    }
  } catch {
    return new Set(
      raw
        .split(",")
        .map((value) => value.trim().toLowerCase())
        .filter(Boolean),
    );
  }

  return new Set<string>();
};

const getCachedAvailability = (
  form: HTMLFormElement,
  attributeName: string,
  optionValue: string,
): boolean | undefined => {
  const formId = getFormId(form);
  return ajaxStateCache.get(
    `${formId}:${attributeName.toLowerCase()}:${optionValue.toLowerCase()}`,
  );
};

const cacheVariationAvailability = (
  form: HTMLFormElement,
  variation: Variation,
): void => {
  if (!variationCountsAsAvailable(variation)) {
    return;
  }

  const formId = getFormId(form);
  for (const [attrName, attrValue] of Object.entries(variation.attributes)) {
    if (!attrValue) continue;

    ajaxStateCache.set(
      `${formId}:${attrName.toLowerCase()}:${String(attrValue).toLowerCase()}`,
      true,
    );
  }
};

const clearVariationAvailability = (form?: HTMLFormElement): void => {
  if (!form) {
    ajaxStateCache.clear();
    return;
  }

  const formId = getFormId(form);
  const keysToDelete: string[] = [];
  ajaxStateCache.forEach((_, key) => {
    if (key.startsWith(`${formId}:`)) {
      keysToDelete.push(key);
    }
  });

  keysToDelete.forEach((key) => ajaxStateCache.delete(key));
};

const computeUnavailableOptionsAjax = (
  form: HTMLFormElement,
  select: HTMLSelectElement,
  optionValues: string[],
): Set<string> => {
  const unavailable = new Set<string>();
  const attrName = select.getAttribute("name") || "";
  const serverUnavailable = parseServerUnavailableValues(select);

  for (const optionValue of optionValues) {
    if (!optionValue) continue;

    // A found_variation event proved this combination available; never paint it
    // out of stock even if the server baseline flagged it.
    if (getCachedAvailability(form, attrName, optionValue) === true) {
      continue;
    }

    if (serverUnavailable.has(optionValue.toLowerCase())) {
      unavailable.add(optionValue);
    }
  }

  return unavailable;
};

/**
 * Resolve the set of out-of-stock option values for one variation select.
 *
 * The returned set uses the ORIGINAL option-value casing (matching the values
 * read off the <select>), so callers can do a direct Set.has(option.value).
 */
export const resolveOutOfStockValues = (
  select: HTMLSelectElement,
  optionValues: string[],
): Set<string> => {
  const form = select.closest("form.variations_form") as HTMLFormElement | null;

  if (!form) {
    // No variations form context: fall back to whatever the server tagged on
    // the option elements directly.
    return readOptionLevelOutOfStock(select, optionValues);
  }

  if (isAjaxMode(form)) {
    return computeUnavailableOptionsAjax(form, select, optionValues);
  }

  const attrName = select.getAttribute("name") || "";
  if (!attrName) {
    return readOptionLevelOutOfStock(select, optionValues);
  }

  return computeUnavailableOptions(
    attrName,
    optionValues,
    getVariationsFromForm(form),
    getCurrentSelections(form),
  );
};

/**
 * Fallback reader: collect option values flagged out of stock by the server on
 * the option elements themselves (data-b3-wvs-out-of-stock="1"). Only the
 * explicit marker counts; a merely `disabled` option is not out of stock.
 */
export const readOptionLevelOutOfStock = (
  select: HTMLSelectElement,
  optionValues: string[],
): Set<string> => {
  const flagged = new Set<string>();
  const allowed = new Set(optionValues);

  Array.from(select.options).forEach((option) => {
    const value = option.value || "";
    if (!value || !allowed.has(value)) return;
    if (option.dataset.b3WvsOutOfStock === "1") {
      flagged.add(value);
    }
  });

  return flagged;
};

/**
 * Subscribe to WooCommerce variation lifecycle events so the renderer can
 * re-resolve availability. Mirrors the premium observeOptions contract.
 *
 * @returns Cleanup function.
 */
export const observeOutOfStock = (
  select: HTMLSelectElement,
  refresh: () => void,
): (() => void) => {
  const jq = typeof window !== "undefined" ? window.jQuery : undefined;
  const form = select.closest("form.variations_form") as HTMLFormElement | null;
  const $form = form && typeof jq === "function" ? jq(form) : null;

  if (!$form || typeof $form.on !== "function" || !form) {
    return () => undefined;
  }

  const formId = getFormId(form);
  formObserverCounts.set(formId, (formObserverCounts.get(formId) ?? 0) + 1);

  const handleFoundVariation = (_event: unknown, variation: unknown) => {
    if (!isAjaxMode(form) || !variation || typeof variation !== "object") {
      return;
    }

    cacheVariationAvailability(form, variation as Variation);
    refresh();
  };

  const handleResetData = () => {
    clearVariationAvailability(form);
    refresh();
  };

  const handleUpdateValues = () => refresh();

  $form.on(
    "update_variation_values.b3wvsoos woocommerce_update_variation_values.b3wvsoos",
    handleUpdateValues,
  );
  $form.on("found_variation.b3wvsoos", handleFoundVariation);
  $form.on("reset_data.b3wvsoos", handleResetData);

  let subscribed = true;
  return () => {
    if (!subscribed) return;
    subscribed = false;
    $form.off(
      "update_variation_values.b3wvsoos woocommerce_update_variation_values.b3wvsoos",
      handleUpdateValues,
    );
    $form.off("found_variation.b3wvsoos", handleFoundVariation);
    $form.off("reset_data.b3wvsoos", handleResetData);
    const remainingObservers = (formObserverCounts.get(formId) ?? 1) - 1;
    if (remainingObservers <= 0) {
      formObserverCounts.delete(formId);
      clearVariationAvailability(form);
    } else {
      formObserverCounts.set(formId, remainingObservers);
    }
  };
};