"use strict";

(function () {
  var MAP_SELECTOR = ".afc-franchise-map";
  var ACTIVE_CLASS = "is-active";
  var DEFAULT_MAP_LABEL = "United States franchise regions map";
  var SCRIPT_EL = document.currentScript;
  var svgCache = new Map();
  var ATTRIBUTES = {
    activeStates: "data-active-states",
    mapSrc: "data-map-src",
    activeFill: "data-active-fill",
    defaultFill: "data-default-fill",
    stroke: "data-stroke",
    mapLabel: "data-map-label"
  };

  function readAttr(element, attrName) {
    if (!element || !element.hasAttribute || !element.hasAttribute(attrName)) return null;
    return element.getAttribute(attrName);
  }

  function readNonEmptyAttr(element, attrName) {
    var value = readAttr(element, attrName);
    if (value == null) return null;
    var trimmed = String(value).trim();
    return trimmed ? trimmed : null;
  }

  function firstNonEmpty(values) {
    for (var index = 0; index < values.length; index += 1) {
      var value = values[index];
      if (value == null) continue;
      var trimmed = String(value).trim();
      if (trimmed) return trimmed;
    }
    return null;
  }

  function parseCodes(raw) {
    return Array.from(
      new Set(
        String(raw || "")
          .split(",")
          .map(function (value) {
            return value.trim().toUpperCase();
          })
          .filter(Boolean)
      )
    );
  }

  function findAncestorWithAttr(element, attrName) {
    var current = element ? element.parentElement : null;

    while (current) {
      if (current.hasAttribute && current.hasAttribute(attrName)) return current;
      current = current.parentElement;
    }

    return null;
  }

  function resolveConfig(container) {
    return {
      mapSrc: firstNonEmpty([
        readNonEmptyAttr(container, ATTRIBUTES.mapSrc),
        readNonEmptyAttr(findAncestorWithAttr(container, ATTRIBUTES.mapSrc), ATTRIBUTES.mapSrc),
        readNonEmptyAttr(SCRIPT_EL, ATTRIBUTES.mapSrc),
        readNonEmptyAttr(SCRIPT_EL, "data-default-map-src")
      ]),
      activeStatesRaw:
        firstNonEmpty([
          readAttr(container, ATTRIBUTES.activeStates),
          readAttr(findAncestorWithAttr(container, ATTRIBUTES.activeStates), ATTRIBUTES.activeStates),
          readAttr(SCRIPT_EL, ATTRIBUTES.activeStates)
        ]) || "",
      mapLabel:
        firstNonEmpty([
          readNonEmptyAttr(container, ATTRIBUTES.mapLabel),
          readNonEmptyAttr(findAncestorWithAttr(container, ATTRIBUTES.mapLabel), ATTRIBUTES.mapLabel),
          readNonEmptyAttr(SCRIPT_EL, ATTRIBUTES.mapLabel)
        ]) || DEFAULT_MAP_LABEL,
      activeFill: firstNonEmpty([
        readNonEmptyAttr(container, ATTRIBUTES.activeFill),
        readNonEmptyAttr(findAncestorWithAttr(container, ATTRIBUTES.activeFill), ATTRIBUTES.activeFill),
        readNonEmptyAttr(SCRIPT_EL, ATTRIBUTES.activeFill)
      ]),
      defaultFill: firstNonEmpty([
        readNonEmptyAttr(container, ATTRIBUTES.defaultFill),
        readNonEmptyAttr(findAncestorWithAttr(container, ATTRIBUTES.defaultFill), ATTRIBUTES.defaultFill),
        readNonEmptyAttr(SCRIPT_EL, ATTRIBUTES.defaultFill)
      ]),
      stroke: firstNonEmpty([
        readNonEmptyAttr(container, ATTRIBUTES.stroke),
        readNonEmptyAttr(findAncestorWithAttr(container, ATTRIBUTES.stroke), ATTRIBUTES.stroke),
        readNonEmptyAttr(SCRIPT_EL, ATTRIBUTES.stroke)
      ])
    };
  }

  function applyRuntimeCssVars(container, config) {
    if (config.defaultFill) {
      container.style.setProperty("--afc-map-default-fill", config.defaultFill);
    }

    if (config.stroke) {
      container.style.setProperty("--afc-map-stroke", config.stroke);
    }

    if (config.activeFill) {
      container.style.setProperty("--afc-map-active-fill", config.activeFill);
    }
  }

  function fetchSvg(mapSrc) {
    if (!mapSrc) {
      return Promise.reject(
        new Error(
          "AFC map source URL is missing. Set data-map-src on the component/embed or script tag."
        )
      );
    }

    if (!svgCache.has(mapSrc)) {
      svgCache.set(
        mapSrc,
        fetch(mapSrc)
          .then(function (response) {
            if (!response.ok) {
              throw new Error("Failed to fetch SVG (" + response.status + ").");
            }
            return response.text();
          })
          .then(function (text) {
            var svgText = String(text || "").trim();
            if (!svgText.startsWith("<svg")) {
              throw new Error("Fetched map file is not valid SVG.");
            }
            return svgText;
          })
      );
    }

    return svgCache.get(mapSrc);
  }

  function applyHighlights(container, codes, config) {
    var defaultFill = config.defaultFill || "var(--afc-map-default-fill, #1a1a1a)";
    var stroke = config.stroke || "var(--afc-map-stroke, #3a3a3a)";
    var activeFill = config.activeFill || "var(--afc-map-active-fill, #f5d318)";
    var states = container.querySelectorAll(".afc-state");
    states.forEach(function (statePath) {
      statePath.classList.remove(ACTIVE_CLASS);
      statePath.style.fill = defaultFill;
      statePath.style.stroke = stroke;
    });

    codes.forEach(function (code) {
      var safeCode = window.CSS && CSS.escape ? CSS.escape(code) : code.replace(/[^A-Z0-9_-]/g, "");
      if (!safeCode) return;
      var state = container.querySelector("#" + safeCode);
      if (state) {
        state.classList.add(ACTIVE_CLASS);
        state.style.fill = activeFill;
      }
    });
  }

  function ensureSvgA11y(container, mapLabel) {
    var svg = container.querySelector("svg");
    if (!svg) return;
    if (!svg.hasAttribute("role")) svg.setAttribute("role", "img");
    svg.setAttribute("aria-label", mapLabel || DEFAULT_MAP_LABEL);
  }

  function initMap(container) {
    var config = resolveConfig(container);
    var activeCodes = parseCodes(config.activeStatesRaw);
    var mapSrc = config.mapSrc;

    applyRuntimeCssVars(container, config);

    fetchSvg(mapSrc)
      .then(function (svgMarkup) {
        var hasSvg = Boolean(container.querySelector("svg"));
        var loadedMapSrc = container.getAttribute("data-loaded-map-src");

        if (!hasSvg || loadedMapSrc !== mapSrc) {
          container.innerHTML = svgMarkup;
          container.setAttribute("data-loaded-map-src", mapSrc);
        }

        ensureSvgA11y(container, config.mapLabel);
        applyHighlights(container, activeCodes, config);
      })
      .catch(function (error) {
        console.error("[AFC map] " + error.message);
      });
  }

  function initAll() {
    document.querySelectorAll(MAP_SELECTOR).forEach(initMap);
  }

  if (document.readyState === "loading") {
    document.addEventListener("DOMContentLoaded", initAll);
  } else {
    initAll();
  }

  window.afcMapRefresh = initAll;
})();