/**
 * mapRenderer.test.ts — Tests for all mapRenderer.ts behavioral contracts
 *
 * Tests mock Leaflet, DOM APIs, and CSS variable access.
 * Each contract from the spec has its own describe block.
 *
 * @vitest-environment jsdom
 */
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import type { Place } from "../src/parser";

// ─── Helpers ──────────────────────────────────────────────────────────

function makePlace(
  name: string,
  overrides: Partial<Place> = {}
): Place {
  return {
    name,
    fields: {},
    notes: [],
    startLine: 0,
    endLine: 0,
    ...overrides,
  };
}

// ─── Leaflet Mock ─────────────────────────────────────────────────────

// We build a comprehensive mock of the Leaflet APIs used by mapRenderer.
// Each test gets a fresh set of mock objects.

interface MockMarker {
  setLatLng: ReturnType<typeof vi.fn>;
  setIcon: ReturnType<typeof vi.fn>;
  bindPopup: ReturnType<typeof vi.fn>;
  openPopup: ReturnType<typeof vi.fn>;
  on: ReturnType<typeof vi.fn>;
  off: ReturnType<typeof vi.fn>;
  addTo: ReturnType<typeof vi.fn>;
  remove: ReturnType<typeof vi.fn>;
  getLatLng: ReturnType<typeof vi.fn>;
  _latlng: { lat: number; lng: number };
  _events: Record<string, ((...args: unknown[]) => void)[]>;
}

interface MockCircleMarker {
  addTo: ReturnType<typeof vi.fn>;
  remove: ReturnType<typeof vi.fn>;
  setLatLng: ReturnType<typeof vi.fn>;
  getElement: ReturnType<typeof vi.fn>;
}

interface MockMap {
  setView: ReturnType<typeof vi.fn>;
  fitBounds: ReturnType<typeof vi.fn>;
  remove: ReturnType<typeof vi.fn>;
  invalidateSize: ReturnType<typeof vi.fn>;
  getZoom: ReturnType<typeof vi.fn>;
  on: ReturnType<typeof vi.fn>;
  off: ReturnType<typeof vi.fn>;
  _events: Record<string, ((...args: unknown[]) => void)[]>;
}

interface MockTileLayer {
  addTo: ReturnType<typeof vi.fn>;
}

interface MockLayerGroup {
  addTo: ReturnType<typeof vi.fn>;
  clearLayers: ReturnType<typeof vi.fn>;
  addLayer: ReturnType<typeof vi.fn>;
  getLayers: ReturnType<typeof vi.fn>;
  eachLayer: ReturnType<typeof vi.fn>;
}

interface MockIcon {
  options: Record<string, unknown>;
}

interface MockLatLngBounds {
  extend: ReturnType<typeof vi.fn>;
  isValid: ReturnType<typeof vi.fn>;
  getCenter: ReturnType<typeof vi.fn>;
  pad: ReturnType<typeof vi.fn>;
}

let mockMapInstance: MockMap;
let mockMarkers: MockMarker[];
let mockCircleMarkers: MockCircleMarker[];
let mockTileLayer: MockTileLayer;
let mockLayerGroup: MockLayerGroup;
let mockIcons: MockIcon[];
let mockBounds: MockLatLngBounds;

function createMockMarker(lat: number, lng: number): MockMarker {
  const marker: MockMarker = {
    setLatLng: vi.fn().mockReturnThis(),
    setIcon: vi.fn().mockReturnThis(),
    bindPopup: vi.fn().mockReturnThis(),
    openPopup: vi.fn().mockReturnThis(),
    on: vi.fn().mockImplementation(function (this: MockMarker, event: string, handler: (...args: unknown[]) => void) {
      if (!this._events[event]) this._events[event] = [];
      this._events[event].push(handler);
      return this;
    }),
    off: vi.fn().mockReturnThis(),
    addTo: vi.fn().mockReturnThis(),
    remove: vi.fn().mockReturnThis(),
    getLatLng: vi.fn().mockReturnValue({ lat, lng }),
    _latlng: { lat, lng },
    _events: {},
  };
  mockMarkers.push(marker);
  return marker;
}

