package computer.whatthefuck.arcology.publishing

import computer.whatthefuck.arcology.database.RoamRepository
import computer.whatthefuck.arcology.domain.GeoCoordinate
import computer.whatthefuck.arcology.gis.GpxOrgMapping
import kotlinx.serialization.Serializable
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json

/** Knobs from the ARCOLOGY_MAP property (OSMAND_EXTENSIONS-style k=v encoding). */
data class MapPageConfig(
    val key: String?,
    val style: String,
    val center: String?,
    val zoom: Double?,
    val terrain: Boolean
) {
    companion object {
        const val MAP_PROPERTY = "ARCOLOGY_MAP"

        val DEFAULT = MapPageConfig(key = null, style = "streets", center = null, zoom = null, terrain = false)

        /**
         * Fail-soft parse: a bogus knob is skipped, not an error. `center` is
         * validated through GeoCoordinate.parse and re-emitted normalized so
         * " 44.0 , -123.0 " round-trips as "44.0,-123.0" in the JSON blob.
         */
        fun parseRaw(raw: String?): MapPageConfig {
            if (raw.isNullOrBlank()) return DEFAULT
            val knobs = GpxOrgMapping.decodeExtensions(raw)
            val center = knobs["center"]
                ?.takeIf { it.isNotBlank() }
                ?.let { GeoCoordinate.parse(it) }
                ?.let { "${it.latitude},${it.longitude}" }
            val terrain = knobs["terrain"]?.trim()?.lowercase() in setOf("on", "true", "yes")
            return MapPageConfig(
                key = knobs["key"]?.trim()?.takeIf { it.isNotEmpty() },
                style = knobs["style"]?.trim()?.takeIf { it.isNotEmpty() } ?: DEFAULT.style,
                center = center,
                zoom = knobs["zoom"]?.trim()?.takeIf { it.isNotEmpty() }?.toDoubleOrNull(),
                terrain = terrain
            )
        }
    }
}

@Serializable
data class MapMarkerJson(
    val id: String,
    val lat: Double,
    val lon: Double,
    val altitude: Double? = null,
    val title: String? = null,
    val href: String
)

@Serializable
data class MapPageData(
    val key: String,
    val style: String,
    val center: String? = null,
    val zoom: Double? = null,
    val terrain: Boolean = false,
    val markers: List<MapMarkerJson> = emptyList()
)

/**
 * The no-JS fallback list: the map is progressive enhancement, this list is
 * the content. One row per marker, in document order, each row an in-page or
 * cross-site anchor plus a geo: link for the OsmAnd handoff.
 */
data class MapEntry(
    val id: String,
    val title: String?,
    val href: String,
    val geoHref: String,
    val coords: String
)

/** What lands in the PageModel: the raw JSON blob + the fallback rows. */
class MapPageContext(val json: String, val entries: List<MapEntry>)

private val mapPageJson = Json { encodeDefaults = true }

/** Neutralize </ so a title cannot close the enclosing <script> tag early. */
internal fun escapeMapJson(json: String): String = json.replace("</", "<\\/")

/**
 * Build the map-page context for the route entries sharing one published
 * path. Returns null when the rendered subtree holds no markers — the page
 * then behaves exactly like it would under page.peb (minus the map).
 *
 * The MapTiler key resolves in this order: the ARCOLOGY_MAP `key=` knob
 * (org drawer property), then the ARCOLOGY_MAPTILER_KEY process env var,
 * else "". The env var is the recommended carrier — it keeps the key out
 * of the org files entirely — while the knob remains for per-page
 * overrides. `envKey` is a parameter so tests inject explicit values and
 * stay hermetic.
 */
