import * as THREE from "three";

import { COMPUTE_CENTER_CONFIG, CONFIG, PATHS } from "./constants.js";
import {
  createInteractableLayer,
  SURFACE_AVOIDANCE_PROFILES,
} from "./interactable.js";
import { latLonToVector3 } from "./utils.js";

const COMPUTE_CENTER_RENDER_ORDER = 4.5;
const COMPUTE_CENTER_POINT_SIZE = 36;
const COMPUTE_CENTER_ICON_FIT_SIZE = 60;
const COMPUTE_CENTER_ATLAS_CELL_SIZE = 128;
const COMPUTE_CENTER_ICON_SOURCES = {
  supercomputer: new URL("../assets/icons/compute-supercomputer.svg", import.meta.url).href,
  gpu_cluster: new URL("../assets/icons/compute-gpu-cluster.svg", import.meta.url).href,
  infrastructure: new URL("../assets/icons/compute-hdd-network.svg", import.meta.url).href,
};
let showComputeCenters = true;
let supercomputerCount = 0;
let gpuClusterCount = 0;
let unresolvedComputeCenters = [];
let previewRingTexture = null;
let previewRingGroup = null;
let previewRingA = null;
let previewRingB = null;
let previewRingPulseOffset = 0;

const COLLECT_LOCATION_API_BASE = "/api/v1/visualization/compute-centers";
const LOCATION_CAPABILITY_API = "/api/v1/visualization/compute-centers/location-capability";
let computeCenterLocationCapabilityPromise = null;

function getPreviewRingTexture() {
  if (previewRingTexture) return previewRingTexture;

  const canvas = document.createElement("canvas");
  canvas.width = 128;
  canvas.height = 128;
  const context = canvas.getContext("2d");
  if (!context) {
    previewRingTexture = new THREE.Texture(canvas);
    return previewRingTexture;
  }

  context.clearRect(0, 0, 128, 128);
  context.strokeStyle = "rgba(255,255,255,0.96)";
  context.lineWidth = 5;
  context.beginPath();
  context.arc(64, 64, 43, 0, Math.PI * 2);
  context.stroke();

  previewRingTexture = new THREE.CanvasTexture(canvas);
  return previewRingTexture;
}

function ensurePreviewRingGroup(earth) {
  if (!earth) return null;
  if (!previewRingGroup) {
    previewRingGroup = new THREE.Group();
    previewRingGroup.name = "compute-center-location-preview";
  }
  if (previewRingGroup.parent !== earth) {
    previewRingGroup.parent?.remove?.(previewRingGroup);
    earth.add(previewRingGroup);
  }
  return previewRingGroup;
}

function createPreviewRingSprite({ color = 0x2dd4bf } = {}) {
  const sprite = new THREE.Sprite(
    new THREE.SpriteMaterial({
      map: getPreviewRingTexture(),
      color,
      transparent: true,
      opacity: 0,
      depthWrite: false,
      depthTest: true,
      blending: THREE.AdditiveBlending,
    }),
  );
  sprite.renderOrder = COMPUTE_CENTER_RENDER_ORDER + 0.18;
  return sprite;
}

function disposePreviewRingSprite(sprite) {
  if (!sprite) return;
  sprite.parent?.remove?.(sprite);
  sprite.material?.dispose?.();
}

function attachPreviewRings(group, position, color) {
  disposePreviewRingSprite(previewRingA);
  disposePreviewRingSprite(previewRingB);
  previewRingA = createPreviewRingSprite({ color });
  previewRingB = createPreviewRingSprite({ color });
  previewRingA.position.copy(position);
  previewRingB.position.copy(position);
  group.add(previewRingA);
  group.add(previewRingB);
  previewRingPulseOffset = Math.random() * Math.PI * 2;
}

function buildComputeCenterMarkerData(feature) {
  const props = feature?.properties || {};
  const coordinates = feature?.geometry?.coordinates || [];
  const longitude = Number(coordinates[0]);
  const latitude = Number(coordinates[1]);
  if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
    return null;
  }

  return {
    ...props,
    latitude,
    longitude,
    displayLatitude: latitude,
    displayLongitude: longitude,
    site_type: normalizeSiteType(props.site_type),
  };
}

