// satellites.js - Satellite visualization module with real SGP4 positions and animations

import * as THREE from "three";
import { twoline2satrec, propagate } from "satellite.js";
import { CONFIG, SATELLITE_CONFIG } from "./constants.js";
import { latLonToVector3 } from "./utils.js";

let satellitePoints = null;
let satelliteBackdropPoints = null;
let satelliteTrails = null;
let satelliteData = [];
let showSatellites = false;
let showTrails = true;
let selectedSatellite = null;
let satellitePositions = [];
let hoverRingSprite = null;
let lockedRingSprite = null;
let lockedDotSprite = null;
let predictedOrbitLine = null;
let relatedSatelliteSprites = [];
let highlightedSatelliteIndices = null;
let earthObjRef = null;
let sceneRef = null;
let cameraRef = null;
let lockedSatelliteIndex = null;
let hoveredSatelliteIndex = null;
let positionUpdateAccumulator = 0;
let satelliteCapacity = 0;
let satelliteSatrecCache = new Map();

const TRAIL_LENGTH = SATELLITE_CONFIG.trailLength;
const DOT_TEXTURE_SIZE = 32;
const POSITION_UPDATE_INTERVAL_MS = 250;

const scratchWorldSatellitePosition = new THREE.Vector3();
const scratchToCamera = new THREE.Vector3();
const scratchToSatellite = new THREE.Vector3();

export let breathingPhase = 0;

const SATELLITE_LEGEND_RULES = [
  {
    key: "equatorial",
    label: "赤道轨道（0-30°）",
    color: "#ff3333",
    match: (props) => {
      const inclination = Number(props?.inclination ?? 0);
      return inclination >= 0 && inclination < 30;
    },
  },
  {
    key: "low",
    label: "低倾角轨道（30-60°）",
    color: "#ff9933",
    match: (props) => {
      const inclination = Number(props?.inclination ?? 0);
      return inclination >= 30 && inclination < 60;
    },
  },
  {
    key: "medium",
    label: "中倾角轨道（60-90°）",
    color: "#ffff33",
    match: (props) => {
      const inclination = Number(props?.inclination ?? 0);
      return inclination >= 60 && inclination < 90;
    },
  },
  {
    key: "high",
    label: "高倾角轨道（90-120°）",
    color: "#33ff33",
    match: (props) => {
      const inclination = Number(props?.inclination ?? 0);
      return inclination >= 90 && inclination < 120;
    },
  },
  {
    key: "retrograde",
    label: "逆行轨道（120-180°）",
    color: "#3333ff",
    match: (props) => {
      const inclination = Number(props?.inclination ?? 0);
      return inclination >= 120 && inclination <= 180;
    },
  },
  {
    key: "other",
    label: "其他",
    color: "#d7e2f4",
    match: () => true,
  },
];

const SATELLITE_RULE_COLOR_CACHE = new Map();

function getSatelliteLegendRule(props = {}) {
  return (
    SATELLITE_LEGEND_RULES.find((rule) => rule.match(props)) ||
    SATELLITE_LEGEND_RULES[SATELLITE_LEGEND_RULES.length - 1]
  );
}

function getSatelliteRuleColor(rule) {
  if (!rule) {
    return { r: 1, g: 1, b: 1 };
  }

  if (SATELLITE_RULE_COLOR_CACHE.has(rule.key)) {
    return SATELLITE_RULE_COLOR_CACHE.get(rule.key);
  }

  const color = new THREE.Color(rule.color);
  const rgb = { r: color.r, g: color.g, b: color.b };
  SATELLITE_RULE_COLOR_CACHE.set(rule.key, rgb);
  return rgb;
}

export function updateBreathingPhase(deltaTime = 16) {
  breathingPhase += SATELLITE_CONFIG.breathingSpeed * (deltaTime / 16);
}

function getBreathingPulse(phase) {
  return 0.5 + 0.5 * Math.sin(phase);
}

export function getSatelliteLegendItems() {
  const presentKeys = new Set();

  satelliteData.forEach((satellite) => {
    const props = satellite?.properties || {};
    const rule = SATELLITE_LEGEND_RULES.find((item) => item.match(props));
    if (rule) {
      presentKeys.add(rule.key);
    }
  });

  if (presentKeys.size === 0) {
    return SATELLITE_LEGEND_RULES.map(({ label, color }) => ({ label, color }));
  }

  const items = SATELLITE_LEGEND_RULES
    .filter((item) => presentKeys.has(item.key))
    .map(({ key, label, color }) => ({ key, label, color }));

  return items.map(({ label, color }) => ({ label, color }));
}

export function setSelectedSatelliteLegend(props) {
  return getSatelliteLegendRule(props || {});
}

export function clearSelectedSatelliteLegend() {
  return null;
}

function disposeMaterial(material) {
  if (!material) return;
  if (Array.isArray(material)) {
    material.forEach(disposeMaterial);
    return;
  }
  if (material.map) {
    material.map.dispose();
  }
  material.dispose();
}

function disposeObject3D(object, parent = earthObjRef) {
  if (!object) return;
  if (parent) {
    parent.remove(object);
  } else if (object.parent) {
    object.parent.remove(object);
  }
  if (object.geometry) {
    object.geometry.dispose();
  }
  if (object.material) {
    disposeMaterial(object.material);
  }
}

