'use strict';

/**
 * Advanced Report analytics engine (D1 — ADVANCED_REPORTS_IMPLEMENTATION_PLAN.md §3).
 *
 * Pure computation over ApplicationDetail point streams: no HTTP, no Mongo, no
 * Puppeteer (NFR-6.3). The caller streams points in stored file order (gpsTime is
 * seconds-of-day and can wrap past midnight, so records are never re-sorted — same
 * convention as controllers/job.js getAppDataByJobId) and reads back per-line,
 * per-zone and mission aggregates computed in that single pass (NFR-1.2, NFR-3.3).
 *
 * All results are numeric and metric (meters, seconds, liters, m/s); display
 * formatting/localization belongs to the datasource builder, not this module.
 */

const turf = require('@turf/turf'),
  geoUtil = require('./geo_util'),
  utils = require('./utils');

// Spray-on records: 1 = spray on (inside the mapped zone), 3 = spray segment START marker,
// 10 = spray on but OUTSIDE the mapped zone boundary (docs/DATA_EXPORT_API_DESIGN.md).
// Whether out-of-zone spray (10) counts toward coverage/area is a per-user "Spray Coverage:
// All/Inside" preference (Setting.sprayPath.dataOp — 0=All, 1=Inside; today only wired into
// the map editor's drawing endpoint, controllers/job.js getData_post). createMissionAnalytics's
// includeOutOfZoneSpray option lets the caller mirror that preference here; the actual
// Set is built per-call inside the function, not as a shared module-level constant, since
// it now depends on that option.
// Consecutive points further apart than this are a data gap, not travel
// (getSprayOnSegments breaks spray segments at the same 1 km jump)
const GAP_KM = 1;
// Valid turn duration window in seconds (workers/job_worker.js turn-time loop)
const TURN_MIN_S = 5, TURN_MAX_S = 120;
// Max gap between consecutive points still counted as flight time — same threshold as
// TURN_MAX_S today, but a conceptually distinct cap (workers/job_worker.js:1447-1455's
// totalFlightTime loop), kept as its own named constant rather than reusing TURN_MAX_S
const FLIGHT_GAP_MAX_S = 120;
// Seconds-of-day wrap guard (workers/job_worker.js: negative diffs >= 80000 are midnight wraps)
const DAY_S = 86400, WRAP_GUARD_S = 80000;
// Max points sampled per pass for point-in-polygon zone assignment
const PIP_SAMPLES = 25;
// A line whose nearest zone center is still farther than this is not a boundary-straddle
// or GPS-drift case — it's unrelated data (wrong file, GPS fault, mixed-in test data) that
// doesn't belong to any zone in this job. Generous on purpose (a single ag mission's zones
// are normally within a few km of each other; this only rejects genuinely implausible
// matches, e.g. a flight recorded hundreds of km away)
const NEAREST_ZONE_MAX_KM = 50;
// Equipment quirk: the very first line of a file can be logged with llnum 65535
// (2^16-1, the max value of an unsigned 16-bit integer) instead of a real line
// number — no real mission has anywhere near 65535 flight lines, so this is always
// the sentinel/underflow artifact, never a legitimate count. Confirmed on real data
// (Job #90): the file's other line numbers run 2, 3, 4...37 with no "1" anywhere,
// and 65535 sits chronologically exactly where line 1 belongs.
const LLNUM_SENTINEL = 65535;

/** Seconds-of-day difference t2 - t1, corrected across the midnight wrap */
function todDiff(t2, t1) {
  let d = t2 - t1;
  if (d < 0 && Math.abs(d) >= WRAP_GUARD_S) d = (DAY_S - t1) + t2;
  return d;
}

/** Planned area of a spray zone in m², net of any intersecting exclusion zones —
 *  mirrors jobUtil.calcTTSprayAreas so this matches the job's own Job.ttSprArea figure.
 *  Falls back to the stored properties.area (sprayArea.properties.area is absent in
 *  much live data) only when there are no exclusion zones to net out — a stored area
 *  predates any excludedAreas subtraction and can't be trusted once there's overlap to
 *  remove. */
function plannedAreaM2(zone, excludedAreas = []) {
  if (!excludedAreas.length && zone.properties && zone.properties.area > 0) return zone.properties.area;
  try {
    const feature = { type: 'Feature', properties: {}, geometry: zone.geometry };
    let area = turf.area(feature);
    for (const xcl of excludedAreas) {
      const diff = turf.intersect(feature, { type: 'Feature', properties: {}, geometry: xcl.geometry });
      if (diff) area -= turf.area(diff);
    }
    return area;
  } catch (err) {
    return 0;
  }
}