function spreadComputeCenterPositions(markers) {
  const groups = new Map();
  const precision = COMPUTE_CENTER_CONFIG.overlapSpread.groupPrecision;

  markers.forEach((marker) => {
    const key = `${marker.latitude.toFixed(precision)}|${marker.longitude.toFixed(precision)}`;
    if (!groups.has(key)) {
      groups.set(key, []);
    }
    groups.get(key).push(marker);
  });

  groups.forEach((group) => {
    if (group.length <= 1) return;

    const radius = COMPUTE_CENTER_CONFIG.overlapSpread.radius;
    const offsetStep = COMPUTE_CENTER_CONFIG.overlapSpread.offsetStep;
    group.forEach((marker, index) => {
      const angle = (Math.PI * 2 * index) / group.length;
      marker.displayLatitude =
        marker.latitude + Math.sin(angle) * radius * offsetStep;
      marker.displayLongitude =
        marker.longitude + Math.cos(angle) * radius * offsetStep;
      marker.isSpread = true;
      marker.groupSize = group.length;
    });
  });

  markers.forEach((marker) => {
    if (marker.isSpread) return;
    marker.displayLatitude = marker.latitude;
    marker.displayLongitude = marker.longitude;
    marker.isSpread = false;
    marker.groupSize = 1;
  });

  return markers;
}

function drawComputeCenterEstimatedBadge(context, isEstimated = false) {
  if (isEstimated) {
    context.save();
    context.fillStyle = "rgba(15,23,42,0.92)";
    context.beginPath();
    context.arc(94, 36, 12, 0, Math.PI * 2);
    context.fill();
    context.fillStyle = "rgba(255,255,255,0.98)";
    context.font = "bold 18px sans-serif";
    context.textAlign = "center";
    context.textBaseline = "middle";
    context.fillText("?", 94, 36);
    context.restore();
  }
}

function shouldShowComputeCenterEstimatedBadge(data) {
  if (!data) return false;
  if (data.needs_confirmation === true) return true;
  if (data.location_source === "nominatim_online_geocode") return true;
  return false;
}

function normalizeSiteType(siteType) {
  return siteType === "supercomputer" ? "supercomputer" : "gpu_cluster";
}

const computeCenterIconLayer = createInteractableLayer({
  id: "computeCenters",
  objectType: "compute_center",
  renderOrder: COMPUTE_CENTER_RENDER_ORDER,
  altitudeOffset: COMPUTE_CENTER_CONFIG.altitudeOffset,
  pointSize: COMPUTE_CENTER_POINT_SIZE,
  atlasCellSize: COMPUTE_CENTER_ATLAS_CELL_SIZE,
  colors: {
    byKind: COMPUTE_CENTER_CONFIG.colors,
    normal: COMPUTE_CENTER_CONFIG.colors.gpu_cluster,
  },
  opacity: {
    normal: COMPUTE_CENTER_CONFIG.marker.baseOpacity,
    dimmed: COMPUTE_CENTER_CONFIG.marker.dimmedOpacity,
    hover: 0.98,
    locked: 1,
  },
  stateScale: {
    hover: COMPUTE_CENTER_CONFIG.marker.hoverScale,
    locked: COMPUTE_CENTER_CONFIG.marker.lockedScale,
    dimmed: COMPUTE_CENTER_CONFIG.marker.dimmedScale,
  },
  pulse: {
    enabled: true,
    speed: COMPUTE_CENTER_CONFIG.marker.pulseSpeed,
    amplitude: COMPUTE_CENTER_CONFIG.marker.pulseAmplitude,
  },
  icon: {
    coordinates: "canvas",
    fitSize: COMPUTE_CENTER_ICON_FIT_SIZE,
    glowBlur: 16,
    getSource({ marker, item }) {
      const siteType =
        marker?.userData?.site_type || item?.site_type || "gpu_cluster";
      return (
        COMPUTE_CENTER_ICON_SOURCES[siteType] ||
        COMPUTE_CENTER_ICON_SOURCES.infrastructure
      );
    },
    afterDraw(context, { marker, item }) {
      const data = marker?.userData || item;
      drawComputeCenterEstimatedBadge(
        context,
        shouldShowComputeCenterEstimatedBadge(data),
      );
    },
  },
  getPosition: (item) => ({
    latitude: item.displayLatitude,
    longitude: item.displayLongitude,
  }),
  getKind: (item) => item.site_type || "gpu_cluster",
  getBucketKey: (marker) =>
    [
      marker.userData?.site_type || "gpu_cluster",
      shouldShowComputeCenterEstimatedBadge(marker.userData) ? "estimated" : "verified",
    ].join(":"),
  getUserData: (item) => ({
    ...item,
    pulseOffset: Math.random() * Math.PI * 2,
  }),
  avoidance: SURFACE_AVOIDANCE_PROFILES.city,
  cluster: {
    strategy: "stable-spherical",
  },
});