function createMockCircleMarker(): MockCircleMarker {
  const cm: MockCircleMarker = {
    addTo: vi.fn().mockReturnThis(),
    remove: vi.fn().mockReturnThis(),
    setLatLng: vi.fn().mockReturnThis(),
    getElement: vi.fn().mockReturnValue(document.createElement("div")),
  };
  mockCircleMarkers.push(cm);
  return cm;
}

function setupLeafletMock(): typeof import("leaflet") {
  mockMapInstance = {
    setView: vi.fn().mockReturnThis(),
    fitBounds: vi.fn().mockReturnThis(),
    remove: vi.fn(),
    invalidateSize: vi.fn(),
    getZoom: vi.fn().mockReturnValue(2),
    on: vi.fn().mockImplementation(function (this: MockMap, event: string, handler: (...args: unknown[]) => void) {
      if (!this._events[event]) this._events[event] = [];
      this._events[event].push(handler);
      return this;
    }),
    off: vi.fn().mockReturnThis(),
    _events: {},
  };

  mockTileLayer = {
    addTo: vi.fn().mockReturnThis(),
  };

  mockLayerGroup = {
    addTo: vi.fn().mockReturnThis(),
    clearLayers: vi.fn(),
    addLayer: vi.fn(),
    getLayers: vi.fn().mockReturnValue([]),
    eachLayer: vi.fn(),
  };

  mockBounds = {
    extend: vi.fn().mockReturnThis(),
    isValid: vi.fn().mockReturnValue(true),
    getCenter: vi.fn().mockReturnValue({ lat: 0, lng: 0 }),
    pad: vi.fn().mockReturnThis(),
  };

  const L = {
    map: vi.fn().mockReturnValue(mockMapInstance),
    tileLayer: vi.fn().mockReturnValue(mockTileLayer),
    layerGroup: vi.fn().mockReturnValue(mockLayerGroup),
    marker: vi.fn().mockImplementation((latlng: [number, number]) => {
      return createMockMarker(latlng[0], latlng[1]);
    }),
    circleMarker: vi.fn().mockImplementation(() => {
      return createMockCircleMarker();
    }),
    divIcon: vi.fn().mockImplementation((opts: Record<string, unknown>) => {
      const icon: MockIcon = { options: opts };
      mockIcons.push(icon);
      return icon;
    }),
    icon: vi.fn().mockImplementation((opts: Record<string, unknown>) => {
      const icon: MockIcon = { options: opts };
      mockIcons.push(icon);
      return icon;
    }),
    latLngBounds: vi.fn().mockReturnValue(mockBounds),
    latLng: vi.fn().mockImplementation((lat: number, lng: number) => ({ lat, lng })),
    DomEvent: {
      stopPropagation: vi.fn(),
      stop: vi.fn(),
    },
    Util: {
      stamp: vi.fn().mockReturnValue(1),
    },
  };

  return L as unknown as typeof import("leaflet");
}

// ─── Mock ResizeObserver ──────────────────────────────────────────────

let resizeObserverCallback: ResizeObserverCallback | null = null;
let resizeObserverDisconnected = false;

class MockResizeObserver {
  callback: ResizeObserverCallback;
  constructor(callback: ResizeObserverCallback) {
    this.callback = callback;
    resizeObserverCallback = callback;
    resizeObserverDisconnected = false;
  }
  observe() {}
  unobserve() {}
  disconnect() {
    resizeObserverDisconnected = true;
  }
}

// ─── Test Setup ───────────────────────────────────────────────────────

let L: ReturnType<typeof setupLeafletMock>;
let createMap: typeof import("../src/mapRenderer").createMap;

beforeEach(async () => {
  mockMarkers = [];
  mockCircleMarkers = [];
  mockIcons = [];

  L = setupLeafletMock();

  // Mock leaflet module
  vi.doMock("leaflet", () => ({ default: L, ...L }));

  // Mock ResizeObserver globally
  vi.stubGlobal("ResizeObserver", MockResizeObserver);
  resizeObserverCallback = null;
  resizeObserverDisconnected = false;

  // Mock getComputedStyle for CSS variable access
  vi.stubGlobal(
    "getComputedStyle",
    vi.fn().mockReturnValue({
      getPropertyValue: vi.fn().mockImplementation((prop: string) => {
        if (prop === "--interactive-accent") return "#7b6cd9";
        return "";
      }),
    })
  );

  // Import fresh module for each test
  const mod = await import("../src/mapRenderer");
  createMap = mod.createMap;
});

