import * as THREE from "three";
import { OrbitControls } from "three/addons/controls/OrbitControls.js";
import { ColladaLoader } from "three/addons/loaders/ColladaLoader.js";

const COLORS = {
  left: 0x4d9fe8,
  right: 0xed883f,
  body: 0xa7b4bd,
};

const GATE_PHASE_COLORS = {
  async: { left: 0x38e891, right: 0x38e891 },
  sync: { left: 0x9b87f5, right: 0x9b87f5 },
};

const ACTIVE_SEMANTICS = new Set([
  "reach_grasp_object",
  "reach_open_drawer",
  "insert_place_object",
]);

const elements = {
  scene: document.getElementById("scene"),
  dataset: document.getElementById("dataset-select"),
  episode: document.getElementById("episode-select"),
  resetView: document.getElementById("reset-view"),
  play: document.getElementById("play-button"),
  timeline: document.getElementById("timeline"),
  routerMarkers: document.getElementById("router-markers"),
  rate: document.getElementById("rate-select"),
  fps: document.getElementById("fps-label"),
  defaultArmLegend: document.getElementById("default-arm-legend"),
  asyncGateLegend: document.getElementById("async-gate-legend"),
  syncGateLegend: document.getElementById("sync-gate-legend"),
  videos: {
    head: document.getElementById("head-video"),
    left_wrist: document.getElementById("left-wrist-video"),
    right_wrist: document.getElementById("right-wrist-video"),
  },
  time: document.getElementById("time-label"),
  frame: document.getElementById("frame-label"),
  phase: document.getElementById("phase-label"),
  meta: document.getElementById("episode-meta"),
  attributes: document.getElementById("episode-attributes"),
  annotationPanel: document.getElementById("annotation-panel"),
  annotationTitle: document.getElementById("annotation-title"),
  annotationFrame: document.getElementById("annotation-current-frame"),
  annotationSplit: document.getElementById("annotation-split"),
  annotationVariant: document.getElementById("annotation-variant"),
  objectArm: document.getElementById("object-arm-role"),
  drawerArm: document.getElementById("drawer-arm-role"),
  pairedText: document.getElementById("paired-subtask-text"),
  activityRelation: document.getElementById("arm-activity-relation"),
  leftSemanticKey: document.getElementById("left-arm-semantic-key"),
  rightSemanticKey: document.getElementById("right-arm-semantic-key"),
  leftSemantic: document.getElementById("left-arm-semantic"),
  rightSemantic: document.getElementById("right-arm-semantic"),
  leftSourceIndex: document.getElementById("left-source-index"),
  rightSourceIndex: document.getElementById("right-source-index"),
  annotationProvenance: document.getElementById("annotation-provenance"),
  annotationTimeline: document.getElementById("annotation-timeline"),
  annotationLegend: document.getElementById("annotation-legend"),
  status: document.getElementById("status"),
};

const state = {
  config: null,
  episode: null,
  transforms: null,
  meshes: [],
  materials: null,
  currentFrame: -1,
  loadGeneration: 0,
  scrubbing: false,
};

const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
renderer.outputColorSpace = THREE.SRGBColorSpace;
renderer.shadowMap.enabled = true;
elements.scene.appendChild(renderer.domElement);

const scene = new THREE.Scene();
scene.fog = new THREE.Fog(0x09131c, 2.2, 5.2);

const camera = new THREE.PerspectiveCamera(43, 1, 0.01, 20);
camera.up.set(0, 0, 1);

const controls = new OrbitControls(camera, renderer.domElement);
controls.enableDamping = true;
controls.dampingFactor = 0.08;
controls.minDistance = 0.45;
controls.maxDistance = 6.0;

scene.add(new THREE.HemisphereLight(0xd8efff, 0x17212a, 2.4));
const keyLight = new THREE.DirectionalLight(0xffffff, 3.2);
keyLight.position.set(-1.5, -2.0, 3.2);
keyLight.castShadow = true;
scene.add(keyLight);