export function formatComputeCenterTypeLabel(siteType) {
  return siteType === "supercomputer" ? "超算中心" : "GPU 集群";
}

export function formatComputeCenterCapacity(markerData) {
  const value = markerData?.capacity_value;
  const unit = markerData?.capacity_unit;
  if (value === null || value === undefined || value === "") return "-";
  return `${value}${unit ? ` ${unit}` : ""}`;
}

export function formatComputeCenterUpdatedAt(value) {
  if (!value) return "-";
  const date = new Date(value);
  if (Number.isNaN(date.getTime())) return String(value);
  return date.toLocaleString("zh-CN", { hour12: false });
}

export function formatComputeCenterLocationPrecision(markerData) {
  const precision = markerData?.location_precision;
  if (precision === "precise") return "精确坐标";
  if (precision === "site") return "站点级位置";
  if (precision === "city") return "城市级位置";
  return "位置未确认";
}

const COMPUTE_CENTER_LOCATION_SOURCE_LABELS = {
  source_coordinates: "源数据自带坐标",
  ror_organization_registry: "ROR 组织注册 API",
  nominatim_online_geocode: "Nominatim 在线搜索",
  llm_location_factcheck: "LLM factcheck 兜底",
};

export function formatComputeCenterLocationSource(markerData) {
  const source = markerData?.location_source;
  if (!source) return "未知来源";
  return COMPUTE_CENTER_LOCATION_SOURCE_LABELS[source] || source;
}

export function formatComputeCenterNeedsConfirmation(markerData) {
  if (markerData?.needs_confirmation === true) return "待人工核验";
  if (markerData?.is_estimated === true) return "估算位置";
  return "已确认";
}

export function formatComputeCenterLocationConfidence(markerData) {
  const confidence = Number(markerData?.location_confidence);
  if (!Number.isFinite(confidence)) return "-";
  return `${Math.round(confidence * 100)}%`;
}

export function getComputeCenterLegendItems() {
  return [
    {
      label: "超算中心",
      color: COMPUTE_CENTER_CONFIG.colors.supercomputer,
    },
    {
      label: "GPU 集群",
      color: COMPUTE_CENTER_CONFIG.colors.gpu_cluster,
    },
  ];
}

export function getComputeCenterMarkers() {
  return computeCenterIconLayer.getMarkers();
}

export function getComputeCenterCount() {
  return computeCenterIconLayer.getCount();
}

export function getComputeCenterSupercomputerCount() {
  return supercomputerCount;
}

export function getComputeCenterGPUClusterCount() {
  return gpuClusterCount;
}

export function getComputeCenterStatusSummary() {
  if (getComputeCenterCount() === 0) return "暂无算力中心数据";
  return `${supercomputerCount} 台超算 / ${gpuClusterCount} 个 GPU 集群`;
}

export function setComputeCenterMarkerState(marker, state = "normal") {
  computeCenterIconLayer.setMarkerState(marker, state);
}

export function clearComputeCenterSelection() {
  getComputeCenterMarkers().forEach((marker) => setComputeCenterMarkerState(marker, "normal"));
}

export function clearComputeCenterData(earth) {
  supercomputerCount = 0;
  gpuClusterCount = 0;
  unresolvedComputeCenters = [];
  clearComputeCenterLocationPreview();
  computeCenterIconLayer.clearData(earth);
}