afterEach(() => {
  vi.restoreAllMocks();
  vi.resetModules();
  vi.unstubAllGlobals();
});

// ─── Contract 1: Leaflet CSS injection ────────────────────────────────

describe("Contract 1: Leaflet CSS injection", () => {
  it("injects a <style> tag with id='leaflet-css' into document.head", () => {
    const container = document.createElement("div");
    createMap(container, [], {});

    const style = document.getElementById("leaflet-css");
    expect(style).not.toBeNull();
    expect(style?.tagName.toLowerCase()).toBe("style");
  });

  it("does not inject a second <style> tag on repeat calls (idempotent)", () => {
    const container1 = document.createElement("div");
    const container2 = document.createElement("div");
    createMap(container1, [], {});
    const ctrl2 = createMap(container2, [], {});

    const styles = document.querySelectorAll("#leaflet-css");
    expect(styles.length).toBe(1);

    ctrl2.destroy();
  });
});

// ─── Contract 2: Map container setup ──────────────────────────────────

describe("Contract 2: Map container div", () => {
  it("creates a child div with class 'map-viewer-map' inside container", () => {
    const container = document.createElement("div");
    createMap(container, [], {});

    const mapDiv = container.querySelector(".map-viewer-map");
    expect(mapDiv).not.toBeNull();
  });

  it("passes the map div to L.map()", () => {
    const container = document.createElement("div");
    createMap(container, [], {});

    expect(L.map).toHaveBeenCalledTimes(1);
    const mapDiv = container.querySelector(".map-viewer-map");
    expect(L.map).toHaveBeenCalledWith(mapDiv, expect.anything());
  });
});

// ─── Contract 3: Tile layers ──────────────────────────────────────────

describe("Contract 3: Tile layers", () => {
  it("creates Cooper Hewitt Watercolor base layer", () => {
    const container = document.createElement("div");
    createMap(container, [], {});

    const calls = (L.tileLayer as ReturnType<typeof vi.fn>).mock.calls;
    const watercolorCall = calls.find(
      (c: unknown[]) =>
        typeof c[0] === "string" &&
        c[0].includes("watercolor")
    );
    expect(watercolorCall).toBeDefined();
    expect(watercolorCall![0]).toContain("watercolormaps.collection.cooperhewitt.org");
  });

  it("creates CartoDB Light Labels overlay", () => {
    const container = document.createElement("div");
    createMap(container, [], {});

    const calls = (L.tileLayer as ReturnType<typeof vi.fn>).mock.calls;
    const labelsCall = calls.find(
      (c: unknown[]) =>
        typeof c[0] === "string" &&
        c[0].includes("light_only_labels")
    );
    expect(labelsCall).toBeDefined();
    expect(labelsCall![0]).toContain("basemaps.cartocdn.com");
  });

  it("adds both tile layers to the map", () => {
    const container = document.createElement("div");
    createMap(container, [], {});

    // tileLayer is called twice, each result gets addTo called
    expect(L.tileLayer).toHaveBeenCalledTimes(2);
    expect(mockTileLayer.addTo).toHaveBeenCalledTimes(2);
  });
});

// ─── Contract 4: Marker grouping by identical lat/lng ─────────────────

describe("Contract 4: Marker grouping by toFixed(6)", () => {
  it("creates one marker for two places at the exact same coordinates", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.403600, lng: 2.174400, startLine: 0 }),
      makePlace("Place B", { lat: 41.403600, lng: 2.174400, startLine: 3 }),
    ];
    createMap(container, places, {});

    // Only one L.marker call despite two places
    expect(L.marker).toHaveBeenCalledTimes(1);
  });

  it("creates separate markers for places at different coordinates", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.403600, lng: 2.174400, startLine: 0 }),
      makePlace("Place B", { lat: 48.860600, lng: 2.337600, startLine: 3 }),
    ];
    createMap(container, places, {});

    expect(L.marker).toHaveBeenCalledTimes(2);
  });

  it("groups using toFixed(6) — tiny differences below precision are merged", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036001, lng: 2.1744001, startLine: 0 }),
      makePlace("Place B", { lat: 41.4036002, lng: 2.1744002, startLine: 3 }),
    ];
    createMap(container, places, {});

    // Both round to 41.403600, 2.174400 — should be one marker
    expect(L.marker).toHaveBeenCalledTimes(1);
  });

  it("does not group places where toFixed(6) differs", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.403600, lng: 2.174400, startLine: 0 }),
      makePlace("Place B", { lat: 41.403601, lng: 2.174400, startLine: 3 }),
    ];
    createMap(container, places, {});

    // 41.403600 vs 41.403601 — different at 6th decimal
    expect(L.marker).toHaveBeenCalledTimes(2);
  });
});