function createDotTexture() {
  const canvas = document.createElement("canvas");
  canvas.width = DOT_TEXTURE_SIZE;
  canvas.height = DOT_TEXTURE_SIZE;
  const ctx = canvas.getContext("2d");
  const center = DOT_TEXTURE_SIZE / 2;
  const radius = center - 2;

  const gradient = ctx.createRadialGradient(
    center,
    center,
    0,
    center,
    center,
    radius,
  );
  gradient.addColorStop(0, "rgba(255, 255, 255, 1)");
  gradient.addColorStop(0.5, "rgba(255, 255, 255, 0.8)");
  gradient.addColorStop(1, "rgba(255, 255, 255, 0)");

  ctx.fillStyle = gradient;
  ctx.beginPath();
  ctx.arc(center, center, radius, 0, Math.PI * 2);
  ctx.fill();

  const texture = new THREE.CanvasTexture(canvas);
  texture.needsUpdate = true;
  return texture;
}

function createBackdropDotTexture() {
  const canvas = document.createElement("canvas");
  canvas.width = DOT_TEXTURE_SIZE;
  canvas.height = DOT_TEXTURE_SIZE;
  const ctx = canvas.getContext("2d");
  const center = DOT_TEXTURE_SIZE / 2;
  const radius = center - 1;

  const gradient = ctx.createRadialGradient(
    center,
    center,
    0,
    center,
    center,
    radius,
  );
  gradient.addColorStop(0, "rgba(7, 14, 27, 0.98)");
  gradient.addColorStop(0.55, "rgba(7, 14, 27, 0.88)");
  gradient.addColorStop(0.85, "rgba(7, 14, 27, 0.34)");
  gradient.addColorStop(1, "rgba(7, 14, 27, 0)");

  ctx.fillStyle = gradient;
  ctx.beginPath();
  ctx.arc(center, center, radius, 0, Math.PI * 2);
  ctx.fill();

  const texture = new THREE.CanvasTexture(canvas);
  texture.needsUpdate = true;
  return texture;
}

function createRingTexture(innerRadius, outerRadius, color = "#ffffff") {
  const size = DOT_TEXTURE_SIZE * 2;
  const canvas = document.createElement("canvas");
  canvas.width = size;
  canvas.height = size;
  const ctx = canvas.getContext("2d");
  const center = size / 2;

  ctx.strokeStyle = color;
  ctx.lineWidth = 3;
  ctx.beginPath();
  ctx.arc(center, center, (innerRadius + outerRadius) / 2, 0, Math.PI * 2);
  ctx.stroke();

  const texture = new THREE.CanvasTexture(canvas);
  texture.needsUpdate = true;
  return texture;
}

export function createSatellites(scene, earthObj) {
  initSatelliteScene(scene, earthObj);
  const dotTexture = createDotTexture();
  const backdropTexture = createBackdropDotTexture();

  const pointsGeometry = new THREE.BufferGeometry();
  const backdropGeometry = new THREE.BufferGeometry();

  const backdropMaterial = new THREE.PointsMaterial({
    size: SATELLITE_CONFIG.dotSize * 1.28,
    map: backdropTexture,
    color: 0x0b1626,
    transparent: true,
    opacity: 0.42,
    sizeAttenuation: false,
    alphaTest: 0.04,
    depthWrite: false,
  });

  const pointsMaterial = new THREE.PointsMaterial({
    size: SATELLITE_CONFIG.dotSize,
    map: dotTexture,
    vertexColors: true,
    transparent: true,
    opacity: 0.9,
    sizeAttenuation: false,
    alphaTest: 0.1,
    depthWrite: false,
  });

  satelliteBackdropPoints = new THREE.Points(backdropGeometry, backdropMaterial);
  satelliteBackdropPoints.visible = false;
  satelliteBackdropPoints.userData = { type: "satelliteBackdropPoints" };
  satelliteBackdropPoints.renderOrder = 5;

  satellitePoints = new THREE.Points(pointsGeometry, pointsMaterial);
  satellitePoints.visible = false;
  satellitePoints.userData = { type: "satellitePoints" };
  satellitePoints.renderOrder = 6;

  const originalScale = { x: 1, y: 1, z: 1 };
  const syncPointScale = () => {
    if (earthObj && earthObj.scale.x !== 1) {
      const scaleX = originalScale.x / earthObj.scale.x;
      const scaleY = originalScale.y / earthObj.scale.y;
      const scaleZ = originalScale.z / earthObj.scale.z;
      satellitePoints.scale.set(scaleX, scaleY, scaleZ);
      if (satelliteBackdropPoints) {
        satelliteBackdropPoints.scale.set(scaleX, scaleY, scaleZ);
      }
    } else {
      satellitePoints.scale.set(originalScale.x, originalScale.y, originalScale.z);
      if (satelliteBackdropPoints) {
        satelliteBackdropPoints.scale.set(
          originalScale.x,
          originalScale.y,
          originalScale.z,
        );
      }
    }
  };

  satelliteBackdropPoints.onBeforeRender = syncPointScale;
  satellitePoints.onBeforeRender = syncPointScale;

  earthObj.add(satelliteBackdropPoints);
  earthObj.add(satellitePoints);

  const trailGeometry = new THREE.BufferGeometry();

  const trailMaterial = new THREE.LineBasicMaterial({
    vertexColors: true,
    transparent: true,
    opacity: 0.3,
    blending: THREE.AdditiveBlending,
  });

  satelliteTrails = new THREE.LineSegments(trailGeometry, trailMaterial);
  satelliteTrails.visible = false;
  satelliteTrails.userData = { type: "satelliteTrails" };
  earthObj.add(satelliteTrails);
  ensureSatelliteCapacity(0);

  positionUpdateAccumulator = POSITION_UPDATE_INTERVAL_MS;
  return satellitePoints;
}