const floor = new THREE.Mesh(
  new THREE.PlaneGeometry(4.0, 4.0),
  new THREE.MeshStandardMaterial({ color: 0x1a2934, roughness: 0.94, metalness: 0.02 }),
);
floor.position.set(0, -0.65, -0.012);
floor.receiveShadow = true;
scene.add(floor);

const grid = new THREE.GridHelper(3.4, 34, 0x375166, 0x1a3040);
grid.rotation.x = Math.PI / 2;
grid.position.set(0, -0.65, -0.008);
grid.material.opacity = 0.38;
grid.material.transparent = true;
scene.add(grid);

const robotGroup = new THREE.Group();
scene.add(robotGroup);

function resetCamera() {
  camera.position.set(2.0, -2.7, 1.75);
  controls.target.set(0, -0.65, 0.72);
  controls.update();
}

resetCamera();

const resizeObserver = new ResizeObserver(() => {
  const width = elements.scene.clientWidth;
  const height = elements.scene.clientHeight;
  if (!width || !height) return;
  renderer.setSize(width, height, false);
  camera.aspect = width / height;
  camera.updateProjectionMatrix();
});
resizeObserver.observe(elements.scene);

function fetchChecked(url, responseType = "json") {
  return fetch(url).then((response) => {
    if (!response.ok) {
      throw new Error(response.status + " " + response.statusText + ": " + url);
    }
    return responseType === "arrayBuffer" ? response.arrayBuffer() : response.json();
  });
}

function materialForLink(linkName, materials) {
  if (linkName.startsWith("fl_")) return materials.left;
  if (linkName.startsWith("fr_")) return materials.right;
  return materials.body;
}

async function loadRobotMeshes() {
  const loader = new ColladaLoader();
  const scenePromises = new Map();
  for (const meshInfo of state.config.meshes) {
    if (!scenePromises.has(meshInfo.url)) {
      scenePromises.set(
        meshInfo.url,
        loader.loadAsync(meshInfo.url).then((collada) => collada.scene),
      );
    }
  }

  const materials = Object.fromEntries(
    Object.entries(COLORS).map(([name, color]) => [
      name,
      new THREE.MeshStandardMaterial({ color, roughness: 0.7, metalness: 0.06 }),
    ]),
  );
  state.materials = materials;
  for (const meshInfo of state.config.meshes) {
    const content = (await scenePromises.get(meshInfo.url)).clone(true);
    const material = materialForLink(meshInfo.link_name, materials);
    content.traverse((child) => {
      if (!child.isMesh) return;
      child.material = material;
      child.castShadow = true;
      child.receiveShadow = true;
    });
    content.rotation.set(0, 0, 0);
    content.scale.set(...meshInfo.scale);
    content.updateMatrix();

    const wrapper = new THREE.Group();
    wrapper.add(content);
    wrapper.matrixAutoUpdate = false;
    state.meshes.push(wrapper);
    robotGroup.add(wrapper);
  }
}

function humanizeDataset(name) {
  return name.replaceAll("_", " ");
}

function populateDatasets() {
  elements.dataset.replaceChildren(
    ...Object.keys(state.config.datasets).map((name) => {
      const option = document.createElement("option");
      option.value = name;
      option.textContent = humanizeDataset(name);
      return option;
    }),
  );
  const preferred = "put_object_cabinet_retimed";
  if (preferred in state.config.datasets) {
    elements.dataset.value = preferred;
  }
}

function populateEpisodes() {
  const dataset = state.config.datasets[elements.dataset.value];
  elements.episode.replaceChildren(
    ...dataset.episode_indices.map((episodeIndex) => {
      const option = document.createElement("option");
      option.value = String(episodeIndex);
      option.textContent = "Episode " + String(episodeIndex).padStart(2, "0");
      return option;
    }),
  );
}

function videos() {
  return Object.values(elements.videos);
}

function masterVideo() {
  return elements.videos.head;
}

function waitForMetadata(video) {
  if (video.readyState >= HTMLMediaElement.HAVE_METADATA) return Promise.resolve();
  return new Promise((resolve, reject) => {
    video.addEventListener("loadedmetadata", resolve, { once: true });
    video.addEventListener(
      "error",
      () => reject(new Error("RoboTwin 视频 metadata 加载失败")),
      { once: true },
    );
  });
}