/** Single point-in-polygon zone lookup (first matching zone wins, same as the sampled
 *  callers below) — -1 when the point falls inside none of them. */
function zoneOfPoint(p, zoneFeatures) {
  const xy = [p.lon, p.lat];
  for (let z = 0; z < zoneFeatures.length; z++)
    if (turf.booleanPointInPolygon(xy, zoneFeatures[z])) return z;
  return -1;
}

/** Shared sampling pass behind majorityZone/straddlesMultipleZones — walks up to
 *  PIP_SAMPLES points at a stride and returns per-zone hit counts, so both callers
 *  do exactly one point-in-polygon sweep instead of two. */
function sampleZoneCounts(points, zoneFeatures) {
  const stride = Math.max(1, Math.floor(points.length / PIP_SAMPLES));
  const counts = new Array(zoneFeatures.length).fill(0);
  let sampled = 0;
  for (let i = 0; i < points.length; i += stride) {
    sampled++;
    const z = zoneOfPoint(points[i], zoneFeatures);
    if (z >= 0) counts[z]++;
  }
  return { counts, sampled };
}

/** Majority point-in-polygon zone index for a pass; -1 when no sampled point is inside
 *  any zone (FR-5.2 — straddling lines go to the zone holding most of their points) */
function majorityZone(points, zoneFeatures) {
  const { counts, sampled } = sampleZoneCounts(points, zoneFeatures);
  let best = -1, bestCount = 0;
  for (let z = 0; z < zoneFeatures.length; z++)
    if (counts[z] > bestCount) { best = z; bestCount = counts[z]; }
  return sampled ? best : -1;
}

/** Cheap pre-check (same sample as majorityZone, no extra PIP work): does this pass's
 *  sample touch more than one zone at all? Only passes that do pay for the full,
 *  unsampled per-point split below (FR-5.2 refinement) — a pass that's cleanly inside
 *  one zone costs exactly what it did before this refinement. */
function straddlesMultipleZones(points, zoneFeatures) {
  const { counts } = sampleZoneCounts(points, zoneFeatures);
  return counts.filter(c => c > 0).length > 1;
}

/** Splits a pass into one segment per zone it actually crosses, instead of handing the
 *  whole pass to whichever zone the sampled majority favors (FR-5.2 refinement — a small
 *  zone next to a much bigger one was otherwise losing coverage credit for genuinely-its
 *  passes to the bigger neighbor's majority vote). Only called for passes already flagged
 *  by straddlesMultipleZones, so every point gets a real (unsampled) zone lookup here —
 *  that cost is bounded to the minority of passes that actually straddle a boundary.
 *
 *  A point that itself resolves to no zone (-1 — e.g. sitting exactly on a shared
 *  boundary edge) rides along with whichever run is already open rather than forcing a
 *  spurious extra split; a run only breaks when a point resolves to a DIFFERENT real
 *  zone than the run in progress. A run that never finds a real zone anywhere in it
 *  (all -1) falls back to nearestZone, same as the non-split path's own fallback.
 *
 *  Documented trade-off: the single GPS interval that actually crosses the boundary
 *  (the edge from one run's last point to the next run's first point) isn't counted in
 *  either segment's length/area/volume — splitting that one edge's distance between two
 *  zones would add real complexity for a per-crossing discrepancy of one GPS interval
 *  (a few meters), which nets out as negligible against a whole mission's totals. */
function splitPassByZone(pass, zoneFeatures, zoneCenters, computeSegmentStats) {
  const pts = pass.points;
  const runs = [];
  let curZone = zoneOfPoint(pts[0], zoneFeatures);
  let runStart = 0;
  for (let i = 1; i < pts.length; i++) {
    const z = zoneOfPoint(pts[i], zoneFeatures);
    if (z >= 0 && z !== curZone) {
      runs.push({ zoneIdx: curZone, startIdx: runStart, endIdx: i - 1 });
      runStart = i;
      curZone = z;
    }
  }
  runs.push({ zoneIdx: curZone, startIdx: runStart, endIdx: pts.length - 1 });

  return runs.map(r => {
    const runPts = pts.slice(r.startIdx, r.endIdx + 1);
    const zoneIdx = r.zoneIdx >= 0 ? r.zoneIdx : nearestZone(runPts[0], zoneCenters);
    return Object.assign({ llnum: pass.llnum, zoneIdx, points: runPts }, computeSegmentStats(runPts));
  });
}

/** Nearest zone (by center, real great-circle km — not raw lat/lon degrees, which
 *  under-counts longitude distance away from the equator) — fallback so a line that
 *  straddles no zone at all still lands somewhere plausible. Returns -1 when even the
 *  closest zone is farther than NEAREST_ZONE_MAX_KM: that's not a boundary-straddle or
 *  GPS-drift case, it's unrelated data with no real zone to belong to (mission totals
 *  then no longer include it — see the mission.unassigned summary in finish()) */