function getRequestedSatelliteLimit(limitOverride) {
  if (limitOverride === null) return null;
  if (Number.isFinite(limitOverride) && limitOverride > 0) {
    return Math.floor(limitOverride);
  }

  return SATELLITE_CONFIG.maxCount < 0 ? null : SATELLITE_CONFIG.maxCount;
}

function createSatellitePositionState() {
  return {
    current: new THREE.Vector3(),
    trail: [],
    trailIndex: 0,
    trailCount: 0,
  };
}

function ensureSatelliteCapacity(count) {
  if (!satellitePoints || !satelliteBackdropPoints || !satelliteTrails) return;

  const nextCapacity = Math.max(count, 0);
  if (nextCapacity === satelliteCapacity) return;

  const previousPointPositions =
    satellitePoints.geometry.attributes.position?.array || null;
  const previousBackdropPositions =
    satelliteBackdropPoints.geometry.attributes.position?.array || null;
  const previousColors = satellitePoints.geometry.attributes.color?.array || null;
  const previousTrailPositions =
    satelliteTrails.geometry.attributes.position?.array || null;
  const previousTrailColors =
    satelliteTrails.geometry.attributes.color?.array || null;
  const previousSatellitePositions = satellitePositions;
  const previousCapacity = satelliteCapacity;

  const positions = new Float32Array(nextCapacity * 3);
  const backdropPositions = new Float32Array(nextCapacity * 3);
  const colors = new Float32Array(nextCapacity * 3);
  if (previousPointPositions) {
    positions.set(
      previousPointPositions.subarray(0, Math.min(previousPointPositions.length, positions.length)),
    );
  }
  if (previousBackdropPositions) {
    backdropPositions.set(
      previousBackdropPositions.subarray(
        0,
        Math.min(previousBackdropPositions.length, backdropPositions.length),
      ),
    );
  }
  if (previousColors) {
    colors.set(previousColors.subarray(0, Math.min(previousColors.length, colors.length)));
  }
  satelliteBackdropPoints.geometry.setAttribute(
    "position",
    new THREE.BufferAttribute(backdropPositions, 3),
  );
  satelliteBackdropPoints.geometry.setDrawRange(
    0,
    Math.min(previousCapacity, nextCapacity),
  );
  satellitePoints.geometry.setAttribute(
    "position",
    new THREE.BufferAttribute(positions, 3),
  );
  satellitePoints.geometry.setAttribute(
    "color",
    new THREE.BufferAttribute(colors, 3),
  );
  satellitePoints.geometry.setDrawRange(0, Math.min(previousCapacity, nextCapacity));

  const trailPositions = new Float32Array(nextCapacity * TRAIL_LENGTH * 3);
  const trailColors = new Float32Array(nextCapacity * TRAIL_LENGTH * 3);
  if (previousTrailPositions) {
    trailPositions.set(
      previousTrailPositions.subarray(
        0,
        Math.min(previousTrailPositions.length, trailPositions.length),
      ),
    );
  }
  if (previousTrailColors) {
    trailColors.set(
      previousTrailColors.subarray(
        0,
        Math.min(previousTrailColors.length, trailColors.length),
      ),
    );
  }
  satelliteTrails.geometry.setAttribute(
    "position",
    new THREE.BufferAttribute(trailPositions, 3),
  );
  satelliteTrails.geometry.setAttribute(
    "color",
    new THREE.BufferAttribute(trailColors, 3),
  );

  satellitePositions = Array.from({ length: nextCapacity }, (_, index) => {
    const previousState = previousSatellitePositions[index];
    if (!previousState) {
      return createSatellitePositionState();
    }

    return {
      current: previousState.current.clone(),
      trail: previousState.trail.slice(),
      trailIndex: previousState.trailIndex,
      trailCount: previousState.trailCount,
    };
  });
  satelliteCapacity = nextCapacity;
}

function computeSatellitePosition(satellite, time) {
  try {
    const props = satellite.properties;
    if (!props || !props.norad_cat_id) {
      return null;
    }

    const satrec = getOrBuildSatrec(props, time);
    if (!satrec || satrec.error) {
      return null;
    }

    const positionAndVelocity = propagate(satrec, time);
    if (!positionAndVelocity || !positionAndVelocity.position) {
      return null;
    }

    const x = positionAndVelocity.position.x;
    const y = positionAndVelocity.position.y;
    const z = positionAndVelocity.position.z;

    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) {
      return null;
    }

    const r = Math.sqrt(x * x + y * y + z * z);
    const displayRadius =
      CONFIG.earthRadius + SATELLITE_CONFIG.displayAltitudeOffset;
    const scale = displayRadius / r;

    return new THREE.Vector3(x * scale, y * scale, z * scale);
  } catch (error) {
    return null;
  }
}

function buildSatrecFromProperties(props, fallbackTime) {
  if (props.tle_line1 && props.tle_line2) {
    // Prefer source-provided TLE lines so the client does not need to rebuild them.
    const satrec = twoline2satrec(props.tle_line1, props.tle_line2);
    if (!satrec.error) {
      return satrec;
    }
  }

  const tleLines = buildTleLinesFromElements(props, fallbackTime);
  if (!tleLines) {
    return null;
  }

  return twoline2satrec(tleLines.line1, tleLines.line2);
}