export function clearComputeCenterLocationPreview() {
  disposePreviewRingSprite(previewRingA);
  disposePreviewRingSprite(previewRingB);
  previewRingA = null;
  previewRingB = null;
}

export function showComputeCenterLocationPreview(earth, { latitude, longitude, color = 0x2dd4bf } = {}) {
  const lat = Number(latitude);
  const lon = Number(longitude);
  if (!earth || !Number.isFinite(lat) || !Number.isFinite(lon)) return false;
  const group = ensurePreviewRingGroup(earth);
  if (!group) return false;
  const position = latLonToVector3(
    lat,
    lon,
    CONFIG.earthRadius + COMPUTE_CENTER_CONFIG.altitudeOffset + 0.2,
  );
  attachPreviewRings(group, position, color);
  updateComputeCenterLocationPreview();
  return true;
}

function updateComputeCenterLocationPreview() {
  if (!previewRingA && !previewRingB) return;
  const now = performance.now();
  const baseScale = 8.5;
  const pulseSpeed = 0.00105;
  const applyRing = (ring, phaseOffset, maxScale) => {
    if (!ring) return;
    const phase = (now * pulseSpeed + previewRingPulseOffset + phaseOffset) % 1;
    const progress = Math.max(0, Math.min(1, phase));
    const fadeIn = Math.max(0, Math.min(1, (progress - 0.04) / 0.16));
    const fadeOut = 1 - progress;
    const visibility = fadeIn * fadeOut;
    ring.scale.setScalar(baseScale * (1.0 + progress * (maxScale - 1.0)));
    ring.material.opacity = 0.5 * visibility;
    ring.visible = true;
  };
  applyRing(previewRingA, 0, 1.85);
  applyRing(previewRingB, 0.45, 2.35);
}

function recomputeComputeCenterCounts(markerData) {
  let nextSupercomputerCount = 0;
  let nextGpuClusterCount = 0;
  markerData.forEach((item) => {
    if (item.site_type === "supercomputer") {
      nextSupercomputerCount += 1;
    } else {
      nextGpuClusterCount += 1;
    }
  });
  supercomputerCount = nextSupercomputerCount;
  gpuClusterCount = nextGpuClusterCount;
}

function buildOptimisticComputeCenterMarkerData({ sourceId, candidate, context, saveResult }) {
  const location = saveResult?.location || {};
  const existingData = context?.data || {};
  const latitude = Number(location.latitude ?? candidate?.latitude);
  const longitude = Number(location.longitude ?? candidate?.longitude);
  if (!sourceId || !Number.isFinite(latitude) || !Number.isFinite(longitude)) {
    return null;
  }
  const siteType = normalizeSiteType(
    context?.site_type || context?.siteType || existingData.site_type || location.site_type,
  );
  return {
    id: context?.recordId || context?.id || existingData.id || saveResult?.record_id || sourceId,
    source_id: sourceId,
    name:
      context?.name ||
      existingData.name ||
      location.name ||
      candidate?.matched_location_name ||
      candidate?.display_name ||
      "算力中心",
    source: saveResult?.source || context?.source || existingData.source || location.source || "",
    site_type: siteType,
    country: location.country || candidate?.country || context?.country || existingData.country || "",
    city: location.city || candidate?.city || context?.city || existingData.city || "",
    region: location.region || candidate?.region || "",
    latitude,
    longitude,
    displayLatitude: latitude,
    displayLongitude: longitude,
    operator: context?.operator || existingData.operator || location.operator || "",
    vendor: context?.vendor || existingData.vendor || "",
    capacity_value: context?.capacity_value ?? existingData.capacity_value,
    capacity_unit: context?.capacity_unit ?? existingData.capacity_unit,
    rank: context?.rank ?? existingData.rank,
    gpu_count: context?.gpu_count ?? existingData.gpu_count,
    gpu_type: context?.gpu_type ?? existingData.gpu_type,
    cores: context?.cores ?? existingData.cores,
    power: context?.power ?? existingData.power,
    updated_at: new Date().toISOString(),
    status: "observed",
    location_precision: location.precision || candidate?.precision || "city",
    location_confidence: location.confidence ?? candidate?.confidence ?? null,
    location_source: location.location_source || candidate?.source || "manual_selection",
    location_source_note: location.location_source_note || candidate?.source_note || "",
    location_verified_at: location.verified_at || new Date().toISOString(),
    matched_location_name:
      location.matched_location_name ||
      candidate?.matched_location_name ||
      candidate?.display_name ||
      "",
    needs_confirmation: location.needs_confirmation === true,
    is_estimated: false,
    estimated_reason: location.estimated_reason || "",
    data_type: "compute_center",
    metadata: context?.metadata || existingData.metadata || {},
    optimistic_spawn: true,
  };
}