// ─── Contract 5: Custom SVG teardrop pin icons ────────────────────────

describe("Contract 5: SVG teardrop pin icons", () => {
  it("creates markers with a custom divIcon containing SVG", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    createMap(container, places, {});

    // Should use divIcon for the marker
    expect(L.divIcon).toHaveBeenCalled();
    const iconOpts = mockIcons[0]?.options;
    expect(iconOpts).toBeDefined();
    // The icon HTML should contain an SVG
    const html = iconOpts?.html as string;
    expect(html).toBeDefined();
    expect(html.toLowerCase()).toContain("<svg");
    expect(html.toLowerCase()).toContain("teardrop");
  });

  it("uses --interactive-accent CSS variable for fill color", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    createMap(container, places, {});

    const iconOpts = mockIcons[0]?.options;
    const html = iconOpts?.html as string;
    // Should contain the accent color from CSS variable
    expect(html).toContain("#7b6cd9");
  });

  it("uses a darkened stroke color (25% darker than fill)", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    createMap(container, places, {});

    const iconOpts = mockIcons[0]?.options;
    const html = iconOpts?.html as string;
    // Stroke should be present and different from fill
    // The exact darkened color depends on implementation, but it should have a stroke
    expect(html.toLowerCase()).toContain("stroke");
  });
});

// ─── Contract 6: Marker click → onPlaceSelect ────────────────────────

describe("Contract 6: Marker click calls onPlaceSelect", () => {
  it("calls onPlaceSelect with all places at the marker's location on click", () => {
    const container = document.createElement("div");
    const onPlaceSelect = vi.fn();
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
      makePlace("Place B", { lat: 41.4036, lng: 2.1744, startLine: 3 }),
    ];
    createMap(container, places, { onPlaceSelect });

    // Simulate click on the marker
    const marker = mockMarkers[0];
    expect(marker.on).toHaveBeenCalled();
    const clickHandler = marker._events["click"]?.[0];
    expect(clickHandler).toBeDefined();
    clickHandler!({});

    expect(onPlaceSelect).toHaveBeenCalledTimes(1);
    const calledWith = onPlaceSelect.mock.calls[0][0];
    expect(calledWith).toHaveLength(2);
    expect(calledWith[0].name).toBe("Place A");
    expect(calledWith[1].name).toBe("Place B");
  });

  it("shows popup with place names on marker click", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    createMap(container, places, {});

    // Marker should have popup bound
    const marker = mockMarkers[0];
    expect(marker.bindPopup).toHaveBeenCalled();
  });

  it("popup shows linked name if place has url, plain text otherwise", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", {
        lat: 41.4036,
        lng: 2.1744,
        startLine: 0,
        url: "https://example.com",
      }),
      makePlace("Place B", {
        lat: 41.4036,
        lng: 2.1744,
        startLine: 3,
      }),
    ];
    createMap(container, places, {});

    const marker = mockMarkers[0];
    const popupContent = marker.bindPopup.mock.calls[0][0] as string;

    // Should contain an <a> for Place A (has url)
    expect(popupContent).toContain("<a");
    expect(popupContent).toContain("https://example.com");
    expect(popupContent).toContain("Place A");

    // Place B should be plain text (no url)
    expect(popupContent).toContain("Place B");
  });

  it("uses L.DomEvent.stopPropagation on marker click", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    createMap(container, places, {});

    const marker = mockMarkers[0];
    const clickHandler = marker._events["click"]?.[0];
    expect(clickHandler).toBeDefined();

    const fakeEvent = { originalEvent: new Event("click") };
    clickHandler!(fakeEvent);

    expect(L.DomEvent.stopPropagation).toHaveBeenCalled();
  });
});