function renderRouterMarkers() {
  const timeline = state.episode.phase_timeline;
  const markers = [];
  if (timeline.has_gate_records) {
    for (let frame = 1; frame < timeline.phase_ids.length; frame += 1) {
      if (timeline.phase_ids[frame] === timeline.phase_ids[frame - 1]) continue;
      markers.push([frame, timeline.phase_ids[frame] === 1 ? "ASYNC" : "SYNC"]);
    }
  }
  elements.routerMarkers.replaceChildren(...markers.map(([frame, label]) => {
    const marker = document.createElement("span");
    marker.textContent = label + " @ " + frame;
    marker.style.left = (100 * frame / state.episode.frame_count) + "%";
    return marker;
  }));
}

function updateArmLegend(hasGateRecords) {
  elements.defaultArmLegend.hidden = hasGateRecords;
  elements.asyncGateLegend.hidden = !hasGateRecords;
  elements.syncGateLegend.hidden = !hasGateRecords;
}

function segmentAtFrame(segments, frame) {
  return segments.find((segment) => segment.start <= frame && frame < segment.end);
}

function semanticDefinitions(annotation) {
  return Object.fromEntries(
    annotation.semantic_definitions.map((semantic) => [semantic.key, semantic]),
  );
}

function renderAnnotationLane(label, arm, segments, definitions, frameCount) {
  const row = document.createElement("div");
  row.className = "annotation-lane";
  const laneLabel = document.createElement("span");
  laneLabel.className = "annotation-lane-label mono";
  laneLabel.textContent = label;
  const track = document.createElement("div");
  track.className = "annotation-track";
  track.dataset.arm = arm;
  for (const segment of segments) {
    const semantic = definitions[segment.semantic_key];
    const block = document.createElement("button");
    block.type = "button";
    block.className = "annotation-block";
    block.dataset.start = String(segment.start);
    block.dataset.end = String(segment.end);
    block.style.left = (100 * segment.start / frameCount) + "%";
    block.style.width =
      (100 * (segment.end - segment.start) / frameCount) + "%";
    block.style.backgroundColor = semantic.color;
    block.textContent = semantic.label_zh;
    block.title =
      label + " · " + semantic.label_zh + " · " + segment.semantic_key +
      " · [" + segment.start + ", " + segment.end + ") · " +
      segment.semantic_text;
    block.setAttribute("aria-label", block.title);
    block.addEventListener("click", () => {
      setLocalTime(segment.start / state.episode.fps);
    });
    track.appendChild(block);
  }
  row.append(laneLabel, track);
  return row;
}

function renderAnnotationLegend(semantics) {
  elements.annotationLegend.replaceChildren(...semantics.map((semantic) => {
    const item = document.createElement("span");
    const swatch = document.createElement("i");
    swatch.style.backgroundColor = semantic.color;
    item.append(swatch, document.createTextNode(semantic.label_zh));
    return item;
  }));
}