suspend fun buildMapPageContext(
    repository: RoamRepository,
    resolver: LinkResolver,
    entries: List<RouteEntry>,
    envKey: String? = System.getenv("ARCOLOGY_MAPTILER_KEY")?.takeIf { it.isNotBlank() }
): MapPageContext? {
    val firstEntry = entries.firstOrNull() ?: return null
    val effectiveEnvKey = envKey?.takeIf { it.isNotBlank() }

    val rawMap: String? = repository.getHeadingProperty(firstEntry.nodeId, MapPageConfig.MAP_PROPERTY)
        ?: repository.getFileProperties(firstEntry.file)[MapPageConfig.MAP_PROPERTY]
    val config = MapPageConfig.parseRaw(rawMap)

    val entriesById = entries.associateBy { it.nodeId }
    val candidates = repository.getNodesWithLocation()
        .filter { (node, _) -> entries.any { it.file == node.file } }
        .sortedBy { (node, _) -> node.position }
    if (candidates.isEmpty()) return null

    val ancestorsCache = mutableMapOf<String, List<String>>()
    val tagsByNode = repository.getTagsByNodes(candidates.map { it.first.id })
    val excludeNodeIds = tagsByNode
        .filter { (_, tags) -> tags.any { it in EXCLUDE_TAGS } }
        .keys

    val markers = mutableListOf<MapMarkerJson>()
    val noJs = mutableListOf<MapEntry>()
    for ((node, coord) in candidates) {
        if (node.id in excludeNodeIds) continue
        val pageEntry = entriesById.values.firstOrNull { entry ->
            entry.file == node.file && ancestorsCache
                .getOrPut(node.id) { repository.getNodeAncestors(node.id) }
                .contains(entry.nodeId)
        } ?: continue
        val href = resolver.resolveNodeId(node.id) ?: "#${node.id}"
        val latLon = "${coord.latitude},${coord.longitude}"
        markers.add(MapMarkerJson(
            id = node.id,
            lat = coord.latitude,
            lon = coord.longitude,
            altitude = coord.altitude,
            title = node.title,
            href = href
        ))
        noJs.add(MapEntry(
            id = node.id,
            title = node.title,
            href = href,
            geoHref = "geo:$latLon",
            coords = latLon
        ))
    }
    if (markers.isEmpty()) return null

    val data = MapPageData(
        key = config.key ?: effectiveEnvKey ?: "",
        style = config.style,
        center = config.center,
        // zoom without center would anchor the view nowhere; fitBounds instead
        zoom = if (config.center != null) config.zoom else null,
        terrain = config.terrain,
        markers = markers
    )
    return MapPageContext(escapeMapJson(mapPageJson.encodeToString(data)), noJs)
}

{% extends "app.peb" %}

{% block title %}{{ headTitle }}{% endblock %}

{% block extra_head %}
  {% for feed in feeds %}
    <link rel="alternate" type="application/atom+xml" href="{{ feed.url }}" title="{{ feed.title }}"/>
  {% endfor %}
  {% if allowCrawl %}
    <meta name="robots" content=""/>
  {% else %}
    <meta name="robots" content="noarchive noimageindex noindex nofollow"/>
  {% endif %}
  <link href="https://cdn.maptiler.com/maptiler-sdk-js/v4.2.0/maptiler-sdk.css" rel="stylesheet"/>
  <script src="https://cdn.maptiler.com/maptiler-sdk-js/v4.2.0/maptiler-sdk.umd.min.js" defer></script>
  <script src="/static/arcology-map.js" defer></script>
  <style>
    #arcology-map { width: 100%; height: 60vh; min-height: 320px; margin: 0 0 1em 0; }
    .poi-marker {
      display: block; width: 14px; height: 14px; border-radius: 50%;
      background: #8b0000; border: 2px solid #fff;
      box-shadow: 0 0 2px rgba(0,0,0,.5); cursor: pointer;
    }
    .poi-list { padding-left: 1.2em; }
  </style>
{% endblock %}

{% block content %}
  {% if mapDataJson %}
  <script type="application/json" class="arcology-map-data">{{ mapDataJson | raw }}</script>
  {% endif %}
  <div id="arcology-map"></div>
  {% if mapEntries | length > 0 %}
  <ul class="poi-list">
    {% for poi in mapEntries %}
    <li>
      <a href="#" data-poi-id="{{ poi.id }}">{{ poi.title | default("untitled") }}</a>
      &mdash; <a href="{{ poi.geoHref }}">{{ poi.coords }}</a>
    </li>
    {% endfor %}
  </ul>
  {% endif %}
  <main>{{ htmlContent | raw }}</main>
  {{ sidenotesHtml | raw }}
{% endblock %}