function getSatelliteSatrecCacheKey(props) {
  if (!props?.norad_cat_id) {
    return null;
  }

  if (props.tle_line1 && props.tle_line2) {
    return `tle:${props.norad_cat_id}:${props.tle_line1}:${props.tle_line2}`;
  }

  if (props.epoch) {
    return [
      "elements",
      props.norad_cat_id,
      props.epoch,
      props.inclination,
      props.raan,
      props.eccentricity,
      props.arg_of_perigee,
      props.mean_anomaly,
      props.mean_motion,
    ].join(":");
  }

  return null;
}

function getOrBuildSatrec(props, fallbackTime) {
  const cacheKey = getSatelliteSatrecCacheKey(props);
  if (cacheKey && satelliteSatrecCache.has(cacheKey)) {
    return satelliteSatrecCache.get(cacheKey);
  }

  const satrec = buildSatrecFromProperties(props, fallbackTime);
  if (cacheKey && satrec && !satrec.error) {
    satelliteSatrecCache.set(cacheKey, satrec);
  }
  return satrec;
}

function computeTleChecksum(line) {
  let sum = 0;

  for (const char of line.slice(0, 68)) {
    if (char >= "0" && char <= "9") {
      sum += Number(char);
    } else if (char === "-") {
      sum += 1;
    }
  }

  return String(sum % 10);
}

function buildTleLinesFromElements(props, fallbackTime) {
  if (!props?.norad_cat_id) {
    return null;
  }

  const requiredValues = [
    props.inclination,
    props.raan,
    props.eccentricity,
    props.arg_of_perigee,
    props.mean_anomaly,
    props.mean_motion,
  ];
  if (requiredValues.some((value) => value === null || value === undefined)) {
    return null;
  }

  const epochDate =
    props.epoch && String(props.epoch).length >= 10
      ? new Date(props.epoch)
      : fallbackTime;
  if (Number.isNaN(epochDate.getTime())) {
    return null;
  }

  const epochYear = epochDate.getUTCFullYear() % 100;
  const startOfYear = new Date(Date.UTC(epochDate.getUTCFullYear(), 0, 1));
  const dayOfYear = Math.floor((epochDate - startOfYear) / 86400000) + 1;
  const msOfDay =
    epochDate.getUTCHours() * 3600000 +
    epochDate.getUTCMinutes() * 60000 +
    epochDate.getUTCSeconds() * 1000 +
    epochDate.getUTCMilliseconds();
  const dayFraction = msOfDay / 86400000;
  const epochStr =
    String(epochYear).padStart(2, "0") +
    String(dayOfYear).padStart(3, "0") +
    dayFraction.toFixed(8).slice(1);

  const eccentricityDigits = Math.round(Number(props.eccentricity) * 1e7)
    .toString()
    .padStart(7, "0");

  // Keep a local fallback for historical rows that do not have stored TLE lines yet.
  const line1Core = `1 ${String(props.norad_cat_id).padStart(5, "0")}U 00001A   ${epochStr}  .00000000  00000-0  00000-0 0  999`;
  const line2Core = `2 ${String(props.norad_cat_id).padStart(5, "0")} ${Number(
    props.inclination,
  )
    .toFixed(4)
    .padStart(
      8,
    )} ${Number(props.raan).toFixed(4).padStart(8)} ${eccentricityDigits} ${Number(
    props.arg_of_perigee,
  )
    .toFixed(4)
    .padStart(8)} ${Number(props.mean_anomaly).toFixed(4).padStart(8)} ${Number(
    props.mean_motion,
  )
    .toFixed(8)
    .padStart(11)}00000`;

  return {
    line1: line1Core + computeTleChecksum(line1Core),
    line2: line2Core + computeTleChecksum(line2Core),
  };
}

function generateFallbackPosition(satellite, index, total) {
  const radius = CONFIG.earthRadius + SATELLITE_CONFIG.displayAltitudeOffset;

  const noradId = satellite.properties?.norad_cat_id || index;
  const inclination = satellite.properties?.inclination || 53;
  const raan = satellite.properties?.raan || 0;
  const meanAnomaly = satellite.properties?.mean_anomaly || 0;

  const hash = String(noradId)
    .split("")
    .reduce((a, b) => a + b.charCodeAt(0), 0);
  const randomOffset = (hash % 1000) / 1000;

  const normalizedIndex = index / total;
  const theta = normalizedIndex * Math.PI * 2 * 10 + (raan * Math.PI) / 180;
  const phi =
    (inclination * Math.PI) / 180 + ((meanAnomaly * Math.PI) / 180) * 0.1;

  const adjustedPhi = Math.abs(phi % Math.PI);
  const adjustedTheta = theta + randomOffset * Math.PI * 2;

  const x = radius * Math.sin(adjustedPhi) * Math.cos(adjustedTheta);
  const y = radius * Math.cos(adjustedPhi);
  const z = radius * Math.sin(adjustedPhi) * Math.sin(adjustedTheta);

  return new THREE.Vector3(x, y, z);
}

export async function loadSatellites(options = {}) {
  const limit = getRequestedSatelliteLimit(options.limit);
  const url = new URL(SATELLITE_CONFIG.apiPath, window.location.origin);
  if (limit !== null) {
    url.searchParams.set("limit", String(limit));
  }

  const response = await fetch(url.toString());
  if (!response.ok) {
    throw new Error(`卫星接口返回 HTTP ${response.status}`);
  }

  const data = await response.json();
  satelliteData = data.features || [];
  satelliteSatrecCache = new Map();
  ensureSatelliteCapacity(satelliteData.length);
  positionUpdateAccumulator = POSITION_UPDATE_INTERVAL_MS;
  return {
    count: satelliteData.length,
    requestedLimit: limit,
  };
}