function renderAnnotations(annotation, frameCount) {
  elements.annotationPanel.hidden = annotation === null;
  elements.annotationTimeline.replaceChildren();
  elements.annotationLegend.replaceChildren();
  if (annotation === null) return;
  const definitions = semanticDefinitions(annotation);
  const isParallel = annotation.schedule?.kind?.startsWith("native_parallel");
  const delay = annotation.schedule?.relative_delay;
  elements.annotationTitle.textContent = isParallel
    ? "QWEN + NATIVE RETIME · PARALLEL DUAL-ARM SUBTASK"
    : "QWEN · CURRENT DUAL-ARM SUBTASK";
  elements.annotationSplit.textContent = annotation.split.toUpperCase();
  elements.annotationSplit.dataset.split = annotation.split;
  if (delay) {
    elements.annotationVariant.textContent =
      "RANDOM DELAY · " + delay.delayed_arm.toUpperCase() + " +" +
      delay.delay_steps + "f · " + delay.delay_seconds.toFixed(2) + "s";
  } else {
    elements.annotationVariant.textContent = isParallel
      ? "PARALLEL NATIVE RETIME"
      : "SERIAL SOURCE";
  }
  elements.objectArm.textContent =
    "OBJECT ARM · " + annotation.object_arm.toUpperCase();
  elements.drawerArm.textContent =
    "DRAWER ARM · " + annotation.drawer_arm.toUpperCase();
  const provenance =
    "model=" + annotation.source.model + " · prompt=" +
    annotation.source.prompt_version + " · revision=" +
    annotation.annotation_revision;
  const delayProvenance = delay
    ? " · relative_delay=" + delay.delayed_arm + "+" + delay.delay_steps +
      "f · sample=" + delay.sample_digest
    : "";
  elements.annotationProvenance.textContent = isParallel
    ? provenance + " · source_annotation=" +
      annotation.source_annotation_revision + " · retime_manifest=" +
      annotation.retime_manifest_sha256 + delayProvenance
    : provenance;
  elements.annotationTimeline.replaceChildren(
    renderAnnotationLane(
      "LEFT ARM",
      "left",
      annotation.arm_segments.left,
      definitions,
      frameCount,
    ),
    renderAnnotationLane(
      "RIGHT ARM",
      "right",
      annotation.arm_segments.right,
      definitions,
      frameCount,
    ),
  );
  renderAnnotationLegend(annotation.semantic_definitions);
}

function updateCurrentAnnotation(frame) {
  const annotation = state.episode.annotations;
  if (annotation === null) return;
  const paired = segmentAtFrame(annotation.paired_segments, frame);
  const left = segmentAtFrame(annotation.arm_segments.left, frame);
  const right = segmentAtFrame(annotation.arm_segments.right, frame);
  if (!paired || !left || !right) {
    throw new Error("当前帧没有完整的 Qwen 双臂标注: " + frame);
  }
  const definitions = semanticDefinitions(annotation);
  const leftDefinition = definitions[left.semantic_key];
  const rightDefinition = definitions[right.semantic_key];
  elements.annotationFrame.textContent = "frame " + frame;
  elements.pairedText.textContent = paired.subtask_text;
  const leftActive = ACTIVE_SEMANTICS.has(left.semantic_key);
  const rightActive = ACTIVE_SEMANTICS.has(right.semantic_key);
  if (leftActive && rightActive) {
    elements.activityRelation.textContent = "双臂同时动作 · OVERLAP";
  } else if (leftActive) {
    elements.activityRelation.textContent = "左臂动作 · 右臂等待 / 保持";
  } else if (rightActive) {
    elements.activityRelation.textContent = "左臂等待 / 保持 · 右臂动作";
  } else {
    elements.activityRelation.textContent = "双臂等待 / 保持";
  }
  const sourcePair = annotation.schedule?.source_indices?.[frame];
  elements.leftSourceIndex.textContent = sourcePair
    ? "serial source frame " + sourcePair[0]
    : "dataset frame " + frame;
  elements.rightSourceIndex.textContent = sourcePair
    ? "serial source frame " + sourcePair[1]
    : "dataset frame " + frame;
  elements.leftSemanticKey.textContent =
    leftDefinition.label_zh + " · " + left.semantic_key;
  elements.leftSemanticKey.style.color = leftDefinition.color;
  elements.leftSemantic.textContent = left.semantic_text;
  elements.rightSemanticKey.textContent =
    rightDefinition.label_zh + " · " + right.semantic_key;
  elements.rightSemanticKey.style.color = rightDefinition.color;
  elements.rightSemantic.textContent = right.semantic_text;
  elements.annotationTimeline.style.setProperty(
    "--annotation-progress",
    (100 * frame / state.episode.frame_count) + "%",
  );
  for (const block of elements.annotationTimeline.querySelectorAll(".annotation-block")) {
    const start = Number(block.dataset.start);
    const end = Number(block.dataset.end);
    block.classList.toggle("active", start <= frame && frame < end);
  }
}
async function loadEpisode() {
  const generation = ++state.loadGeneration;
  pauseVideo();
  elements.status.textContent = "加载轨迹…";
  elements.play.disabled = true;
  state.transforms = null;
  state.currentFrame = -1;

  const datasetName = elements.dataset.value;
  const episodeIndex = Number(elements.episode.value);
  const episode = await fetchChecked("/api/episode/" + encodeURIComponent(datasetName) + "/" + episodeIndex);
  if (generation !== state.loadGeneration) return;

  state.episode = episode;
  elements.timeline.max = String(episode.duration_s);
  elements.timeline.step = String(1 / episode.fps);
  elements.timeline.value = "0";
  renderRouterMarkers();
  updateArmLegend(episode.phase_timeline.has_gate_records);
  renderAnnotations(episode.annotations, episode.frame_count);
  elements.fps.textContent = "MASTER · " + episode.fps + " FPS";
  elements.meta.textContent =
    humanizeDataset(datasetName) + " · episode " + episodeIndex + " · " +
    episode.frame_count + " frames";
  elements.attributes.textContent = Object.entries(episode.attributes)
    .map(([key, value]) => key + "=" + value)
    .join(" · ");

  const metadataPromises = Object.entries(elements.videos).map(([cameraName, video]) => {
    video.src = episode.videos[cameraName];
    video.playbackRate = Number(elements.rate.value);
    const metadataPromise = waitForMetadata(video);
    video.load();
    return metadataPromise;
  });

  const [buffer] = await Promise.all([
    fetchChecked(episode.transforms_url, "arrayBuffer"),
    Promise.all(metadataPromises),
  ]);
  if (generation !== state.loadGeneration) return;

  const expectedFloats = episode.frame_count * state.config.mesh_count * 16;
  if (buffer.byteLength !== expectedFloats * Float32Array.BYTES_PER_ELEMENT) {
    throw new Error("3D transform 大小不匹配: " + buffer.byteLength + " bytes");
  }
  state.transforms = new Float32Array(buffer);
  setLocalTime(0);
  elements.play.disabled = false;
  elements.status.textContent = "已同步";
}