export async function spawnSavedComputeCenterLocation(earth, { sourceId, candidate, context, saveResult } = {}) {
  clearComputeCenterLocationPreview();
  const spawned = buildOptimisticComputeCenterMarkerData({
    sourceId,
    candidate,
    context,
    saveResult,
  });
  if (!spawned) return null;

  const currentItems = getComputeCenterMarkers()
    .map((marker) => ({ ...(marker.userData || {}) }))
    .filter((item) => item.source_id !== sourceId);
  currentItems.push(spawned);
  const nextItems = spreadComputeCenterPositions(currentItems);
  await computeCenterIconLayer.preloadAssets(nextItems);
  computeCenterIconLayer.setData(nextItems);
  computeCenterIconLayer.attach(earth);
  computeCenterIconLayer.setVisible(showComputeCenters);
  recomputeComputeCenterCounts(nextItems);
  unresolvedComputeCenters = unresolvedComputeCenters.filter((item) => {
    const itemSourceId = item?.source_id || item?.id;
    return itemSourceId !== sourceId;
  });

  return {
    marker: getComputeCenterMarkers().find((marker) => marker.userData?.source_id === sourceId) || null,
    totalCount: getComputeCenterCount(),
    supercomputerCount,
    gpuClusterCount,
    unresolvedCount: unresolvedComputeCenters.length,
    unresolved: unresolvedComputeCenters.slice(),
    summary: getComputeCenterStatusSummary(),
    optimistic: true,
  };
}

export function getUnresolvedComputeCenters() {
  return unresolvedComputeCenters.slice();
}

// Generic helper used by every entity type that wires the shared
// /collect-location backend pipeline. The endpoint shape (sources, payload
// keys) is domain-specific; the request/response envelope is unified
// (success / candidates / attempted_queries / failure_reason / context).
export async function collectLocationCandidates(endpoint, payload = {}) {
  if (!endpoint) throw new Error("endpoint is required");
  const response = await fetch(endpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(payload || {}),
  });
  if (!response.ok) {
    const text = await response.text().catch(() => "");
    let detail = "";
    try {
      const payload = JSON.parse(text);
      detail = payload?.detail?.reason || payload?.detail?.message || payload?.detail || "";
    } catch {
      detail = text;
    }
    throw new Error(
      `Collect location failed: HTTP ${response.status} ${detail}`.trim(),
    );
  }
  return response.json();
}

export async function getComputeCenterLocationCapability({ force = false } = {}) {
  if (!computeCenterLocationCapabilityPromise || force) {
    computeCenterLocationCapabilityPromise = fetch(LOCATION_CAPABILITY_API, { cache: "no-store" })
      .then(async (response) => {
        if (!response.ok) {
          const text = await response.text().catch(() => "");
          return {
            enabled: false,
            provider: null,
            reason: `WebSearch 状态检查失败：HTTP ${response.status} ${text}`.trim(),
          };
        }
        const payload = await response.json();
        return {
          enabled: payload?.enabled === true,
          provider: payload?.provider || "",
          reason: payload?.reason || "",
        };
      })
      .catch((error) => ({
        enabled: false,
        provider: null,
        reason: `WebSearch 状态检查失败：${error?.message || error}`,
      }));
  }
  return computeCenterLocationCapabilityPromise;
}