export function updateSatellitePositions(deltaTime = 0, force = false) {
  if (!satellitePoints || !satelliteBackdropPoints || satelliteData.length === 0) return;

  const shouldUpdateTrails =
    showSatellites || showTrails || lockedSatelliteIndex !== null;
  positionUpdateAccumulator += deltaTime;

  if (!force && positionUpdateAccumulator < POSITION_UPDATE_INTERVAL_MS) {
    return;
  }

  const elapsedMs = Math.max(
    positionUpdateAccumulator,
    POSITION_UPDATE_INTERVAL_MS,
  );
  positionUpdateAccumulator = 0;

  const positions = satellitePoints.geometry.attributes.position.array;
  const backdropPositions =
    satelliteBackdropPoints.geometry.attributes.position.array;
  const colors = satellitePoints.geometry.attributes.color.array;
  const trailPositions = satelliteTrails.geometry.attributes.position.array;
  const trailColors = satelliteTrails.geometry.attributes.color.array;
  const baseTime = new Date(Date.now() + elapsedMs);
  const count = Math.min(satelliteData.length, satelliteCapacity);

  for (let i = 0; i < count; i++) {
    const satellite = satelliteData[i];
    const props = satellite.properties;
    const timeOffset = (i / count) * 2 * Math.PI * 0.1;
    const adjustedTime = new Date(
      baseTime.getTime() + timeOffset * 1000 * 60 * 10,
    );

    let pos = computeSatellitePosition(satellite, adjustedTime);
    if (!pos) {
      pos = generateFallbackPosition(satellite, i, count);
    }

    satellitePositions[i].current.copy(pos);

    if (shouldUpdateTrails && i !== lockedSatelliteIndex) {
      const satPos = satellitePositions[i];
      satPos.trail[satPos.trailIndex] = pos.clone();
      satPos.trailIndex = (satPos.trailIndex + 1) % TRAIL_LENGTH;
      if (satPos.trailCount < TRAIL_LENGTH) satPos.trailCount++;
    }

    positions[i * 3] = pos.x;
    positions[i * 3 + 1] = pos.y;
    positions[i * 3 + 2] = pos.z;
    backdropPositions[i * 3] = pos.x;
    backdropPositions[i * 3 + 1] = pos.y;
    backdropPositions[i * 3 + 2] = pos.z;

    const rule = getSatelliteLegendRule(props);
    const { r, g, b } = getSatelliteRuleColor(rule);

    if (highlightedSatelliteIndices !== null && !highlightedSatelliteIndices.has(i)) {
      const lum = r * 0.299 + g * 0.587 + b * 0.114;
      colors[i * 3]     = lum * 0.75 + r * 0.25;
      colors[i * 3 + 1] = lum * 0.75 + g * 0.25;
      colors[i * 3 + 2] = lum * 0.75 + b * 0.25;
    } else {
      colors[i * 3]     = r;
      colors[i * 3 + 1] = g;
      colors[i * 3 + 2] = b;
    }

    const satPosition = satellitePositions[i];
    for (let j = 0; j < TRAIL_LENGTH; j++) {
      const trailIdx = (i * TRAIL_LENGTH + j) * 3;

      if (j < satPosition.trailCount) {
        const idx =
          (satPosition.trailIndex - satPosition.trailCount + j + TRAIL_LENGTH) %
          TRAIL_LENGTH;
        const trailPoint = satPosition.trail[idx];
        if (trailPoint) {
          trailPositions[trailIdx] = trailPoint.x;
          trailPositions[trailIdx + 1] = trailPoint.y;
          trailPositions[trailIdx + 2] = trailPoint.z;
          const alpha = (j + 1) / satPosition.trailCount;
          trailColors[trailIdx] = r * alpha;
          trailColors[trailIdx + 1] = g * alpha;
          trailColors[trailIdx + 2] = b * alpha;
          continue;
        }
      }

      trailPositions[trailIdx] = pos.x;
      trailPositions[trailIdx + 1] = pos.y;
      trailPositions[trailIdx + 2] = pos.z;
      trailColors[trailIdx] = 0;
      trailColors[trailIdx + 1] = 0;
      trailColors[trailIdx + 2] = 0;
    }
  }

  for (let i = count; i < satelliteCapacity; i++) {
    positions[i * 3] = 0;
    positions[i * 3 + 1] = 0;
    positions[i * 3 + 2] = 0;
    backdropPositions[i * 3] = 0;
    backdropPositions[i * 3 + 1] = 0;
    backdropPositions[i * 3 + 2] = 0;

    for (let j = 0; j < TRAIL_LENGTH; j++) {
      const trailIdx = (i * TRAIL_LENGTH + j) * 3;
      trailPositions[trailIdx] = 0;
      trailPositions[trailIdx + 1] = 0;
      trailPositions[trailIdx + 2] = 0;
    }
  }

  satellitePoints.geometry.attributes.position.needsUpdate = true;
  satellitePoints.geometry.attributes.color.needsUpdate = true;
  satellitePoints.geometry.setDrawRange(0, count);
  satelliteBackdropPoints.geometry.attributes.position.needsUpdate = true;
  satelliteBackdropPoints.geometry.setDrawRange(0, count);

  satelliteTrails.geometry.attributes.position.needsUpdate = true;
  satelliteTrails.geometry.attributes.color.needsUpdate = true;

  // Keep the hover ring synced with the propagated satellite position even
  // when the pointer stays still and no new hover event is emitted.
  if (
    hoveredSatelliteIndex !== null &&
    hoveredSatelliteIndex >= 0 &&
    hoveredSatelliteIndex < count &&
    hoveredSatelliteIndex !== lockedSatelliteIndex
  ) {
    updateHoverRingPosition(satellitePositions[hoveredSatelliteIndex].current);
  }
}

