import assert from "node:assert/strict"
import test from "node:test"

import {
  clusterCountLabel,
  clusterExpansionCenter,
  clusterExpansionTarget,
  clusterIconDescriptor,
  clusterSizeClass,
  pointFeatureCollection,
  pointSourceOptions,
  serverClusterDescriptor
} from "./map_cluster_features.mjs"

test("cluster icon descriptors are stable and encode visual state", () => {
  assert.deepEqual(clusterIconDescriptor({count: 999, urgent_count: 0}, "en"), {
    id: "wnh-cluster-normal-44-39-39-39",
    count: 999,
    urgent: false,
    label: "999",
    diameter: 44
  })

  assert.deepEqual(clusterIconDescriptor({count: 12_500, urgent_count: 2}, "en"), {
    id: "wnh-cluster-urgent-56-31-33-4b",
    count: 12_500,
    urgent: true,
    label: "13K",
    diameter: 56
  })
})

test("server hierarchy metadata survives GeoJSON conversion without becoming a native cluster", () => {
  const feature = pointFeatureCollection([
    {
      id: "request:11:1197:1378",
      type: "cluster",
      cluster_id: "request:11:1197:1378",
      parent_cluster_id: "request:10:598:689",
      hierarchy_level: 11,
      expansion_zoom: 13,
      longitude: 30.52,
      latitude: 50.45,
      count: 27
    }
  ]).features[0]

  assert.equal(feature.properties.server_cluster_id, "request:11:1197:1378")
  assert.equal(feature.properties.parent_cluster_id, "request:10:598:689")
  assert.equal(feature.properties.hierarchy_level, 11)
  assert.equal(feature.properties.expansion_zoom, 13)
  assert.equal(feature.properties.weight, 27)
  assert.equal(feature.properties.count_label, "27")
  assert.equal(feature.properties.cluster_icon, "wnh-cluster-normal-44-32-37")
  assert.equal("point_count" in feature.properties, false)
})

test("browser source leaves server hierarchy nodes unclustered", () => {
  const collection = pointFeatureCollection([
    {
      id: "request:11:1197:1378",
      type: "cluster",
      longitude: 30.52,
      latitude: 50.45,
      count: 27
    }
  ])
  const source = pointSourceOptions(collection)

  assert.equal(source.cluster, false)
  assert.equal(source.data, collection)
})

test("cluster size classes remain stable for accessible count buttons", () => {
  assert.equal(clusterSizeClass(999), "is-md")
  assert.equal(clusterSizeClass(1_000), "is-lg")
  assert.equal(clusterSizeClass(10_000), "is-xl")
  assert.equal(clusterSizeClass(100_000), "is-xxl")
})

test("large visual counts are compact while exact values remain available to accessibility text", () => {
  assert.equal(clusterCountLabel(999, "en"), "999")
  assert.equal(clusterCountLabel(1_250, "en"), "1.3K")
  assert.equal(clusterCountLabel(48_533, "en"), "49K")
  assert.equal(clusterCountLabel(1_000_000, "en"), "1M")
})

test("server cluster count labels are compacted before rendering", () => {
  const feature = pointFeatureCollection([
    {
      id: "request:12:2402:2406",
      type: "cluster",
      longitude: 31.3,
      latitude: 30.2,
      count: 48_533
    }
  ], "en").features[0]

  assert.equal(feature.properties.count_label, "49K")
})

test("only server hierarchy nodes become cluster markers", () => {
  assert.deepEqual(
    serverClusterDescriptor({
      id: "request:12:2402:2406",
      type: "cluster",
      longitude: 31.3,
      latitude: 30.2,
      count: 1_727,
      urgent_count: 8
    }),
    {
      key: "server:request:12:2402:2406",
      count: 1_727,
      urgentCount: 8,
      longitude: 31.3,
      latitude: 30.2
    }
  )
  assert.equal(
    serverClusterDescriptor({
      id: "request-1",
      type: "request",
      longitude: 31.3,
      latitude: 30.2
    }),
    null
  )
})

test("cluster expansion always advances at least one integer zoom level", () => {
  assert.equal(clusterExpansionTarget(9, 9), 10)
  assert.equal(clusterExpansionTarget(8.999_999_096_835_52, 9), 10)
  assert.equal(clusterExpansionTarget(10.999_994_193_019_71, 11), 12)
  assert.equal(clusterExpansionTarget(9.6, 10), 10)
  assert.equal(clusterExpansionTarget(9.6, 13), 13)
  assert.equal(clusterExpansionTarget(21.9, 24), 22)
})

test("cluster expansion centers on actual member bounds instead of the display cell", () => {
  const [longitude, latitude] = clusterExpansionCenter({
    longitude: 30.4,
    latitude: 50.6,
    bounds: {west: 30.51, south: 50.44, east: 30.53, north: 50.46}
  })

  assert.ok(Math.abs(longitude - 30.52) <= Number.EPSILON * 32)
  assert.ok(Math.abs(latitude - 50.45) <= Number.EPSILON * 32)

  assert.deepEqual(
    clusterExpansionCenter({
      longitude: 179,
      latitude: 10,
      bounds: {west: 179.5, south: 9, east: -179.5, north: 11}
    }),
    [180, 10]
  )
})

test("cluster expansion falls back to the display point without valid bounds", () => {
  assert.deepEqual(
    clusterExpansionCenter({longitude: 30.52, latitude: 50.45}),
    [30.52, 50.45]
  )
})