import { SceneGuide, sdk } from "../sdk";
import { toRaw, ref, watch, watchEffect } from "vue";
import { viewModeStack, showLeftPanoStack, custom } from "@/env";
import { togetherCallback, asyncTimeout } from "@/utils";
import { fuseModels, isEdit, sysBus, fuseModelsLoaded } from "@/store";
import type { FuseModel, FuseModels, Guide, GuidePath } from "@/store";
import { analysisPoseInfo } from ".";
import { fullView, isScenePlayRun, pauseScene, playScene } from "@/utils/full";

// -----------------导览关联--------------------

export const recovery = async (guide: Guide) => {
  let rFuseModels: (FuseModel & { viewShow: boolean })[];
  try {
    if (!guide.recoveryContent) {
      throw "没有recovery";
    }
    rFuseModels = JSON.parse(guide.recoveryContent);
  } catch (e) {
    return () => {};
  }
  const initFuseModels = JSON.parse(
    JSON.stringify(fuseModels.value)
  ) as FuseModels;
  const initViewShow = fuseModels.value.map((item) =>
    custom.showModelsMap.get(item)
  );

  const setModels = async (models: (FuseModel & { viewShow: boolean })[]) => {
    for (let i = 0; i < models.length; i++) {
      const ndx = fuseModels.value.findIndex(
        ({ modelId }) => modelId === models[i].modelId
      );
      if (~ndx) {
        Object.assign(fuseModels.value[ndx], models[i]);
        custom.showModelsMap.set(
          toRaw(fuseModels.value[ndx]),
          models[i].viewShow
        );
      } else {
        fuseModels.value.push(models[i]);
        custom.showModelsMap.set(toRaw(models[i]), models[i].viewShow);
      }
    }
    // console.log(models)
    for (let i = 0; i < fuseModels.value.length; i++) {
      const ndx = models.findIndex(
        ({ modelId }) => modelId === fuseModels.value[i].modelId
      );
      if (!~ndx) {
        fuseModels.value.splice(i, 1);
        i--;
      }
    }

    await asyncTimeout(100);
    await new Promise<void>((resolve) => {
      const stop = watchEffect(() => {
        if (fuseModelsLoaded.value) {
          setTimeout(() => stop());
          resolve();
        }
      });
    });
  };

  for (let i = 0; i < fuseModels.value.length; i++) {
    const ndx = rFuseModels.findIndex(
      ({ modelId }) => modelId === fuseModels.value[i].modelId
    );
    if (!~ndx) {
      rFuseModels.push({ ...fuseModels.value[i], viewShow: false });
    }
  }

  await setModels(rFuseModels);
  return () =>
    setModels(
      initFuseModels.map((item, i) => ({ ...item, viewShow: initViewShow[i]! }))
    );
};


export const playSceneGuide = (
  paths: GuidePath[],
  changeIndexCallback?: (index: number) => void,
  forceFull = false
) => {
  let sceneGuide: SceneGuide
  return playScene({
    create: () => {
      sceneGuide = sdk.enterSceneGuide(
        paths.map((path) => ({ ...path, ...analysisPoseInfo(path) }))
      );
      changeIndexCallback && sceneGuide.bus.on("changePoint", changeIndexCallback);
    },
    play: () => {
      sceneGuide.play();
      return new Promise((resolve) => sceneGuide.bus.on("playComplete", resolve))
    },
    pause: () => {
      console.error('pause??')
      sceneGuide.pause();
    },
    clear: () => {
      sceneGuide.clear();
      sceneGuide.bus.off("changePoint");
    }
  }, forceFull)
}

export const pauseSceneGuide = pauseScene
export const isScenePlayIng = isScenePlayRun