(function () {
  "use strict";

  function escapeHtml(s) {
    return String(s == null ? "" : s)
      .replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
      .replace(/"/g, "&quot;");
  }

  var UUID_STYLE_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;

  function resolveStyle(name) {
    var s = String(name || "").trim();
    // Custom styles pass through as strings: a bare UUID (the id MapTiler
    // assigns when a designer style is published), a maptiler:// URI, or a
    // full style.json URL. The SDK's styleToStyle normalizes all three and
    // injects config.apiKey itself; only named reference styles take the
    // MapStyle proxy path below.
    if (UUID_STYLE_RE.test(s) || /^(https?:\/\/|maptiler:\/\/)/i.test(s)) return s;
    var styles = window.maptilersdk && window.maptilersdk.MapStyle;
    if (!styles) return null;
    var parts = s.replace(/_/g, "-").split("-").filter(Boolean);
    if (parts.length === 0) return styles.STREETS;
    var ref = styles[parts[0].toUpperCase()];
    if (!ref) {
      console.warn("arcology-map: unknown MapStyle reference", name);
      return styles.STREETS;
    }
    if (parts.length > 1) {
      var variant = ref[parts[1].toUpperCase()];
      if (variant) return variant;
    }
    return ref;
  }

  function init() {
    var script = document.querySelector('script.arcology-map-data[type="application/json"]');
    var container = document.getElementById("arcology-map");
    if (!script || !container) return;
    if (typeof window.maptilersdk === "undefined") {
      console.warn("arcology-map: maptilersdk not loaded");
      return;
    }
    var data;
    try {
      data = JSON.parse(script.textContent || "{}");
    } catch (e) {
      console.warn("arcology-map: malformed map data", e);
      return;
    }
    var markers = data.markers || [];
    if (!markers.length) return;

    maptilersdk.config.apiKey = data.key || "";
    var options = {
      container: container,
      style: resolveStyle(data.style) || maptilersdk.MapStyle.STREETS
    };
    if (data.terrain) {
      options.terrain = true;
      options.terrainControl = true;
    }
    var staticView = false;
    if (data.center && data.zoom != null) {
      var center = String(data.center).split(",").map(Number);
      options.center = [center[1], center[0]]; // knob is "lat,lon"; SDK wants [lng, lat]
      options.zoom = Number(data.zoom);
      staticView = true;
    }
    var map = new maptilersdk.Map(options);

    var bounds = null;
    var byId = {};
    markers.forEach(function (m) {
      byId[m.id] = m;
      var lat = Number(m.lat);
      var lon = Number(m.lon);
      if (bounds === null) {
        bounds = { minLat: lat, maxLat: lat, minLon: lon, maxLon: lon };
      } else {
        bounds.minLat = Math.min(bounds.minLat, lat);
        bounds.maxLat = Math.max(bounds.maxLat, lat);
        bounds.minLon = Math.min(bounds.minLon, lon);
        bounds.maxLon = Math.max(bounds.maxLon, lon);
      }
      var el = document.createElement("a");
      el.className = "poi-marker";
      el.dataset.headingId = m.id;
      el.href = m.href;
      el.title = m.title || "";
      el.setAttribute("aria-label", m.title || "map marker");
      var sameSite = m.href.indexOf("/") === 0;
      el.addEventListener("click", function (ev) {
        if (!sameSite) return; // cross-site POI: popup links out, default nav
        ev.preventDefault();
        var target = document.getElementById(m.id);
        if (target) {
          target.scrollIntoView({ behavior: "smooth", block: "start" });
        }
        history.replaceState(null, "", "#" + m.id);
      });
      var popupHtml =
        "<strong>" + escapeHtml(m.title || "untitled") + "</strong><br/>" +
        '<a href="' + escapeHtml(m.href) + '">open</a>' +
        ' &middot; <a href="geo:' + lat + "," + lon + '">geo</a>';
      new maptilersdk.Marker({ element: el })
        .setLngLat([lon, lat])
        .setPopup(new maptilersdk.Popup({ offset: 18, maxWidth: "280px" }).setHTML(popupHtml))
        .addTo(map);
    });

    if (!staticView && bounds !== null) {
      map.on("load", function () {
        map.fitBounds(
          [[bounds.minLon, bounds.minLat], [bounds.maxLon, bounds.maxLat]],
          { padding: 60, maxZoom: 16, duration: 0 }
        );
      });
    }

    // Click-anchoring, three surfaces, one delegated handler:
    // - a .poi-list titled link centers the map on its POI (the row's geo:
    //   link stays the OsmAnd handoff; the marker popup stays the
    //   navigation path for cross-site points),
    // - a rendered heading whose id is a marker scrolls the heading into
    //   view and flies the map there,
    // - the map's own DOM marker <a>s handle their own clicks: same-page
    //   hrefs scroll to the heading, cross-site hrefs navigate out.
    document.addEventListener("click", function (ev) {
      var t = ev.target;
      var m = null;
      var link = t && t.closest ? t.closest(".poi-list a[data-poi-id]") : null;
      if (link) {
        m = byId[link.getAttribute("data-poi-id")] || null;
        if (!m) return; // not a marker row — fall through to default nav
        ev.preventDefault(); // centering IS the navigation for this link
        var poiTarget = document.getElementById(m.id);
        // if (poiTarget) {
        //   poiTarget.scrollIntoView({ behavior: "smooth", block: "start" });
        //   if (link.getAttribute("href").indexOf("/") === 0) {
        //     history.replaceState(null, "", "#" + m.id);
        //   }
        // }
      } else {
        var heading = t && t.closest ? t.closest("h1[id], h2[id], h3[id], h4[id], h5[id], h6[id]") : null;
        if (heading) {
          m = byId[heading.id] || null;
          if (m) {
            var headTarget = document.getElementById(heading.id);
            if (headTarget) {
              headTarget.scrollIntoView({ behavior: "smooth", block: "start" });
            }
          }
        }
      }
      if (m) {
        map.flyTo({
          center: [Number(m.lon), Number(m.lat)],
          zoom: Math.max(map.getZoom(), 14),
          speed: 1.2
        });
      }
    });
  }

  init();
})();

package computer.whatthefuck.arcology.publishing

import computer.whatthefuck.arcology.database.RoamRepository
import computer.whatthefuck.arcology.domain.GeoCoordinate
import computer.whatthefuck.arcology.domain.OrgNode
import kotlinx.coroutines.runBlocking
import kotlinx.serialization.json.Json
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertNotNull
import kotlin.test.assertNull
import kotlin.test.assertTrue

class MapPagesTest {

    private val pageEntry = RouteEntry(
        nodeId = "20261010T100000", site = "garden", path = "siuslaw",
        file = "camping.org", title = "Siuslaw", timestamp = "20261010T100000",
        isDraft = false, isArchived = false
    )

    private fun node(
        id: String, file: String = "camping.org", position: Int = 0,
        title: String? = null, props: Map<String, String> = emptyMap()
    ): OrgNode = OrgNode(
        id = id, file = file, level = 2, position = position,
        title = title, properties = props
    )

    private fun coord(lat: Double, lon: Double) = GeoCoordinate.parse("$lat,$lon")!!

    private fun repo(
        nodesWithLocation: List<Pair<OrgNode, GeoCoordinate>>,
        ancestors: Map<String, List<String>> = emptyMap(),
        headingProps: Map<String, Map<String, String?>> = emptyMap(),
        fileProps: Map<String, Map<String, String?>> = emptyMap(),
        tags: Map<String, List<String>> = emptyMap()
    ): RoamRepository = object : EmptyRoamRepository() {
        override suspend fun getNodesWithLocation() = nodesWithLocation
        override suspend fun getNodeAncestors(nodeId: String) = ancestors[nodeId] ?: emptyList()
        override suspend fun getHeadingProperty(nodeId: String, key: String): String? =
            headingProps[nodeId]?.get(key)
        override suspend fun getFileProperties(file: String) = fileProps[file] ?: emptyMap()
        override suspend fun getTagsByNodes(nodeIds: List<String>) =
            nodeIds.mapNotNull { id -> tags[id]?.let { id to it } }.toMap()
    }

    private fun resolver(
        repo: RoamRepository,
        routeIndex: Map<String, RouteEntry> = mapOf(pageEntry.nodeId to pageEntry),
        domainMap: DomainMap = DomainMap.fromMap(mapOf("garden" to "arcology.garden"))
    ): CrossDomainLinkResolver = CrossDomainLinkResolver(
        routeIndex = routeIndex,
        domainMap = domainMap,
        repository = repo,
        currentSite = "garden",
        localhost = false
    )

    private val testJson = Json { ignoreUnknownKeys = true }

    private fun decode(context: MapPageContext): MapPageData =
        testJson.decodeFromString(MapPageData.serializer(), context.json)

    @Test
    fun `markers come from the rendered subtree only`() = runBlocking {
        val inside = node("wpt-1", position = 1, title = "Camp A")
        val outside = node("wpt-2", file = "other.org", position = 2, title = "Elsewhere")
        val repo = repo(
            nodesWithLocation = listOf(
                outside to coord(47.0, -119.0),
                inside to coord(44.0, -123.0)
            ),
            ancestors = mapOf("wpt-1" to listOf("wpt-1", pageEntry.nodeId))
        )
        val ctx = assertNotNull(buildMapPageContext(repo, resolver(repo), listOf(pageEntry)))
        val data = decode(ctx)
        assertEquals(listOf("wpt-1"), data.markers.map { it.id })
        assertEquals(1, ctx.entries.size)
        assertEquals("/siuslaw#wpt-1", ctx.entries.first().href)
        assertEquals("geo:44.0,-123.0", ctx.entries.first().geoHref)
        assertEquals("44.0,-123.0", ctx.entries.first().coords)
    }

    @Test
    fun `entry node itself is a marker via self-inclusive ancestors`() = runBlocking {
        val self = node(pageEntry.nodeId, position = 0, title = "Base camp")
        val repo = repo(
            nodesWithLocation = listOf(self to coord(44.1, -123.1)),
            ancestors = mapOf(pageEntry.nodeId to listOf(pageEntry.nodeId))
        )
        val ctx = assertNotNull(buildMapPageContext(repo, resolver(repo), listOf(pageEntry)))
        assertEquals(listOf(pageEntry.nodeId), decode(ctx).markers.map { it.id })
    }

    @Test
    fun `cross site subtree node gets absolute href`() = runBlocking {
        val foreign = RouteEntry(
            nodeId = "20261009T090000", site = "lionsrear", path = "woods",
            file = "woods.org", title = "Woods", timestamp = null,
            isDraft = false, isArchived = false
        )
        val routeIndex = mapOf(
            pageEntry.nodeId to pageEntry,
            foreign.nodeId to foreign
        )
        val domainMap = DomainMap.fromMap(
            mapOf("garden" to "arcology.garden", "lionsrear" to "thelionsrear.com")
        )
        val trail = node("wpt-3", file = "woods.org", position = 1, title = "Trailhead")
        val repo = repo(
            nodesWithLocation = listOf(trail to coord(44.2, -122.9)),
            ancestors = mapOf("wpt-3" to listOf("wpt-3", "20261009T090000"))
        )
        val ctx = assertNotNull(
            buildMapPageContext(repo, resolver(repo, routeIndex, domainMap), listOf(foreign))
        )
        assertEquals("//thelionsrear.com/woods#wpt-3", ctx.entries.first().href)
    }

    @Test
    fun `exclude-tagged heading never becomes a marker`() = runBlocking {
        val archived = node("wpt-4", position = 3, title = "Secret spot")
        val repo = repo(
            nodesWithLocation = listOf(archived to coord(44.3, -123.2)),
            ancestors = mapOf("wpt-4" to listOf("wpt-4", pageEntry.nodeId)),
            tags = mapOf("wpt-4" to listOf("ARCHIVE"))
        )
        assertNull(buildMapPageContext(repo, resolver(repo), listOf(pageEntry)))
    }

    @Test
    fun `config knobs parse from heading property over file property`() = runBlocking {
        val marker = node("wpt-5", position = 1, title = "Knob camp")
        val withHeading = repo(
            nodesWithLocation = listOf(marker to coord(44.4, -123.3)),
            ancestors = mapOf("wpt-5" to listOf("wpt-5", pageEntry.nodeId)),
            headingProps = mapOf(
                pageEntry.nodeId to mapOf("ARCOLOGY_MAP" to "key=abc; style=outdoor; terrain=on")
            ),
            fileProps = mapOf("camping.org" to mapOf("ARCOLOGY_MAP" to "key=stale"))
        )
        val ctx = assertNotNull(buildMapPageContext(withHeading, resolver(withHeading), listOf(pageEntry)))
        val data = decode(ctx)
        assertEquals("abc", data.key)
        assertEquals("outdoor", data.style)
        assertTrue(data.terrain)

        val fromFileOnly = repo(
            nodesWithLocation = listOf(marker to coord(44.4, -123.3)),
            ancestors = mapOf("wpt-5" to listOf("wpt-5", pageEntry.nodeId)),
            fileProps = mapOf(
                "camping.org" to mapOf("ARCOLOGY_MAP" to "key=filekey; center=44.0,-123.0; zoom=11")
            )
        )
        val ctx2 = assertNotNull(buildMapPageContext(fromFileOnly, resolver(fromFileOnly), listOf(pageEntry)))
        val data2 = decode(ctx2)
        assertEquals("filekey", data2.key)
        assertEquals("44.0,-123.0", data2.center)
        assertEquals(11.0, data2.zoom)
    }

    @Test
    fun `env key fills in when the knob is absent`() = runBlocking {
        val marker = node("wpt-9", position = 1, title = "Env camp")
        val repo = repo(
            nodesWithLocation = listOf(marker to coord(44.8, -123.7)),
            ancestors = mapOf("wpt-9" to listOf("wpt-9", pageEntry.nodeId))
        )
        val ctx = assertNotNull(buildMapPageContext(repo, resolver(repo), listOf(pageEntry), envKey = "envkey"))
        assertEquals("envkey", decode(ctx).key)

        val envAndKnob = repo(
            nodesWithLocation = listOf(marker to coord(44.8, -123.7)),
            ancestors = mapOf("wpt-9" to listOf("wpt-9", pageEntry.nodeId)),
            fileProps = mapOf("camping.org" to mapOf("ARCOLOGY_MAP" to "key=knobkey"))
        )
        val ctx2 = assertNotNull(
            buildMapPageContext(envAndKnob, resolver(envAndKnob), listOf(pageEntry), envKey = "envkey")
        )
        assertEquals("knobkey", decode(ctx2).key)
    }

    @Test
    fun `blank env key is ignored like a missing one`() = runBlocking {
        val marker = node("wpt-10", position = 1, title = "Blank env camp")
        val repo = repo(
            nodesWithLocation = listOf(marker to coord(44.9, -123.8)),
            ancestors = mapOf("wpt-10" to listOf("wpt-10", pageEntry.nodeId))
        )
        val ctx = assertNotNull(buildMapPageContext(repo, resolver(repo), listOf(pageEntry), envKey = "  "))
        assertEquals("", decode(ctx).key)
    }

    @Test
    fun `zoom without center is ignored and junk knobs fail soft`() = runBlocking {
        val marker = node("wpt-6", position = 1, title = "Soft camp")
        val repo = repo(
            nodesWithLocation = listOf(marker to coord(44.5, -123.4)),
            ancestors = mapOf("wpt-6" to listOf("wpt-6", pageEntry.nodeId)),
            fileProps = mapOf(
                "camping.org" to mapOf("ARCOLOGY_MAP" to "zoom=9; center=nope; style=")
            )
        )
        val ctx = assertNotNull(buildMapPageContext(repo, resolver(repo), listOf(pageEntry)))
        val data = decode(ctx)
        assertNull(data.center)
        assertNull(data.zoom)
        assertEquals("streets", data.style)
        assertFalse(data.terrain)
    }

    @Test
    fun `no markers means no map context`() = runBlocking {
        val repo = repo(
            nodesWithLocation = listOf(node("wpt-7", file = "elsewhere.org") to coord(44.6, -123.5))
        )
        assertNull(buildMapPageContext(repo, resolver(repo), listOf(pageEntry)))
    }

    @Test
    fun `map json neutralizes script closers`() = runBlocking {
        val marker = node("wpt-8", position = 1, title = "Evil</script>spot")
        val repo = repo(
            nodesWithLocation = listOf(marker to coord(44.7, -123.6)),
            ancestors = mapOf("wpt-8" to listOf("wpt-8", pageEntry.nodeId))
        )
        val ctx = assertNotNull(buildMapPageContext(repo, resolver(repo), listOf(pageEntry)))
        assertFalse(ctx.json.contains("</script>"))
        assertTrue(ctx.json.contains("<\\/script>"))
        assertEquals("Evil</script>spot", decode(ctx).markers.first().title)
    }

    @Test
    fun `MapPageConfig defaults and terrain spellings`() {
        val default = MapPageConfig.parseRaw(null)
        assertEquals("streets", default.style)
        assertNull(default.key)
        assertFalse(default.terrain)
        assertTrue(MapPageConfig.parseRaw("terrain=YES").terrain)
        assertTrue(MapPageConfig.parseRaw("terrain=on").terrain)
        assertFalse(MapPageConfig.parseRaw("terrain=off").terrain)
        assertEquals(9.0, MapPageConfig.parseRaw("zoom=9").zoom)
        assertNull(MapPageConfig.parseRaw("zoom=bogus").zoom)
        assertEquals("44.0,-123.0", MapPageConfig.parseRaw("center= 44.0 , -123.0 ").center)
        assertNull(MapPageConfig.parseRaw("center=a,b").center)
    }

}

<<map-pages-config>>
<<map-pages-builder>>

<<map-pages-test-prelude>>
<<map-pages-test-cases>>
<<map-pages-test-end>>