function nearestZone(point, zoneCenters) {
  let best = -1, bestKm = Infinity;
  for (let z = 0; z < zoneCenters.length; z++) {
    const km = geoUtil.distance([point.lat, point.lon], [zoneCenters[z][1], zoneCenters[z][0]]);
    if (km < bestKm) { bestKm = km; best = z; }
  }
  return bestKm <= NEAREST_ZONE_MAX_KM ? best : -1;
}

/**
 * Create a single-pass mission analytics accumulator.
 *
 * @param {Object} opts
 * @param {Array}  opts.zones         job.sprayAreas (GeoJSON-ish: { properties, geometry })
 * @param {Number} opts.swathWidthM   job swath width in meters — fallback when points carry no swath
 * @param {Array}  opts.excludedAreas job.excludedAreas — netted out of each zone's planned area
 * @param {Boolean} opts.includeOutOfZoneSpray  whether sprayStat=10 (spraying outside the mapped
 *   zone) counts as spray-on for pass/area/distance/speed — mirrors the user's "Spray Coverage:
 *   All/Inside" preference (Setting.sprayPath.dataOp: 0=All/1=Inside). Defaults to true ("All"),
 *   matching that setting's own default. XT Error always stays restricted to sprayStat 1/3
 *   regardless of this option — see missionXtAcc/missionXtN below.
 * @returns {{ push: Function, fileBreak: Function, finish: Function, lineCount: Function }}
 *
 * Point fields consumed: lat, lon, gpsTime, llnum, sprayStat, grSpeed, xTrack,
 * sprayHeight, lminApp, swath.
 */