export function toggleSatellites(visible) {
  showSatellites = visible;
  if (satelliteBackdropPoints) {
    satelliteBackdropPoints.visible = visible;
  }
  if (satellitePoints) {
    satellitePoints.visible = visible;
  }
  if (satelliteTrails) {
    satelliteTrails.visible = visible && showTrails;
  }
}

export function toggleTrails(visible) {
  showTrails = visible;
  if (satelliteTrails) {
    satelliteTrails.visible = visible && showSatellites;
  }
}

export function getShowTrails() {
  return showTrails;
}

export function getShowSatellites() {
  return showSatellites;
}

export function getSatelliteCount() {
  return satelliteData.length;
}

export function getSatelliteAt(index) {
  if (index >= 0 && index < satelliteData.length) {
    return satelliteData[index];
  }
  return null;
}

export function getSatelliteData() {
  return satelliteData;
}

export function selectSatellite(index) {
  selectedSatellite = index;
  return getSatelliteAt(index);
}

export function getSatellitePoints() {
  return satellitePoints;
}

export function getSatellitePositions() {
  return satellitePositions;
}

export function setSatelliteCamera(camera) {
  cameraRef = camera;
}

export function setLockedSatelliteIndex(index) {
  lockedSatelliteIndex = index;
}

export function setHoveredSatelliteIndex(index) {
  hoveredSatelliteIndex = index;
}

export function isSatelliteFrontFacing(index, camera = cameraRef) {
  if (!earthObjRef || !camera) return true;
  if (!satellitePositions || !satellitePositions[index]) return true;

  const satPos = satellitePositions[index].current;
  if (!satPos) return true;

  scratchWorldSatellitePosition
    .copy(satPos)
    .applyMatrix4(earthObjRef.matrixWorld);
  scratchToCamera.subVectors(camera.position, earthObjRef.position).normalize();
  scratchToSatellite
    .subVectors(scratchWorldSatellitePosition, earthObjRef.position)
    .normalize();

  return (
    scratchToCamera.dot(scratchToSatellite) >
    SATELLITE_CONFIG.frontFacingDotThreshold
  );
}

function createBrighterDotCanvas() {
  const size = DOT_TEXTURE_SIZE * 2;
  const canvas = document.createElement("canvas");
  canvas.width = size;
  canvas.height = size;
  const ctx = canvas.getContext("2d");
  const center = size / 2;
  const gradient = ctx.createRadialGradient(
    center,
    center,
    0,
    center,
    center,
    center,
  );
  gradient.addColorStop(0, "rgba(255, 255, 200, 1)");
  gradient.addColorStop(0.3, "rgba(255, 220, 100, 0.9)");
  gradient.addColorStop(0.7, "rgba(255, 180, 50, 0.5)");
  gradient.addColorStop(1, "rgba(255, 150, 0, 0)");
  ctx.fillStyle = gradient;
  ctx.fillRect(0, 0, size, size);
  return canvas;
}

function createRingSprite(position, isLocked = false) {
  if (!earthObjRef) return null;

  const ringTexture = createRingTexture(
    8,
    12,
    isLocked ? "#ffcc00" : "#ffffff",
  );
  const spriteMaterial = new THREE.SpriteMaterial({
    map: ringTexture,
    transparent: true,
    opacity: 0.8,
    depthTest: false,
    sizeAttenuation: false,
  });

  const sprite = new THREE.Sprite(spriteMaterial);
  sprite.position.copy(position);
  sprite.scale.set(SATELLITE_CONFIG.ringSize, SATELLITE_CONFIG.ringSize, 1);
  sprite.renderOrder = SATELLITE_CONFIG.overlayRenderOrder;
  earthObjRef.add(sprite);
  return sprite;
}

function createRelatedSatelliteSprite(position, color = "#7dd3fc") {
  if (!earthObjRef) return null;

  const ringTexture = createRingTexture(7, 11, color);
  const spriteMaterial = new THREE.SpriteMaterial({
    map: ringTexture,
    transparent: true,
    opacity: 0.55,
    depthTest: false,
    sizeAttenuation: false,
  });

  const sprite = new THREE.Sprite(spriteMaterial);
  sprite.position.copy(position);
  sprite.scale.set(SATELLITE_CONFIG.ringSize * 0.8, SATELLITE_CONFIG.ringSize * 0.8, 1);
  sprite.renderOrder = SATELLITE_CONFIG.overlayRenderOrder;
  earthObjRef.add(sprite);
  return sprite;
}

export function showHoverRing(position, isLocked = false) {
  if (!earthObjRef || !position) return null;

  if (isLocked) {
    hideLockedRing();
    lockedRingSprite = createRingSprite(position, true);

    const dotCanvas = createBrighterDotCanvas();
    const dotTexture = new THREE.CanvasTexture(dotCanvas);
    const dotMaterial = new THREE.SpriteMaterial({
      map: dotTexture,
      transparent: true,
      opacity: 1.0,
      depthTest: false,
    });
    lockedDotSprite = new THREE.Sprite(dotMaterial);
    lockedDotSprite.position.copy(position);
    lockedDotSprite.scale.set(4, 4, 1);
    lockedDotSprite.renderOrder = SATELLITE_CONFIG.overlayRenderOrder + 1;
    earthObjRef.add(lockedDotSprite);
    return lockedRingSprite;
  }

  hideHoverRings();
  hoverRingSprite = createRingSprite(position, false);
  return hoverRingSprite;
}