export async function collectComputeCenterLocation(sourceId, context = {}) {
  if (!sourceId) {
    throw new Error("sourceId is required");
  }
  const url = `${COLLECT_LOCATION_API_BASE}/${encodeURIComponent(sourceId)}/collect-location`;
  return collectLocationCandidates(url, {
    name: context?.name ?? null,
    operator: context?.operator ?? null,
    site: context?.site ?? null,
    organization: context?.organization ?? null,
    city: context?.city ?? null,
    country: context?.country ?? null,
    source: context?.source ?? null,
    id: context?.record_id ?? null,
  });
}

export async function saveComputeCenterLocation(sourceId, candidate = {}, context = {}) {
  if (!sourceId) {
    throw new Error("sourceId is required");
  }
  const latitude = Number(candidate?.latitude);
  const longitude = Number(candidate?.longitude);
  if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
    throw new Error("candidate latitude/longitude are required");
  }
  const url = `${COLLECT_LOCATION_API_BASE}/${encodeURIComponent(sourceId)}/location`;
  const response = await fetch(url, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      source: context?.source ?? null,
      name: context?.name ?? candidate?.matched_location_name ?? candidate?.display_name ?? null,
      operator: context?.operator ?? null,
      site: context?.site ?? null,
      city: candidate?.city ?? context?.city ?? null,
      country: candidate?.country ?? context?.country ?? null,
      latitude,
      longitude,
      precision: candidate?.precision ?? "city",
      confidence: candidate?.confidence ?? null,
      location_source: candidate?.source ?? "manual_selection",
      source_url: candidate?.source_url ?? null,
      source_note: candidate?.source_note ?? null,
      raw_payload: candidate || {},
      needs_confirmation: false,
      verification_status: "verified",
    }),
  });
  if (!response.ok) {
    const text = await response.text().catch(() => "");
    throw new Error(
      `Save compute center location failed: HTTP ${response.status} ${text}`.trim(),
    );
  }
  return response.json();
}

export function toggleComputeCenters(show) {
  showComputeCenters = Boolean(show);
  computeCenterIconLayer.setVisible(showComputeCenters);
}

export function getShowComputeCenters() {
  return showComputeCenters;
}

export async function loadComputeCenters(_scene, earth) {
  const separator = PATHS.computeCentersApi.includes("?") ? "&" : "?";
  const response = await fetch(
    `${PATHS.computeCentersApi}${separator}_=${Date.now()}`,
    { cache: "no-store" },
  );
  if (!response.ok) {
    throw new Error(`Compute centers HTTP ${response.status}`);
  }
  const payload = await response.json();
  const features = Array.isArray(payload?.features) ? payload.features : [];
  const unresolved = Array.isArray(payload?.unresolved) ? payload.unresolved : [];

  const markerData = spreadComputeCenterPositions(
    features
      .map((feature) => buildComputeCenterMarkerData(feature))
      .filter(Boolean),
  )
    .slice(0, COMPUTE_CENTER_CONFIG.maxRenderedMarkers);

  let nextSupercomputerCount = 0;
  let nextGpuClusterCount = 0;
  markerData.forEach((item) => {
    if (item.site_type === "supercomputer") {
      nextSupercomputerCount += 1;
    } else {
      nextGpuClusterCount += 1;
    }
  });
  await computeCenterIconLayer.preloadAssets(markerData);

  clearComputeCenterData(earth);
  unresolvedComputeCenters = unresolved;
  supercomputerCount = nextSupercomputerCount;
  gpuClusterCount = nextGpuClusterCount;
  computeCenterIconLayer.setData(markerData);
  computeCenterIconLayer.attach(earth);
  computeCenterIconLayer.setVisible(showComputeCenters);

  return {
    totalCount: getComputeCenterCount(),
    supercomputerCount,
    gpuClusterCount,
    unresolvedCount: unresolvedComputeCenters.length,
    unresolved: unresolvedComputeCenters.slice(),
    summary: getComputeCenterStatusSummary(),
  };
}

export function getComputeCenterPointerIntersections(options) {
  return computeCenterIconLayer.getPointerIntersections(options);
}

export function updateComputeCenterVisualState(lockedObjectType, lockedObject, camera) {
  updateComputeCenterLocationPreview();
  computeCenterIconLayer.updateVisualState(lockedObjectType, lockedObject, camera);
}