// ─── Contract 7: selectPlace by startLine ─────────────────────────────

describe("Contract 7: selectPlace matches by startLine", () => {
  it("pans/zooms to the marker matching the place's startLine", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
      makePlace("Place B", { lat: 48.8606, lng: 2.3376, startLine: 5 }),
    ];
    const ctrl = createMap(container, places, {});

    ctrl.selectPlace(places[1]);

    // Should pan to Place B
    expect(mockMapInstance.setView).toHaveBeenCalled();
  });

  it("selects the group marker if the place is part of a group", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
      makePlace("Place B", { lat: 41.4036, lng: 2.1744, startLine: 3 }),
    ];
    const ctrl = createMap(container, places, {});

    // Select Place B — should select the shared marker
    ctrl.selectPlace(places[1]);

    // Should still pan to the grouped marker location
    expect(mockMapInstance.setView).toHaveBeenCalled();
  });

  it("shows a highlight ring (CircleMarker) on selection", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    const ctrl = createMap(container, places, {});

    ctrl.selectPlace(places[0]);

    // A CircleMarker should be created for the highlight
    expect(L.circleMarker).toHaveBeenCalled();
    expect(mockCircleMarkers.length).toBeGreaterThan(0);
    expect(mockCircleMarkers[0].addTo).toHaveBeenCalled();
  });
});

// ─── Contract 8: selectPlace(null) removes highlight ──────────────────

describe("Contract 8: selectPlace(null) deselects", () => {
  it("removes highlight ring when selectPlace(null) is called", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    const ctrl = createMap(container, places, {});

    ctrl.selectPlace(places[0]);
    expect(mockCircleMarkers.length).toBeGreaterThan(0);

    ctrl.selectPlace(null);
    expect(mockCircleMarkers[0].remove).toHaveBeenCalled();
  });

  it("does nothing if no place is selected and selectPlace(null) is called", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});

    // Should not throw
    expect(() => ctrl.selectPlace(null)).not.toThrow();
  });
});

// ─── Contract 9: updateMarkers clears and recreates ───────────────────

describe("Contract 9: updateMarkers clears and recreates", () => {
  it("clears all existing markers on updateMarkers", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    const ctrl = createMap(container, places, {});

    const newPlaces = [
      makePlace("Place C", { lat: 35.659, lng: 139.700, startLine: 0 }),
    ];
    ctrl.updateMarkers(newPlaces);

    // Old markers should be removed
    expect(mockMarkers[0].remove).toHaveBeenCalled();
  });

  it("removes highlight ring on updateMarkers", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    const ctrl = createMap(container, places, {});

    ctrl.selectPlace(places[0]);
    expect(mockCircleMarkers.length).toBeGreaterThan(0);

    ctrl.updateMarkers([]);

    // Highlight should be removed
    expect(mockCircleMarkers[0].remove).toHaveBeenCalled();
  });

  it("creates new markers from the provided places", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});

    const markerCountBefore = mockMarkers.length;

    const newPlaces = [
      makePlace("Place C", { lat: 35.659, lng: 139.700, startLine: 0 }),
      makePlace("Place D", { lat: 48.8606, lng: 2.3376, startLine: 3 }),
    ];
    ctrl.updateMarkers(newPlaces);

    // New markers should be created
    expect(mockMarkers.length).toBeGreaterThan(markerCountBefore);
  });

  it("fits bounds by default (fitBounds=true)", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});

    const newPlaces = [
      makePlace("Place C", { lat: 35.659, lng: 139.700, startLine: 0 }),
      makePlace("Place D", { lat: 48.8606, lng: 2.3376, startLine: 3 }),
    ];
    ctrl.updateMarkers(newPlaces);

    expect(mockMapInstance.fitBounds).toHaveBeenCalled();
  });

  it("does not fit bounds when fitBounds=false", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});

    // Reset any calls from initial createMap (which sets default world view)
    mockMapInstance.fitBounds.mockClear();
    mockMapInstance.setView.mockClear();

    const newPlaces = [
      makePlace("Place C", { lat: 35.659, lng: 139.700, startLine: 0 }),
    ];
    ctrl.updateMarkers(newPlaces, false);

    // Neither fitBounds nor setView should be called by updateMarkers when fitBounds=false
    expect(mockMapInstance.fitBounds).not.toHaveBeenCalled();
    expect(mockMapInstance.setView).not.toHaveBeenCalled();
  });
});