export function hideHoverRings() {
  if (hoverRingSprite) {
    disposeObject3D(hoverRingSprite);
    hoverRingSprite = null;
  }
}

export function hideLockedRing() {
  if (lockedRingSprite) {
    disposeObject3D(lockedRingSprite);
    lockedRingSprite = null;
  }
  if (lockedDotSprite) {
    disposeObject3D(lockedDotSprite);
    lockedDotSprite = null;
  }
}

export function updateLockedRingPosition(position) {
  if (!position) return;
  if (!lockedRingSprite || !lockedDotSprite) {
    showHoverRing(position, true);
  }
  if (lockedRingSprite) {
    lockedRingSprite.position.copy(position);
    const ringPulse = getBreathingPulse(breathingPhase);
    const breathScale =
      1 +
      (ringPulse * 2 - 1) * SATELLITE_CONFIG.breathingScaleAmplitude;
    lockedRingSprite.scale.set(
      SATELLITE_CONFIG.ringSize * breathScale,
      SATELLITE_CONFIG.ringSize * breathScale,
      1,
    );
    lockedRingSprite.material.opacity =
      SATELLITE_CONFIG.breathingOpacityMin +
      ringPulse *
        (SATELLITE_CONFIG.breathingOpacityMax -
          SATELLITE_CONFIG.breathingOpacityMin);
  }

  if (lockedDotSprite) {
    lockedDotSprite.position.copy(position);
    const dotPulse = getBreathingPulse(breathingPhase);
    const dotBreathScale =
      1 +
      (dotPulse * 2 - 1) * SATELLITE_CONFIG.dotBreathingScaleAmplitude;
    lockedDotSprite.scale.set(4 * dotBreathScale, 4 * dotBreathScale, 1);
    lockedDotSprite.material.opacity =
      SATELLITE_CONFIG.dotOpacityMin +
      dotPulse *
        (SATELLITE_CONFIG.dotOpacityMax - SATELLITE_CONFIG.dotOpacityMin);
  }
}

export function updateHoverRingPosition(position) {
  if (hoverRingSprite && position) {
    hoverRingSprite.position.copy(position);
    hoverRingSprite.scale.set(
      SATELLITE_CONFIG.ringSize,
      SATELLITE_CONFIG.ringSize,
      1,
    );
  }
}

export function setSatelliteRingState(index, state, position) {
  switch (state) {
    case "hover":
      hoveredSatelliteIndex = index;
      hideHoverRings();
      showHoverRing(position, false);
      break;
    case "locked":
      hoveredSatelliteIndex = null;
      hideHoverRings();
      showHoverRing(position, true);
      break;
    case "none":
      hoveredSatelliteIndex = null;
      hideHoverRings();
      hideLockedRing();
      break;
  }
}

function applyDimMaterialState(isDimmed) {
  if (satellitePoints) {
    satellitePoints.material.opacity = isDimmed ? 0.32 : 0.9;
  }
  if (satelliteBackdropPoints) {
    satelliteBackdropPoints.material.opacity = isDimmed ? 0.12 : 0.42;
  }
}

export function clearRelatedSatelliteHighlights() {
  relatedSatelliteSprites.forEach((item) => {
    if (item.sprite) {
      disposeObject3D(item.sprite);
    }
  });
  relatedSatelliteSprites = [];
  highlightedSatelliteIndices = null;
  applyDimMaterialState(false);
}

export function highlightRelatedSatellites(indices, color = "#7dd3fc") {
  clearRelatedSatelliteHighlights();
  if (!Array.isArray(indices) || indices.length === 0) return;

  highlightedSatelliteIndices = new Set(indices);
  applyDimMaterialState(true);
  indices.forEach((index) => {
    const pos = satellitePositions?.[index]?.current;
    if (!pos) return;
    const sprite = createRelatedSatelliteSprite(pos, color);
    if (!sprite) return;
    relatedSatelliteSprites.push({ index, sprite, color });
  });
}

export function updateRelatedSatelliteHighlights() {
  if (relatedSatelliteSprites.length === 0) return;
  relatedSatelliteSprites = relatedSatelliteSprites.filter((item) => {
    const pos = satellitePositions?.[item.index]?.current;
    if (!pos || !item.sprite) return false;
    item.sprite.position.copy(pos);
    return true;
  });
}

export function getRelatedSatelliteIndicesForRegions(
  regions,
  { limit = 6, maxAngleDeg = 22 } = {},
) {
  if (!Array.isArray(regions) || regions.length === 0 || satellitePositions.length === 0) {
    return [];
  }

  const regionVectors = regions
    .filter(
      (region) =>
        typeof region?.latitude === "number" &&
        typeof region?.longitude === "number",
    )
    .map((region) =>
      latLonToVector3(region.latitude, region.longitude, CONFIG.earthRadius + 1)
        .clone()
        .normalize(),
    );

  if (regionVectors.length === 0) return [];

  const threshold = Math.cos((maxAngleDeg * Math.PI) / 180);
  const ranked = [];

  satellitePositions.forEach((item, index) => {
    const current = item?.current;
    if (!current || current.lengthSq() === 0) return;
    const satVector = current.clone().normalize();
    let bestDot = -1;
    regionVectors.forEach((regionVector) => {
      bestDot = Math.max(bestDot, satVector.dot(regionVector));
    });
    if (bestDot >= threshold) {
      ranked.push({ index, score: bestDot });
    }
  });

  return ranked
    .sort((a, b) => b.score - a.score)
    .slice(0, limit)
    .map((item) => item.index);
}

