const state = {
  viewers: [],
  camera: "angle",
  syncing: false,
  outerLayer: true,
  uvOnly: false,
  generation: 0,
};
function cameraPreset(viewer) {
  const camera = viewer.camera;
  if (state.camera === "head") {
    viewer.controls.target.set(0, 10, 0);
    camera.position.set(10, 12, 18);
  } else {
    viewer.controls.target.set(0, 0, 0);
    const distance = 48;
    if (state.camera === "front") camera.position.set(0, 0, distance);
    else if (state.camera === "back") camera.position.set(0, 0, -distance);
    else camera.position.set(23, 7, 42);
  }
  camera.lookAt(viewer.controls.target);
  camera.updateProjectionMatrix();
  viewer.controls.update();
}

function applyCamera() {
  state.syncing = true;
  try {
    state.viewers.forEach((x) => cameraPreset(x.viewer));
  } finally {
    state.syncing = false;
  }
  document
    .querySelectorAll("[data-camera]")
    .forEach((x) =>
      x.classList.toggle("active", x.dataset.camera === state.camera),
    );
}

function syncCamera(source) {
  if (state.syncing) return;
  state.syncing = true;
  try {
    for (const { viewer } of state.viewers) {
      if (viewer === source) continue;
      viewer.camera.position.copy(source.camera.position);
      viewer.camera.quaternion.copy(source.camera.quaternion);
      viewer.camera.zoom = source.camera.zoom;
      viewer.controls.target.copy(source.controls.target);
      viewer.camera.updateProjectionMatrix();
      viewer.controls.update();
    }
  } finally {
    state.syncing = false;
  }
}

function createViewer(stage, result, generation) {
  const status = stage.querySelector(".preview-status");
  if (!window.skinview3d) {
    status.textContent = "3D 组件不可用，请查看下方 UV";
    return;
  }
  let viewer;
  try {
    viewer = new skinview3d.SkinViewer({
      canvas: stage.querySelector("canvas"),
      width: stage.clientWidth || 220,
      height: stage.clientHeight || 300,
      pixelRatio: Math.min(window.devicePixelRatio || 1, 2),
      renderPaused: state.uvOnly,
      model: "default",
    });
    viewer.controls.enablePan = false;
    viewer.controls.enableDamping = false;
    viewer.controls.minDistance = 12;
    viewer.controls.maxDistance = 120;
    viewer.controls.addEventListener("change", () => syncCamera(viewer));
    const observer = new ResizeObserver(() => {
      if (!viewer.disposed && stage.clientWidth && stage.clientHeight) {
        viewer.width = stage.clientWidth;
        viewer.height = stage.clientHeight;
      }
    });
    observer.observe(stage);
    state.viewers.push({ viewer, observer });
    Promise.resolve(viewer.loadSkin(result.url, { model: "default" }))
      .then(() => {
        if (generation !== state.generation || viewer.disposed) return;
        viewer.playerObject.skin.setOuterLayerVisible(state.outerLayer);
        status.hidden = true;
      })
      .catch(() => {
        if (generation === state.generation)
          status.textContent = "此图片无法生成 3D 预览，可查看 UV";
      });
  } catch (error) {
    if (viewer && !viewer.disposed) viewer.dispose();
    status.textContent = "3D 预览不可用，可查看下方 UV";
  }
}

export function mountViewer(stage, result) {
  createViewer(stage, result, state.generation);
  applyCamera();
  const entry =
    state.viewers.find(
      (x) => x.viewer.canvas === stage.querySelector("canvas"),
    ) || state.viewers.at(-1);
  return () => {
    if (!entry) return;
    entry.observer.disconnect();
    entry.viewer.dispose();
    entry.viewer.renderer.forceContextLoss();
    state.viewers = state.viewers.filter((x) => x !== entry);
  };
}
export function configure(camera, outerLayer, uvOnly) {
  const changed = state.camera !== camera;
  Object.assign(state, { camera, outerLayer, uvOnly });
  if (changed) applyCamera();
  state.viewers.forEach(({ viewer }) => {
    viewer.playerObject.skin.setOuterLayerVisible(outerLayer);
    viewer.renderPaused = uvOnly;
  });
}