// ─── Contract 10: fitBounds behavior ──────────────────────────────────

describe("Contract 10: fitBounds behavior", () => {
  it("does nothing with zero markers (preserves current view)", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});

    // Clear initial calls
    mockMapInstance.fitBounds.mockClear();
    mockMapInstance.setView.mockClear();

    ctrl.fitBounds();

    expect(mockMapInstance.fitBounds).not.toHaveBeenCalled();
    expect(mockMapInstance.setView).not.toHaveBeenCalled();
  });

  it("centers on single marker at zoom 13", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    const ctrl = createMap(container, places, {});

    // Clear initial calls
    mockMapInstance.setView.mockClear();

    ctrl.fitBounds();

    expect(mockMapInstance.setView).toHaveBeenCalledWith(
      expect.objectContaining({ lat: 41.4036, lng: 2.1744 }),
      13
    );
  });

  it("fits bounds to show all markers with multiple places", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
      makePlace("Place B", { lat: 48.8606, lng: 2.3376, startLine: 3 }),
    ];
    const ctrl = createMap(container, places, {});

    // Clear initial calls
    mockMapInstance.fitBounds.mockClear();

    ctrl.fitBounds();

    expect(mockMapInstance.fitBounds).toHaveBeenCalled();
  });
});

// ─── Contract 11: invalidateSize ──────────────────────────────────────

describe("Contract 11: invalidateSize", () => {
  it("calls Leaflet's invalidateSize()", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});

    ctrl.invalidateSize();

    expect(mockMapInstance.invalidateSize).toHaveBeenCalled();
  });
});

// ─── Contract 12: destroy ─────────────────────────────────────────────

describe("Contract 12: destroy", () => {
  it("removes the Leaflet map instance", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});

    ctrl.destroy();

    expect(mockMapInstance.remove).toHaveBeenCalled();
  });

  it("removes the map div from the container", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});

    expect(container.querySelector(".map-viewer-map")).not.toBeNull();

    ctrl.destroy();

    expect(container.querySelector(".map-viewer-map")).toBeNull();
  });

  it("calling destroy() twice does not throw", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});

    ctrl.destroy();
    expect(() => ctrl.destroy()).not.toThrow();
  });
});

// ─── Contract 13: ResizeObserver ──────────────────────────────────────

describe("Contract 13: ResizeObserver", () => {
  it("creates a ResizeObserver on the map container", () => {
    const container = document.createElement("div");
    createMap(container, [], {});

    expect(resizeObserverCallback).not.toBeNull();
  });

  it("calls invalidateSize when the container resizes", () => {
    const container = document.createElement("div");
    createMap(container, [], {});

    expect(resizeObserverCallback).not.toBeNull();

    // Simulate a resize event
    resizeObserverCallback!(
      [{ contentRect: { width: 500, height: 400 } }] as unknown as ResizeObserverEntry[],
      {} as ResizeObserver
    );

    expect(mockMapInstance.invalidateSize).toHaveBeenCalled();
  });

  it("disconnects ResizeObserver on destroy()", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});

    ctrl.destroy();

    expect(resizeObserverDisconnected).toBe(true);
  });
});

// ─── Edge Cases ───────────────────────────────────────────────────────