function routerPhase(frame) {
  const timeline = state.episode.phase_timeline;
  if (!timeline.has_gate_records) return null;
  return timeline.phase_ids[frame] === 1 ? "async" : "sync";
}

function applyRouterVisual(frame) {
  const phase = routerPhase(frame);
  const colors = phase === null
    ? { left: COLORS.left, right: COLORS.right }
    : GATE_PHASE_COLORS[phase];
  state.materials.left.color.setHex(colors.left);
  state.materials.right.color.setHex(colors.right);
  const active = phase !== null;
  state.materials.left.emissive.setHex(active ? colors.left : 0x000000);
  state.materials.right.emissive.setHex(active ? colors.right : 0x000000);
  state.materials.left.emissiveIntensity = active ? 0.16 : 0;
  state.materials.right.emissiveIntensity = active ? 0.16 : 0;
  const timeline = state.episode.phase_timeline;
  if (phase === null) {
    elements.phase.textContent = "NO GATE RECORD · step " + frame;
    elements.phase.dataset.phase = "none";
    return;
  }
  const probability = timeline.async_probabilities?.[frame];
  const inferenceIndex = timeline.inference_indices?.[frame];
  const probabilityLabel = Number.isFinite(probability)
    ? " · P(async) " + probability.toFixed(3) : "";
  const inferenceLabel = Number.isInteger(inferenceIndex) ? " · inference " + inferenceIndex : "";
  elements.phase.textContent = phase.toUpperCase() + " · step " + frame + probabilityLabel + inferenceLabel;
  elements.phase.dataset.phase = phase;
}

function applyFrame(frameIndex) {
  if (!state.transforms || !state.episode) return;
  const frame = Math.min(frameIndex, state.episode.frame_count - 1);
  if (frame === state.currentFrame) return;
  const meshCount = state.config.mesh_count;
  const frameStride = meshCount * 16;
  for (let meshIndex = 0; meshIndex < meshCount; meshIndex += 1) {
    const offset = frame * frameStride + meshIndex * 16;
    state.meshes[meshIndex].matrix.fromArray(state.transforms, offset);
    state.meshes[meshIndex].matrixWorldNeedsUpdate = true;
  }
  applyRouterVisual(frame);
  updateCurrentAnnotation(frame);
  state.currentFrame = frame;
  elements.frame.textContent =
    "frame " + String(frame).padStart(4, "0") + " / " + (state.episode.frame_count - 1);
}