export function initSatelliteScene(scene, earth) {
  sceneRef = scene;
  earthObjRef = earth;
}

function calculateOrbitalPeriod(meanMotion) {
  return 86400 / meanMotion;
}

function calculatePredictedOrbit(
  satellite,
  periodSeconds,
  sampleInterval = 10,
) {
  const points = [];
  const samples = Math.ceil(periodSeconds / sampleInterval);
  const now = new Date();

  for (let i = 0; i <= samples; i++) {
    const time = new Date(now.getTime() + i * sampleInterval * 1000);
    const pos = computeSatellitePosition(satellite, time);
    if (pos) points.push(pos);
  }

  if (points.length < samples * 0.5) {
    points.length = 0;
    const radius =
      CONFIG.earthRadius + SATELLITE_CONFIG.displayAltitudeOffset;
    const inclination = satellite.properties?.inclination || 53;
    const raan = satellite.properties?.raan || 0;

    for (let i = 0; i <= samples; i++) {
      const theta = (i / samples) * Math.PI * 2;
      const phi = (inclination * Math.PI) / 180;
      const x =
        radius * Math.sin(phi) * Math.cos(theta + (raan * Math.PI) / 180);
      const y = radius * Math.cos(phi);
      const z =
        radius * Math.sin(phi) * Math.sin(theta + (raan * Math.PI) / 180);
      points.push(new THREE.Vector3(x, y, z));
    }
  }

  return points;
}

export function showPredictedOrbit(satellite) {
  hidePredictedOrbit();
  if (!earthObjRef) return;

  const meanMotion = satellite.properties?.mean_motion || 15;
  const periodSeconds = calculateOrbitalPeriod(meanMotion);
  const points = calculatePredictedOrbit(satellite, periodSeconds);
  if (points.length < 2) return;

  const positions = new Float32Array(points.length * 3);
  const colors = new Float32Array(points.length * 3);

  for (let i = 0; i < points.length; i++) {
    positions[i * 3] = points[i].x;
    positions[i * 3 + 1] = points[i].y;
    positions[i * 3 + 2] = points[i].z;

    const t = i / (points.length - 1);
    colors[i * 3] = 1 - t * 0.4;
    colors[i * 3 + 1] = 1 - t * 0.6;
    colors[i * 3 + 2] = t;
  }

  const geometry = new THREE.BufferGeometry();
  geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
  geometry.setAttribute("color", new THREE.BufferAttribute(colors, 3));

  const material = new THREE.LineBasicMaterial({
    vertexColors: true,
    transparent: true,
    opacity: 0.8,
    blending: THREE.AdditiveBlending,
    depthTest: true,
    depthWrite: false,
  });

  predictedOrbitLine = new THREE.Line(geometry, material);
  predictedOrbitLine.renderOrder = SATELLITE_CONFIG.overlayRenderOrder;
  earthObjRef.add(predictedOrbitLine);
}

export function hidePredictedOrbit() {
  if (predictedOrbitLine) {
    disposeObject3D(predictedOrbitLine);
    predictedOrbitLine = null;
  }
}

export function clearSatelliteData() {
  satelliteData = [];
  satelliteSatrecCache = new Map();
  selectedSatellite = null;
  lockedSatelliteIndex = null;
  hoveredSatelliteIndex = null;
  positionUpdateAccumulator = 0;
  breathingPhase = 0;

  satellitePositions.forEach((position) => {
    position.current.set(0, 0, 0);
    position.trail = [];
    position.trailIndex = 0;
    position.trailCount = 0;
  });

  if (satellitePoints) {
    const positionAttr = satellitePoints.geometry.attributes.position;
    const colorAttr = satellitePoints.geometry.attributes.color;
    if (positionAttr?.array) {
      positionAttr.array.fill(0);
      positionAttr.needsUpdate = true;
    }
    if (colorAttr?.array) {
      colorAttr.array.fill(0);
      colorAttr.needsUpdate = true;
    }
    satellitePoints.geometry.setDrawRange(0, 0);
  }

  if (satelliteBackdropPoints) {
    const backdropPositionAttr =
      satelliteBackdropPoints.geometry.attributes.position;
    if (backdropPositionAttr?.array) {
      backdropPositionAttr.array.fill(0);
      backdropPositionAttr.needsUpdate = true;
    }
    satelliteBackdropPoints.geometry.setDrawRange(0, 0);
  }

  if (satelliteTrails) {
    const trailPositionAttr = satelliteTrails.geometry.attributes.position;
    const trailColorAttr = satelliteTrails.geometry.attributes.color;
    if (trailPositionAttr?.array) {
      trailPositionAttr.array.fill(0);
      trailPositionAttr.needsUpdate = true;
    }
    if (trailColorAttr?.array) {
      trailColorAttr.array.fill(0);
      trailColorAttr.needsUpdate = true;
    }
  }

  hideHoverRings();
  hideLockedRing();
  hidePredictedOrbit();
  clearRelatedSatelliteHighlights();
}

export function resetSatelliteState() {
  clearSatelliteData();

  if (satelliteBackdropPoints) {
    disposeObject3D(satelliteBackdropPoints);
    satelliteBackdropPoints = null;
  }

  if (satellitePoints) {
    disposeObject3D(satellitePoints);
    satellitePoints = null;
  }

  if (satelliteTrails) {
    disposeObject3D(satelliteTrails);
    satelliteTrails = null;
  }

  satellitePositions = [];
  satelliteCapacity = 0;
  satelliteSatrecCache = new Map();
  showSatellites = false;
  showTrails = true;
}