describe("Edge cases", () => {
  it("zero places → map shows default world view (center [20, 0], zoom 2)", () => {
    const container = document.createElement("div");
    createMap(container, [], {});

    expect(mockMapInstance.setView).toHaveBeenCalledWith(
      [20, 0],
      2
    );
  });

  it("single place → map centers on it at zoom 13", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    createMap(container, places, {});

    expect(mockMapInstance.setView).toHaveBeenCalledWith(
      expect.objectContaining({ lat: 41.4036, lng: 2.1744 }),
      13
    );
  });

  it("places without lat/lng are silently excluded from markers", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("No Coords", { startLine: 0 }),
      makePlace("Has Coords", { lat: 41.4036, lng: 2.1744, startLine: 3 }),
    ];
    createMap(container, places, {});

    // Only one marker should be created (for the place with coords)
    expect(L.marker).toHaveBeenCalledTimes(1);
  });

  it("all places at same location → single marker, popup lists all names", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
      makePlace("Place B", { lat: 41.4036, lng: 2.1744, startLine: 3 }),
      makePlace("Place C", { lat: 41.4036, lng: 2.1744, startLine: 6 }),
    ];
    createMap(container, places, {});

    expect(L.marker).toHaveBeenCalledTimes(1);

    const marker = mockMarkers[0];
    const popupContent = marker.bindPopup.mock.calls[0][0] as string;
    expect(popupContent).toContain("Place A");
    expect(popupContent).toContain("Place B");
    expect(popupContent).toContain("Place C");
  });

  it("places with only lat but no lng are excluded from markers", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Half Place", { lat: 41.4036, startLine: 0 }),
    ];
    createMap(container, places, {});

    expect(L.marker).not.toHaveBeenCalled();
  });

  it("places with only lng but no lat are excluded from markers", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Half Place", { lng: 2.1744, startLine: 0 }),
    ];
    createMap(container, places, {});

    expect(L.marker).not.toHaveBeenCalled();
  });

  it("selectPlace with a place not in the current markers does nothing", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    const ctrl = createMap(container, places, {});

    const unknownPlace = makePlace("Unknown", {
      lat: 99, lng: 99, startLine: 999,
    });

    // Should not throw
    expect(() => ctrl.selectPlace(unknownPlace)).not.toThrow();
  });
});

// ─── Adversary-identified gaps: destroyed-state methods ───────────────

describe("Post-destroy safety", () => {
  it("updateMarkers is a no-op after destroy", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});
    ctrl.destroy();

    const markerCountBefore = mockMarkers.length;
    ctrl.updateMarkers([
      makePlace("X", { lat: 10, lng: 20, startLine: 0 }),
    ]);

    // No new markers should be created
    expect(mockMarkers.length).toBe(markerCountBefore);
  });

  it("selectPlace is a no-op after destroy", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("A", { lat: 10, lng: 20, startLine: 0 }),
    ];
    const ctrl = createMap(container, places, {});
    ctrl.destroy();

    // Should not throw or create highlight
    const cmCountBefore = mockCircleMarkers.length;
    expect(() => ctrl.selectPlace(places[0])).not.toThrow();
    expect(mockCircleMarkers.length).toBe(cmCountBefore);
  });

  it("fitBounds is a no-op after destroy", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});
    ctrl.destroy();

    mockMapInstance.fitBounds.mockClear();
    mockMapInstance.setView.mockClear();

    expect(() => ctrl.fitBounds()).not.toThrow();
    expect(mockMapInstance.fitBounds).not.toHaveBeenCalled();
    expect(mockMapInstance.setView).not.toHaveBeenCalled();
  });

  it("invalidateSize is a no-op after destroy", () => {
    const container = document.createElement("div");
    const ctrl = createMap(container, [], {});
    ctrl.destroy();

    mockMapInstance.invalidateSize.mockClear();

    expect(() => ctrl.invalidateSize()).not.toThrow();
    expect(mockMapInstance.invalidateSize).not.toHaveBeenCalled();
  });
});

// ─── Adversary-identified gaps: XSS and HTML escaping ─────────────────

