import { INF, MAP_H, MAP_W, SIZE, clamp, fbm, hash2, indexOf, inside, pickEntities, valueNoise } from "./mapUtils.js";

export function buildFeatureContext(seed, terrain) {
  const {
    elevation,
    slope,
    sea,
    river,
    floodplain,
    plain,
    agriculture,
    ridgeField,
    valleyField,
    basinField,
    coastalLowland,
    arcSpineField,
    branchRidgeField,
    depositionalLowland,
    alluvialFanField,
    deltaField,
    portSuitability,
    prefectureMask,
    prefectureRegionId,
    naturalBarrierScore,
  } = terrain;

  const geography = terrain.geography || {};
  const geoHabitability = geography.habitability || null;
  const geoAccessibility = geography.accessibility || null;
  const geoNaturalCentrality = geography.naturalCentrality || geography.centrality || null;
  const geoLowlandCapacity = geography.lowlandCapacity || null;
  const geoValleyAccess = geography.valleyAccess || null;
  const geoCoastalAccess = geography.coastalAccess || null;
  const geoBarrier = geography.geographicBarrier || naturalBarrierScore || null;
  const geoCorridorSuitability = geography.corridorSuitability || null;

  function fieldValue(field, i, fallback = 0) {
    const v = field?.[i];
    return Number.isFinite(v) ? v : fallback;
  }

  function regionIdAt(x, y) {
    if (!inside(x, y)) return -1;
    const i = indexOf(x, y);
    if (sea[i]) return -1;
    if (prefectureMask?.[i]) return 0;
    if (!prefectureRegionId) return 0;
    const id = prefectureRegionId?.[i];
    return id !== undefined && id >= 0 ? id : -1;
  }

  function inFocusedPrefecture(p) {
    return Boolean(p && inside(p.x, p.y) && prefectureMask[indexOf(p.x, p.y)] && !sea[indexOf(p.x, p.y)]);
  }

  function localConfluenceScore(x, y) {
    let arms = 0;
    let strong = 0;
    for (const [dx, dy] of [[1,0],[-1,0],[0,1],[0,-1],[1,1],[-1,1],[1,-1],[-1,-1]]) {
      const nx = x + dx;
      const ny = y + dy;
      if (!inside(nx, ny)) continue;
      const rv = river[indexOf(nx, ny)];
      if (rv > 0.18) arms++;
      if (rv > 0.34) strong++;
    }
    return clamp((arms >= 3 ? 0.22 : arms === 2 ? 0.09 : 0) + strong * 0.04);
  }

  // --- 1. Human context: one full raster pass -----------------------------
  const developable = new Float32Array(SIZE);
  const ruralSuitability = new Float32Array(SIZE);
  const townSuitability = new Float32Array(SIZE);
  const valleySettlement = new Float32Array(SIZE);
  const coastalSettlement = new Float32Array(SIZE);
  const confluenceField = new Float32Array(SIZE);
  const barrierCost = new Float32Array(SIZE);
  const corridorCost = new Float32Array(SIZE);
  const settlementCluster = new Float32Array(SIZE);
  const settlementScore = new Float32Array(SIZE);

  for (let y = 0; y < MAP_H; y++) {
    for (let x = 0; x < MAP_W; x++) {
      const i = indexOf(x, y);
      if (sea[i]) {
        barrierCost[i] = INF;
        corridorCost[i] = INF;
        continue;
      }
      const naturalBarrier = naturalBarrierScore?.[i] || 0;
      const depositional = (depositionalLowland?.[i] || 0) + (alluvialFanField?.[i] || 0) * 0.62 + (deltaField?.[i] || 0) * 0.90;
      const highPenalty = Math.max(0, elevation[i] - 0.56);
      const lowSlope = clamp(1 - slope[i] * 2.3);
      const confluence = x > 0 && y > 0 && x < MAP_W - 1 && y < MAP_H - 1 ? localConfluenceScore(x, y) : 0;
      const openPlainPotential = clamp(plain[i] * 0.68 + agriculture[i] * 0.54 + basinField[i] * 0.30 + lowSlope * 0.22 - river[i] * 0.18 - valleyField[i] * 0.08 - ridgeField[i] * 0.22 - slope[i] * 0.26);
      const spine = (arcSpineField?.[i] || 0) * 0.58 + (branchRidgeField?.[i] || 0) * 0.38;
      confluenceField[i] = confluence;

      const geoH = fieldValue(geoHabitability, i, 0);
      const geoLow = fieldValue(geoLowlandCapacity, i, 0);
      const geoValley = fieldValue(geoValleyAccess, i, 0);
      const geoCoast = fieldValue(geoCoastalAccess, i, 0);
      const geoB = fieldValue(geoBarrier, i, naturalBarrier);
      const localDevelopable = clamp(
        plain[i] * 0.34 +
        agriculture[i] * 0.24 +
        basinField[i] * 0.24 +
        valleyField[i] * 0.24 +
        coastalLowland[i] * 0.18 +
        depositional * 0.22 +
        lowSlope * 0.10 -
        slope[i] * 0.82 -
        ridgeField[i] * 0.52 -
        spine * 0.24 -
        highPenalty * 1.14 -
        floodplain[i] * 0.03
      );
      developable[i] = clamp(localDevelopable * 0.68 + geoH * 0.34 + geoLow * 0.16 - geoB * 0.05);
      valleySettlement[i] = clamp((
        valleyField[i] * 0.52 +
        river[i] * 0.08 +
        confluence * 0.38 +
        depositional * 0.20 +
        basinField[i] * 0.16 +
        plain[i] * 0.08 +
        lowSlope * 0.12 -
        slope[i] * 0.54 -
        ridgeField[i] * 0.30 -
        spine * 0.16 -
        highPenalty * 0.70 -
        floodplain[i] * 0.10
      ) * 0.74 + geoValley * 0.30 + geoH * 0.08 - geoB * 0.04);
      coastalSettlement[i] = clamp((
        coastalLowland[i] * 0.50 +
        (portSuitability?.[i] || 0) * 0.30 +
        (deltaField?.[i] || 0) * 0.20 +
        plain[i] * 0.10 -
        slope[i] * 0.52 -
        ridgeField[i] * 0.24 -
        spine * 0.12
      ) * 0.76 + geoCoast * 0.32 + geoH * 0.06 - geoB * 0.04);
      const clusterNoise = 0.72 + fbm(x * 0.34 + 13, y * 0.34 - 31, seed + 7001) * 0.46 + valueNoise(x, y, seed + 7002, 8) * 0.16;
      settlementCluster[i] = clamp((developable[i] * 0.42 + valleySettlement[i] * 0.12 + coastalSettlement[i] * 0.22 + agriculture[i] * 0.48 + plain[i] * 0.32 + openPlainPotential * 0.46) * clusterNoise);
      ruralSuitability[i] = clamp(
        agriculture[i] * 0.54 +
        developable[i] * 0.30 +
        valleySettlement[i] * 0.18 +
        coastalSettlement[i] * 0.20 +
        openPlainPotential * 0.34 +
        settlementCluster[i] * 0.30 -
        Math.max(0, elevation[i] - 0.64) * 0.56
      );
      townSuitability[i] = clamp(
        developable[i] * 0.38 +
        agriculture[i] * 0.18 +
        valleySettlement[i] * 0.16 +
        coastalSettlement[i] * 0.30 +
        confluence * 0.20 +
        basinField[i] * 0.18 +
        plain[i] * 0.26 +
        openPlainPotential * 0.44 +
        settlementCluster[i] * 0.22 -
        slope[i] * 0.34 -
        ridgeField[i] * 0.17 -
        spine * 0.10
      );
      settlementScore[i] = clamp(
        ruralSuitability[i] * 0.48 +
        townSuitability[i] * 0.30 +
        confluence * 0.08 +
        fieldValue(geoHabitability, i, developable[i]) * 0.18 +
        fieldValue(geoNaturalCentrality, i, 0) * 0.12 -
        fieldValue(geoBarrier, i, 0) * 0.06
      );
      barrierCost[i] = 1 + slope[i] * 6.4 + ridgeField[i] * 3.2 + spine * 2.2 + highPenalty * 5.8 + river[i] * 0.25 + naturalBarrier * 1.2 - valleyField[i] * 0.55 - plain[i] * 0.30 - coastalLowland[i] * 0.14;
      corridorCost[i] = Math.max(0.25, barrierCost[i] - developable[i] * 0.42 - valleySettlement[i] * 0.36 - coastalSettlement[i] * 0.12 + hash2(x, y, seed + 7011) * 0.05);
    }
  }

  // --- region statistics ---------------------------------------------------
  const regionStats = new Map();
  function ensureRegion(regionId) {
    let st = regionStats.get(regionId);
    if (!st) {
      st = {
        id: regionId,
        area: 0,
        developableCells: 0,
        developableSum: 0,
        valleyCells: 0,
        coastCells: 0,
        townCells: 0,
        plainCells: 0,
        highCentralityCells: 0,
        habitabilitySum: 0,
        accessibilitySum: 0,
        centralitySum: 0,
        lowlandCapacitySum: 0,
        minX: MAP_W,
        minY: MAP_H,
        maxX: 0,
        maxY: 0,
      };
      regionStats.set(regionId, st);
    }
    return st;
  }
  for (let y = 0; y < MAP_H; y++) {
    for (let x = 0; x < MAP_W; x++) {
      const i = indexOf(x, y);
      if (sea[i]) continue;
      const regionId = regionIdAt(x, y);
      if (regionId < 0) continue;
      const st = ensureRegion(regionId);
      st.area++;
      const gHabit = fieldValue(geoHabitability, i, developable[i]);
      const gAccess = fieldValue(geoAccessibility, i, 0);
      const gCentral = fieldValue(geoNaturalCentrality, i, townSuitability[i]);
      const gLow = fieldValue(geoLowlandCapacity, i, plain[i]);
      st.developableSum += developable[i];
      st.habitabilitySum += gHabit;
      st.accessibilitySum += gAccess;
      st.centralitySum += gCentral;
      st.lowlandCapacitySum += gLow;
      if (developable[i] > 0.16 || gHabit > 0.24) st.developableCells++;
      if (valleySettlement[i] > 0.24 || fieldValue(geoValleyAccess, i, 0) > 0.25) st.valleyCells++;
      if (coastalSettlement[i] > 0.25 || fieldValue(geoCoastalAccess, i, 0) > 0.24) st.coastCells++;
      if (townSuitability[i] > 0.28 || gCentral > 0.31) st.townCells++;
      if (plain[i] > 0.24 || gLow > 0.26) st.plainCells++;
      if (gCentral > 0.36 && gHabit > 0.18) st.highCentralityCells++;
      st.minX = Math.min(st.minX, x);
      st.minY = Math.min(st.minY, y);
      st.maxX = Math.max(st.maxX, x);
      st.maxY = Math.max(st.maxY, y);
    }
  }

  function visibilityFactor(regionId, st) {
    if (!st || st.area <= 0) return 0;
    // Treat the focused prefecture and neighboring prefectures with the same
    // density curve.  Only genuinely clipped map-edge slivers are downscaled.
    return clamp(Math.sqrt(st.area / 1900), 0.32, 1.05);
  }

  function pickRegionalPoints(scoreArray, {
    stride = 1,
    threshold = 0.25,
    minDistance = 6,
    totalMax = 100,
    seedOffset = 0,
    quotaForRegion,
    predicate = () => true,
    kind = "Point",
    extraScore = () => 0,
  }) {
    const byRegion = new Map();
    for (let y = 2; y < MAP_H - 2; y += stride) {
      for (let x = 2; x < MAP_W - 2; x += stride) {
        const i = indexOf(x, y);
        if (sea[i] || !predicate(x, y, i)) continue;
        const regionId = regionIdAt(x, y);
        if (regionId < 0) continue;
        const score = scoreArray[i] + extraScore(x, y, i) + hash2(x, y, seed + seedOffset) * 0.055;
        if (score < threshold) continue;
        if (!byRegion.has(regionId)) byRegion.set(regionId, []);
        byRegion.get(regionId).push({ x, y, score, kind, regionId });
      }
    }
    const out = [];
    for (const [regionId, candidates] of [...byRegion.entries()].sort((a, b) => a[0] - b[0])) {
      const st = regionStats.get(regionId);
      const quota = quotaForRegion ? quotaForRegion(regionId, st) : 0;
      if (quota <= 0) continue;
      out.push(...pickEntities(candidates, {
        max: quota,
        minDistance,
        threshold,
        seed: seed + seedOffset + regionId * 1009,
        jitter: 0.04,
      }));
    }
    return out.sort((a, b) => b.score - a.score).slice(0, totalMax);
  }

  function pickGlobalPoints(scoreArray, { threshold, max, minDistance, seedOffset = 0, predicate = () => true, stride = 1 }) {
    const candidates = [];
    for (let y = 2; y < MAP_H - 2; y += stride) {
      for (let x = 2; x < MAP_W - 2; x += stride) {
        const i = indexOf(x, y);
        if (sea[i] || !predicate(x, y, i)) continue;
        const score = scoreArray[i] + hash2(x, y, seed + seedOffset) * 0.07;
        if (score >= threshold) candidates.push({ x, y, score, regionId: regionIdAt(x, y) });
      }
    }
    return pickEntities(candidates, { max, minDistance, threshold, seed: seed + seedOffset });
  }


  return {
    geography,
    geoHabitability,
    geoAccessibility,
    geoNaturalCentrality,
    geoLowlandCapacity,
    geoValleyAccess,
    geoCoastalAccess,
    geoBarrier,
    geoCorridorSuitability,
    fieldValue,
    regionIdAt,
    inFocusedPrefecture,
    developable,
    ruralSuitability,
    townSuitability,
    valleySettlement,
    coastalSettlement,
    confluenceField,
    barrierCost,
    corridorCost,
    settlementCluster,
    settlementScore,
    regionStats,
    visibilityFactor,
    pickRegionalPoints,
    pickGlobalPoints,
  };
}