function formatTime(seconds) {
  const minutes = Math.floor(seconds / 60);
  const remainder = seconds - minutes * 60;
  return String(minutes).padStart(2, "0") + ":" + remainder.toFixed(3).padStart(6, "0");
}

function updateAtTime(seconds) {
  if (!state.episode) return;
  const local = THREE.MathUtils.clamp(seconds, 0, state.episode.duration_s);
  const frame = Math.min(Math.floor(local * state.episode.fps), state.episode.frame_count - 1);
  applyFrame(frame);
  if (!state.scrubbing) elements.timeline.value = String(local);
  elements.time.textContent = formatTime(local) + " / " + formatTime(state.episode.duration_s);
}

function setLocalTime(seconds) {
  if (!state.episode) return;
  const local = THREE.MathUtils.clamp(seconds, 0, state.episode.duration_s);
  for (const video of videos()) {
    if (Math.abs(video.currentTime - local) > 0.002) video.currentTime = local;
  }
  updateAtTime(local);
}

function pauseVideo() {
  for (const video of videos()) video.pause();
  elements.play.textContent = "▶";
  elements.play.setAttribute("aria-label", "播放");
}

async function playVideo() {
  if (!state.episode || !state.transforms) return;
  if (masterVideo().currentTime >= state.episode.duration_s - 1 / state.episode.fps) {
    setLocalTime(0);
  }
  for (const video of videos()) video.playbackRate = Number(elements.rate.value);
  await Promise.all(videos().map((video) => video.play()));
  elements.play.textContent = "Ⅱ";
  elements.play.setAttribute("aria-label", "暂停");
  elements.status.textContent = "同步播放";
}

function togglePlayback() {
  if (masterVideo().paused) {
    playVideo().catch(showError);
  } else {
    pauseVideo();
    elements.status.textContent = "已暂停";
  }
}

function tick() {
  controls.update();
  if (state.episode && state.transforms && !state.scrubbing) {
    const local = THREE.MathUtils.clamp(
      masterVideo().currentTime,
      0,
      state.episode.duration_s,
    );
    updateAtTime(local);
    for (const video of videos().slice(1)) {
      if (Math.abs(video.currentTime - local) > 0.08) video.currentTime = local;
    }
    if (!masterVideo().paused && local >= state.episode.duration_s - 1 / state.episode.fps) {
      setLocalTime(state.episode.duration_s);
      pauseVideo();
      elements.status.textContent = "Episode 结束";
    }
  }
  renderer.render(scene, camera);
}

function showError(error) {
  pauseVideo();
  elements.status.textContent = "加载失败";
  console.error(error);
  alert(error.message);
}

elements.dataset.addEventListener("change", () => {
  populateEpisodes();
  loadEpisode().catch(showError);
});
elements.episode.addEventListener("change", () => loadEpisode().catch(showError));
elements.resetView.addEventListener("click", resetCamera);
elements.play.addEventListener("click", togglePlayback);
for (const video of videos()) video.addEventListener("click", togglePlayback);
elements.rate.addEventListener("change", () => {
  for (const video of videos()) video.playbackRate = Number(elements.rate.value);
});
elements.timeline.addEventListener("pointerdown", () => {
  state.scrubbing = true;
});
elements.timeline.addEventListener("input", () => {
  setLocalTime(Number(elements.timeline.value));
});
elements.timeline.addEventListener("change", () => {
  state.scrubbing = false;
  setLocalTime(Number(elements.timeline.value));
});
document.addEventListener("keydown", (event) => {
  if (event.code === "Space" && event.target.tagName !== "SELECT") {
    event.preventDefault();
    togglePlayback();
  }
});

async function initialize() {
  state.config = await fetchChecked("/api/config");
  populateDatasets();
  populateEpisodes();
  await loadRobotMeshes();
  await loadEpisode();
  renderer.setAnimationLoop(tick);
}

initialize().catch(showError);