function createMissionAnalytics({ zones = [], swathWidthM = 0, collectDraw = false, excludedAreas = [], includeOutOfZoneSpray = true } = {}) {
  const SPRAY_ON = includeOutOfZoneSpray ? new Set([1, 3, 10]) : new Set([1, 3]);

  const zoneFeatures = zones.map(z => ({ type: 'Feature', properties: {}, geometry: z.geometry }));
  const zoneCenters = zoneFeatures.map(f => turf.getCoord(turf.center(f)));

  const passes = [];          // contiguous spray-on runs
  let curPass = null;

  // whole-flight accumulators (all points, spray or not)
  let prev = null;            // previous point (across spray state, within a file)
  let totalDistanceM = 0;
  let totalFlightS = 0;

  // flat, unweighted XT accumulator across every spray-on point in the mission —
  // deliberately NOT rolled up through the pass->line->zone->mission weighted-mean
  // chain (which weights by point-count then spray-time, and so doesn't equal a
  // simple per-reading average); matches the client playback's own avg-XT method
  // (job-map-edit.component.ts playXt: a flat running average of every spray-on
  // reading) so the mission KPI and the playback figure follow the same method.
  // Excludes exact-zero xTrack, same as the pass-level xtAcc/xtN below — verified
  // ~44% of readings are exactly 0 (the schema default for an unpopulated field, not
  // a real "dead on target" measurement), so including them would dilute the average
  // with likely-missing data rather than bring it closer to playback's own figure.
  // Always restricted to sprayStat 1/3, independent of includeOutOfZoneSpray/SPRAY_ON —
  // cross-track-error-from-line isn't meaningful once outside the mapped zone
  // (workers/job_worker.js:1478 draws the same distinction for the legacy calculation).
  // Accumulated here in push(), NOT inside the per-pass loop in finish(), because
  // endPass() silently discards single-point pass fragments (curPass.points.length > 1
  // guard) — those fragments become more common once SPRAY_ON excludes 10 (a run of
  // spray-on-outside-area points can chop an otherwise-continuous pass into slivers),
  // and a flat "average of every reading" figure must not lose readings just because
  // they landed in a fragment too small to become a real pass.
  let missionXtAcc = 0, missionXtN = 0;

  // optional map-drawing geometry, built in the same pass so the report never
  // re-reads ApplicationDetail for the captures (NFR-1.2)
  const DRAW_STRIDE = 3;
  const flightSegs = [];      // ferry/flight paths as [[lat, lon], ...]
  let curFlightSeg = null, flightPtCount = 0;

  // turn-time state machine (workers/job_worker.js:1486 pattern, plus an atFresh
  // guard: a gap only counts as a turn when off-travel was actually observed
  // between the two lines — a bare llnum change with no off records is a data
  // hole, not a measured turn)
  const turn = { line: null, at: null, nextOff: false, atFresh: false };
  // { beforeLlnum, seconds, passIndex } — passIndex is the `passes` index of the pass this gap
  // immediately follows; zone isn't known yet at push() time (assigned later in finish()), so the
  // gap can't be keyed by zone+llnum until the pass it belongs to has been zone-assigned. Looking it
  // up by bare llnum alone would let the same llnum reused in a different zone steal this gap.
  const turnGaps = [];

  function endPass() {
    if (curPass && curPass.points.length > 1) passes.push(curPass);
    curPass = null;
  }

  function endFlightSeg() {
    if (curFlightSeg && curFlightSeg.length > 1) flightSegs.push(curFlightSeg);
    curFlightSeg = null;
  }

  function push(p) {
    // normalize the llnum sentinel before anything downstream (turn-time tracking,
    // pass segmentation, line keying/display) reads it
    if (p.llnum === LLNUM_SENTINEL) p.llnum = 1;

    // ---- whole-flight time & distance --------------------------------------
    // matches the legacy convention exactly (workers/job_worker.js:1447-1455): sum
    // consecutive-point deltas, excluding any gap that's zero/negative or >120s entirely —
    // a long pause (refuel stop, GPS dropout) is not counted as flight time, unlike a plain
    // last-minus-first span which would silently include it
    let gapJump = false;
    if (prev) {
      const dt = todDiff(p.gpsTime, prev.gpsTime);
      if (dt > 0 && dt <= FLIGHT_GAP_MAX_S) totalFlightS += dt;
      const dKm = geoUtil.distance([prev.lat, prev.lon], [p.lat, p.lon]);
      if (dKm < GAP_KM) totalDistanceM += dKm * 1000;
      else gapJump = true;
    }

    // ---- flight-path drawing geometry ---------------------------------------
    if (collectDraw) {
      if (gapJump) endFlightSeg();
      if (!curFlightSeg) curFlightSeg = [];
      if (flightPtCount % DRAW_STRIDE === 0) curFlightSeg.push([p.lat, p.lon]);
      flightPtCount++;
    }

    // ---- turn time between spray lines --------------------------------------
    if (turn.line === null) {
      if (!SPRAY_ON.has(p.sprayStat)) { turn.line = p.llnum; turn.at = p.gpsTime; turn.atFresh = true; }
    } else if (turn.line !== p.llnum) {
      if (SPRAY_ON.has(p.sprayStat)) {
        if (turn.atFresh) {
          const gap = todDiff(p.gpsTime, turn.at);
          if (gap >= TURN_MIN_S && gap <= TURN_MAX_S)
            turnGaps.push({ beforeLlnum: turn.line, seconds: gap, passIndex: passes.length - 1 });
          turn.atFresh = false;
        }
        turn.line = p.llnum;
        turn.nextOff = true;
      }
    } else {
      if (!SPRAY_ON.has(p.sprayStat) && turn.nextOff) { turn.at = p.gpsTime; turn.nextOff = false; turn.atFresh = true; }
      else if (SPRAY_ON.has(p.sprayStat)) turn.nextOff = true;
    }

    // ---- spray pass segmentation --------------------------------------------
    if (SPRAY_ON.has(p.sprayStat)) {
      const jump = prev && geoUtil.distance([prev.lat, prev.lon], [p.lat, p.lon]) >= GAP_KM;
      if (curPass && (curPass.llnum !== p.llnum || p.sprayStat === 3 || jump)) endPass();
      if (!curPass) curPass = { llnum: p.llnum, points: [] };
      curPass.points.push(p);
    } else if (curPass) {
      endPass();
    }

    // ---- mission-wide flat XT accumulator (see the declaration above for why this
    // lives here rather than in the per-pass loop in finish()) ---------------------
    if (utils.isNumber(p.xTrack) && p.xTrack !== 0 && (p.sprayStat === 1 || p.sprayStat === 3)) {
      missionXtAcc += Math.abs(p.xTrack); missionXtN++;
    }

    prev = p;
  }

  /** Call between files: file order is only guaranteed within a file */
  function fileBreak() {
    endPass();
    endFlightSeg();
    prev = null;
    turn.line = null; turn.at = null; turn.nextOff = false; turn.atFresh = false;
  }

  function lineCount() {
    // upper bound used for the NFR-2.1 line limit while streaming
    return passes.length + (curPass ? 1 : 0);
  }

  function finish() {
    fileBreak();

    // Per-point-array stats shared by both the non-split path and each zone segment a
    // straddling pass gets split into (DRY — this is the exact same computation that
    // used to run once per pass, unchanged in every respect other than being callable
    // per-segment too).
    function computeSegmentStats(pts) {
      const startT = pts[0].gpsTime;
      const endT = pts[pts.length - 1].gpsTime;
      const sprayS = todDiff(endT, startT);

      let lenM = 0, speedAcc = 0, speedN = 0, xtAcc = 0, xtN = 0,
        heightAcc = 0, heightN = 0, volumeL = 0, flowN = 0, swathAcc = 0, swathN = 0;
      for (let i = 0; i < pts.length; i++) {
        const p = pts[i];
        if (i > 0) {
          lenM += geoUtil.distance([pts[i - 1].lat, pts[i - 1].lon], [p.lat, p.lon]) * 1000;
          const dt = todDiff(p.gpsTime, pts[i - 1].gpsTime);
          const flow = ((pts[i - 1].lminApp || 0) + (p.lminApp || 0)) / 2;   // L/min across the interval
          // legacy caps every time-based accumulator at this same gap (AGGREGATED_FIELDS_
          // CALCULATION.md: "Max time gap: 120s — outlier rejection for all time accumulators");
          // without it, a stray timestamp gap with no matching distance jump (so the pass never
          // splits) would integrate flow across an unrealistically long, likely-bogus interval
          if (flow > 0 && dt > 0 && dt <= FLIGHT_GAP_MAX_S) { volumeL += flow * (dt / 60); flowN++; }
        }
        // sprayStat 3 (line-start marker) IS included in the speed average — verified against the
        // actual legacy code (workers/job_worker.js:1470-1472): the sprayStat!==3 exclusion there
        // applies to the spray-TIME accumulator, not speed. avgSpraySpeed fires for every record
        // with sprayStat>0, marker included. AGGREGATED_FIELDS_CALCULATION.md's prose description
        // conflates the two rules and is wrong on this point — don't trust it over the real code.
        if (utils.isNumber(p.grSpeed) && p.grSpeed > 0) { speedAcc += p.grSpeed; speedN++; }
        // XT Error always stays restricted to sprayStat 1/3, even when includeOutOfZoneSpray
        // widens SPRAY_ON to include 10 — cross-track-error-from-line isn't a meaningful
        // measurement once the aircraft is outside the mapped zone (workers/job_worker.js:1478
        // draws the same distinction for the legacy avgXtError calculation)
        if (utils.isNumber(p.xTrack) && p.xTrack !== 0 && (p.sprayStat === 1 || p.sprayStat === 3)) {
          xtAcc += Math.abs(p.xTrack); xtN++;
        }
        if (utils.isNumber(p.sprayHeight) && p.sprayHeight > 0) { heightAcc += p.sprayHeight; heightN++; }
        if (utils.isNumber(p.swath) && p.swath > 0) { swathAcc += p.swath; swathN++; }
      }
      const swathM = swathN ? swathAcc / swathN : swathWidthM;
      return {
        startT, endT, sprayS,
        lengthM: lenM,
        avgSpeedMps: speedN ? speedAcc / speedN : (sprayS > 0 ? lenM / sprayS : 0),
        avgXtM: xtN ? xtAcc / xtN : null,                       // null: no xTrack recorded (SatLoc etc.)
        avgHeightM: heightN ? heightAcc / heightN : null,       // null: no Flight Master height
        volumeL: flowN ? volumeL : null,                        // null: lminApp flat 0 (no flow controller)
        swathM,
        areaM2: lenM * swathM
      };
    }

    // ---- per-pass stats, zone assignment; straddling passes split into segments ----
    // (FR-5.2 refinement) — passLastZone remembers each original pass's LAST zone
    // segment (by array position, so a non-split pass just records its one zone) for
    // the turn-gap attribution below: a turn starts right after the pass's last point,
    // so it belongs to whichever zone that pass was in when it ended.
    const segments = [];
    const passLastZone = new Array(passes.length).fill(-1);
    passes.forEach((pass, passIdx) => {
      const pts = pass.points;
      if (zoneFeatures.length && straddlesMultipleZones(pts, zoneFeatures)) {
        for (const seg of splitPassByZone(pass, zoneFeatures, zoneCenters, computeSegmentStats)) {
          segments.push(seg);
          passLastZone[passIdx] = seg.zoneIdx;
        }
      } else {
        let zoneIdx = -1;
        if (zoneFeatures.length) {
          zoneIdx = majorityZone(pts, zoneFeatures);
          if (zoneIdx < 0) zoneIdx = nearestZone(pts[0], zoneCenters);
        }
        segments.push(Object.assign({ llnum: pass.llnum, zoneIdx, points: pts }, computeSegmentStats(pts)));
        passLastZone[passIdx] = zoneIdx;
      }
    });

    // ---- line rows: one per (zone, llnum), ordered by start time (FR-4.5) ---
    const lineMap = new Map();
    for (const seg of segments) {
      const key = seg.zoneIdx + ':' + seg.llnum;
      if (!lineMap.has(key))
        lineMap.set(key, {
          zoneIdx: seg.zoneIdx, llnum: seg.llnum, startT: seg.startT,
          sprayS: 0, lengthM: 0, areaM2: 0,
          _speedAcc: 0, _speedW: 0, _xtAcc: 0, _xtW: 0, _volL: 0, _volKnown: false,
          _heightAcc: 0, _heightW: 0, _swathAcc: 0, _swathW: 0, turnS: null
        });
      const line = lineMap.get(key);
      if (todDiff(seg.startT, line.startT) < 0) line.startT = seg.startT;
      line.sprayS += seg.sprayS;
      line.lengthM += seg.lengthM;
      line.areaM2 += seg.areaM2;
      line._speedAcc += seg.avgSpeedMps * seg.points.length; line._speedW += seg.points.length;
      if (seg.avgXtM !== null) { line._xtAcc += seg.avgXtM * seg.points.length; line._xtW += seg.points.length; }
      if (seg.avgHeightM !== null) { line._heightAcc += seg.avgHeightM * seg.points.length; line._heightW += seg.points.length; }
      if (seg.volumeL !== null) { line._volL += seg.volumeL; line._volKnown = true; }
      line._swathAcc += seg.swathM * seg.points.length; line._swathW += seg.points.length;
    }

    // attribute measured turn gaps to their line rows (mean when a line turned more than once) —
    // keyed by zone+llnum (via the gap's originating pass's LAST zone segment, now zone-assigned
    // above) so a reused llnum in a different zone can't inherit someone else's turn time
    const turnByLine = new Map();
    for (const g of turnGaps) {
      const key = passLastZone[g.passIndex] + ':' + g.beforeLlnum;
      if (!turnByLine.has(key)) turnByLine.set(key, []);
      turnByLine.get(key).push(g.seconds);
    }

    // NOT re-sorted by raw startTimeS: gpsTime wraps past midnight, so a plain numeric sort would
    // put a post-midnight line (small startTimeS) before a pre-midnight one (large startTimeS) —
    // backwards. lineMap's insertion order already IS chronological (Map iteration order = first-
    // insertion order = the order passes were built in push()'s stream order, and a pass for a given
    // zone+llnum key is always first encountered at its true starting time), so it's left as-is
    // rather than re-sorted with a wrap-unsafe comparator (FR-4.5 — ordered by start time).
    const lines = [...lineMap.values()].map(l => {
      const gaps = turnByLine.get(l.zoneIdx + ':' + l.llnum);
      return {
        zoneIdx: l.zoneIdx,
        llnum: l.llnum,
        startTimeS: l.startT,                                        // seconds of day
        sprayTimeS: l.sprayS,
        lengthM: l.lengthM,
        areaM2: l.areaM2,
        avgSpeedMps: l._speedW ? l._speedAcc / l._speedW : 0,
        avgXtM: l._xtW ? l._xtAcc / l._xtW : null,
        avgHeightM: l._heightW ? l._heightAcc / l._heightW : null,
        volumeL: l._volKnown ? l._volL : null,
        avgSwathM: l._swathW ? l._swathAcc / l._swathW : 0,
        turnTimeS: gaps && gaps.length ? gaps.reduce((a, b) => a + b, 0) / gaps.length : null
      };
    })
      // Drop fully-degenerate rows: zero length AND zero spray time (e.g. a single-point
      // fragment left over at a zone boundary). These already contribute nothing to any
      // weighted average below — every _speedAcc/_xtAcc/etc. accumulator above is weighted
      // by sprayTimeS or point count, so a 0-sprayTimeS line already adds value*0 — this
      // filter only removes the confusing "0 ft / 0 ac" row from the printed Flight Line
      // Statistics table and stops it from inflating lineCount. Deliberately conservative
      // (AND, not OR): a line with real length but zero measured spray time (or vice versa)
      // is kept, since it still reflects something that actually happened.
      .filter(l => l.lengthM > 0 || l.sprayTimeS > 0);

    // ---- zone roll-ups -------------------------------------------------------
    const zoneStats = zones.map((z, idx) => ({
      zoneIdx: idx,
      name: (z.properties && z.properties.name) || '',
      plannedAreaM2: plannedAreaM2(z, excludedAreas),
      sprayedAreaM2: 0, sprayTimeS: 0, flightTimeS: 0, volumeL: null,
      lineCount: 0, avgSpeedMps: null, avgXtM: null, avgHeightM: null,
      avgTurnTimeS: null, avgFlowLmin: null, avgSwathM: null,
      _firstT: null, _lastT: null, _speedAcc: 0, _speedW: 0,
      _xtAcc: 0, _xtW: 0, _heightAcc: 0, _heightW: 0, _turnAcc: 0, _turnN: 0,
      _swathAcc: 0, _swathW: 0
    }));

    for (const line of lines) {
      if (line.zoneIdx < 0 || line.zoneIdx >= zoneStats.length) continue;
      const zs = zoneStats[line.zoneIdx];
      zs.lineCount++;
      zs.sprayedAreaM2 += line.areaM2;
      zs.sprayTimeS += line.sprayTimeS;
      if (line.volumeL !== null) zs.volumeL = (zs.volumeL || 0) + line.volumeL;
      zs._speedAcc += line.avgSpeedMps * line.sprayTimeS; zs._speedW += line.sprayTimeS;
      if (line.avgXtM !== null) { zs._xtAcc += line.avgXtM * line.sprayTimeS; zs._xtW += line.sprayTimeS; }
      if (line.avgHeightM !== null) { zs._heightAcc += line.avgHeightM * line.sprayTimeS; zs._heightW += line.sprayTimeS; }
      if (line.turnTimeS !== null) { zs._turnAcc += line.turnTimeS; zs._turnN++; }
      zs._swathAcc += line.avgSwathM * line.sprayTimeS; zs._swathW += line.sprayTimeS;
      if (zs._firstT === null || todDiff(line.startTimeS, zs._firstT) < 0) zs._firstT = line.startTimeS;
      const lineEnd = line.startTimeS + line.sprayTimeS + (line.turnTimeS || 0);
      if (zs._lastT === null || todDiff(lineEnd, zs._lastT) > 0) zs._lastT = lineEnd;
    }

    for (const zs of zoneStats) {
      zs.avgSpeedMps = zs._speedW ? zs._speedAcc / zs._speedW : null;
      zs.avgXtM = zs._xtW ? zs._xtAcc / zs._xtW : null;
      zs.avgHeightM = zs._heightW ? zs._heightAcc / zs._heightW : null;
      zs.avgTurnTimeS = zs._turnN ? zs._turnAcc / zs._turnN : null;
      zs.avgSwathM = zs._swathW ? zs._swathAcc / zs._swathW : null;
      // zone flight time: first spray start to last spray end incl. its turn — spray + in-zone turns
      zs.flightTimeS = zs._firstT !== null ? todDiff(zs._lastT, zs._firstT) : 0;
      // exposed as their own fields (not just consumed via flightTimeS above) so the report can
      // show the actual start/end clock times, not just the elapsed duration between them
      zs.startTimeS = zs._firstT;
      zs.endTimeS = zs._lastT;
      zs.avgFlowLmin = (zs.volumeL !== null && zs.sprayTimeS > 0) ? zs.volumeL / (zs.sprayTimeS / 60) : null;
      // uncapped: a zone genuinely can be oversprayed past its own plan (swath overlap, turns,
      // re-flown sections — all normal in real spraying), and hiding that behind a 100% ceiling
      // throws away real information (e.g. how much extra product went down). The mission-level
      // coveragePct below is unaffected — it caps each zone's own CONTRIBUTION to that sum, but
      // this field is what gets displayed on the zone's own card/detail page.
      zs.coveragePct = zs.plannedAreaM2 > 0 ? (zs.sprayedAreaM2 / zs.plannedAreaM2) * 100 : null;
      delete zs._firstT; delete zs._lastT; delete zs._speedAcc; delete zs._speedW;
      delete zs._xtAcc; delete zs._xtW; delete zs._heightAcc; delete zs._heightW;
      delete zs._turnAcc; delete zs._turnN; delete zs._swathAcc; delete zs._swathW;
    }

    // ---- mission totals: exact sums / weighted means of the zone values ------
    const sprayed = zoneStats.filter(z => z.lineCount > 0);
    const sum = (arr, f) => arr.reduce((a, z) => a + f(z), 0);
    const wMean = (arr, vf, wf) => {
      let acc = 0, w = 0;
      for (const z of arr) { const v = vf(z); if (v !== null) { acc += v * wf(z); w += wf(z); } }
      return w ? acc / w : null;
    };

    // lines that landed in no zone at all — nearestZone() rejected even the closest match as
    // implausibly far (unrelated data: wrong file, GPS fault, mixed-in test data). Excluded from
    // every zone/mission total below the same way; summarized separately so the report can still
    // surface that this flight activity exists, instead of it just silently vanishing
    const assignedLines = lines.filter(l => l.zoneIdx >= 0 && l.zoneIdx < zoneStats.length);
    const unassignedLines = lines.filter(l => l.zoneIdx < 0 || l.zoneIdx >= zoneStats.length);

    const sprayTimeS = sum(sprayed, z => z.sprayTimeS);
    const sprayDistanceM = sum(assignedLines, l => l.lengthM);
    const volKnown = sprayed.some(z => z.volumeL !== null);
    const mission = {
      plannedAreaM2: sum(zoneStats, z => z.plannedAreaM2),
      sprayedAreaM2: sum(sprayed, z => z.sprayedAreaM2),
      sprayTimeS,
      totalFlightS: Math.max(totalFlightS, sprayTimeS),
      ferryTimeS: Math.max(totalFlightS - sprayTimeS, 0),
      totalDistanceM: Math.max(totalDistanceM, sprayDistanceM),
      sprayDistanceM,
      ferryDistanceM: Math.max(totalDistanceM - sprayDistanceM, 0),
      volumeL: volKnown ? sum(sprayed, z => z.volumeL || 0) : null,
      avgSpeedMps: wMean(sprayed, z => z.avgSpeedMps, z => z.sprayTimeS),
      // flat average of every spray-on reading (matches playback's playXt), not the
      // zone-weighted mean used by the other avg* fields — see missionXtAcc/missionXtN above
      avgXtM: missionXtN ? missionXtAcc / missionXtN : null,
      avgHeightM: wMean(sprayed, z => z.avgHeightM, z => z.sprayTimeS),
      avgSwathM: wMean(sprayed, z => z.avgSwathM, z => z.sprayTimeS),
      avgFlowLmin: null,
      zonesSprayed: sprayed.length,
      zonesTotal: zoneStats.length,
      lineCount: lines.length,
      unassigned: {
        lineCount: unassignedLines.length,
        sprayTimeS: sum(unassignedLines, l => l.sprayTimeS),
        lengthM: sum(unassignedLines, l => l.lengthM),
        areaM2: sum(unassignedLines, l => l.areaM2)
      }
    };
    mission.avgFlowLmin = (mission.volumeL !== null && sprayTimeS > 0) ? mission.volumeL / (sprayTimeS / 60) : null;
    // Coverage % caps each zone's contribution at its OWN planned area before summing, so an
    // overlapped/oversprayed zone can never numerically stand in for a zone that was never
    // touched at all — otherwise "100%" could be reached while some zones are still untouched,
    // contradicting zonesSprayed < zonesTotal. mission.sprayedAreaM2 itself stays the true,
    // uncapped swept-area total (a legitimate, separate figure — "how much ground was passed
    // over," overlap included) and is not changed by this.
    mission.coveragePct = mission.plannedAreaM2 > 0
      ? Math.min((sum(sprayed, z => Math.min(z.sprayedAreaM2, z.plannedAreaM2)) / mission.plannedAreaM2) * 100, 100)
      : null;

    const result = { lines, zones: zoneStats, mission };
    if (collectDraw)
      result.draw = {
        // spraydata.js `data[].data` / `data[].fdata` shape used by the map page. Each
        // segment carries its own zoneIdx (already computed above — a straddling pass is
        // now split into one segment per zone it actually crosses) so the Zone Detail
        // capture can show only the focused zone's own spray corridors instead of every
        // zone's — a zone's map page shouldn't display coverage that belongs to a
        // neighboring zone, and shouldn't display a neighboring zone's own crossing pass either.
        spray: segments.map(seg => ({
          zoneIdx: seg.zoneIdx,
          pts: seg.points.filter((_, i) => i % 2 === 0 || i === seg.points.length - 1)
            .map(p => [p.lat, p.lon])
        })),
        // Same zoneIdx tagging as spray above, and for the same reason: a flight/ferry
        // segment's own bounding box almost always spans the whole mission (it's transit
        // between zones), so a plain "does this layer's bounds overlap the focused zone"
        // check — which is how non-tagged layers get faded in applyZoneFocusStyle — is
        // never false for it; the segment would show at full opacity in every zone's
        // thumbnail/detail regardless of focus. Tagging each segment with the zone it
        // mostly passes through/near (majorityZone, same fallback to nearestZone as passes
        // use) lets applyZoneFocusStyle hide it the same explicit way it already hides
        // out-of-zone spray corridors.
        flight: flightSegs.map(pts => {
          const llPts = pts.map(p => ({ lat: p[0], lon: p[1] }));
          let zoneIdx = zoneFeatures.length ? majorityZone(llPts, zoneFeatures) : -1;
          if (zoneIdx < 0 && zoneCenters.length) zoneIdx = nearestZone(llPts[0], zoneCenters);
          return { zoneIdx, pts };
        })
      };
    return result;
  }

  return { push, fileBreak, finish, lineCount };
}

module.exports = {
  createMissionAnalytics,
  plannedAreaM2,
  todDiff,
};