describe("Popup security: XSS prevention", () => {
  it("escapes HTML entities in place names in popup content", () => {
    const container = document.createElement("div");
    const places = [
      makePlace('<script>alert("xss")</script>', {
        lat: 41.4036,
        lng: 2.1744,
        startLine: 0,
      }),
    ];
    createMap(container, places, {});

    const marker = mockMarkers[0];
    const popupContent = marker.bindPopup.mock.calls[0][0] as string;

    expect(popupContent).not.toContain("<script>");
    expect(popupContent).toContain("&lt;script&gt;");
  });

  it("escapes URLs in popup href attributes to prevent attribute breakout", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Evil Place", {
        lat: 41.4036,
        lng: 2.1744,
        startLine: 0,
        url: '" onclick="alert(1)',
      }),
    ];
    createMap(container, places, {});

    const marker = mockMarkers[0];
    const popupContent = marker.bindPopup.mock.calls[0][0] as string;

    // The double quote in the URL should be escaped
    expect(popupContent).not.toContain('href="" onclick');
    expect(popupContent).toContain("&quot;");
  });

  it("rejects javascript: protocol URLs in popup links", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Malicious", {
        lat: 41.4036,
        lng: 2.1744,
        startLine: 0,
        url: "javascript:alert(1)",
      }),
    ];
    createMap(container, places, {});

    const marker = mockMarkers[0];
    const popupContent = marker.bindPopup.mock.calls[0][0] as string;

    // Should NOT contain an <a> tag with javascript: URL
    expect(popupContent).not.toContain("javascript:");
    expect(popupContent).not.toContain("<a");
  });

  it("escapes single quotes in popup content", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("O'Malley's Pub", {
        lat: 41.4036,
        lng: 2.1744,
        startLine: 0,
      }),
    ];
    createMap(container, places, {});

    const marker = mockMarkers[0];
    const popupContent = marker.bindPopup.mock.calls[0][0] as string;

    expect(popupContent).toContain("&#39;");
    expect(popupContent).not.toContain("O'Malley");
  });
});

// ─── Adversary-identified gaps: click with no callback ────────────────

describe("Marker click with no onPlaceSelect callback", () => {
  it("does not throw when clicking a marker with no onPlaceSelect provided", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    createMap(container, places, {});

    const marker = mockMarkers[0];
    const clickHandler = marker._events["click"]?.[0];
    expect(clickHandler).toBeDefined();

    // Click with empty callbacks — should not throw
    expect(() => clickHandler!({})).not.toThrow();
  });
});

// ─── Adversary-identified gaps: highlight ring className ──────────────

describe("Highlight ring CSS class", () => {
  it("circleMarker is created with className 'map-marker-highlight'", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    const ctrl = createMap(container, places, {});

    ctrl.selectPlace(places[0]);

    expect(L.circleMarker).toHaveBeenCalled();
    const cmCall = (L.circleMarker as ReturnType<typeof vi.fn>).mock.calls[0];
    const options = cmCall[1];
    expect(options.className).toBe("map-marker-highlight");
  });
});

// ─── Adversary-identified gaps: selectPlace zoom behavior ─────────────

describe("selectPlace zoom behavior", () => {
  it("does not zoom out if already zoomed in past 13", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    const ctrl = createMap(container, places, {});

    // Simulate the user being zoomed in to level 18
    mockMapInstance.getZoom.mockReturnValue(18);
    mockMapInstance.setView.mockClear();

    ctrl.selectPlace(places[0]);

    // Should use zoom 18 (current), not 13
    expect(mockMapInstance.setView).toHaveBeenCalledWith(
      expect.objectContaining({ lat: 41.4036, lng: 2.1744 }),
      18
    );
  });

  it("zooms in to 13 if currently zoomed out further", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
    ];
    const ctrl = createMap(container, places, {});

    // Simulate the user being zoomed out to level 5
    mockMapInstance.getZoom.mockReturnValue(5);
    mockMapInstance.setView.mockClear();

    ctrl.selectPlace(places[0]);

    // Should use zoom 13 (minimum for selection)
    expect(mockMapInstance.setView).toHaveBeenCalledWith(
      expect.objectContaining({ lat: 41.4036, lng: 2.1744 }),
      13
    );
  });
});

// ─── Adversary-identified gaps: sequential selectPlace ────────────────

describe("Sequential selectPlace removes previous highlight", () => {
  it("removes old highlight ring before creating new one", () => {
    const container = document.createElement("div");
    const places = [
      makePlace("Place A", { lat: 41.4036, lng: 2.1744, startLine: 0 }),
      makePlace("Place B", { lat: 48.8606, lng: 2.3376, startLine: 5 }),
    ];
    const ctrl = createMap(container, places, {});

    ctrl.selectPlace(places[0]);
    expect(mockCircleMarkers).toHaveLength(1);
    const firstRing = mockCircleMarkers[0];

    ctrl.selectPlace(places[1]);

    // First ring should have been removed
    expect(firstRing.remove).toHaveBeenCalled();
    // A new ring should have been created
    expect(mockCircleMarkers).toHaveLength(2);
    expect(mockCircleMarkers[1].addTo).toHaveBeenCalled();
  });
});