import { nextTick, ref, toRaw, watchEffect } from "vue";
import { Pose, SceneModel, sdk, SDK } from "../sdk";
import {
  activeModel,
  associationModels,
  getFuseModel,
  sceneModelMap,
} from "./fuseMode";
import { FuseModel, fuseModelsLoaded, GuidePath, setting } from "@/store";
import { associationTaggings } from "./tagging";
import { associationSetting } from "./setting";
import { associationMessaures } from "./measure";
import { custom } from "@/env";
import { associationPaths } from "./path";

export const getSupperPanoModel = () => {
  const supperModel = ref<FuseModel | null>(null);

  const interval = setInterval(() => {
    if (!sdk) return;
    clearInterval(interval);

    const update = () => {
      const data = sdk.canTurnToPanoMode();
      if (data?.model) {
        const smodel = getFuseModel(data.model)!
        supperModel.value = smodel;
      } else {
        supperModel.value = null;
      }
    }
    watchEffect((onCleanup) => {
      const smodels = [...sceneModelMap.values()]
      console.log(smodels)
      smodels.forEach(smodel => {
        smodel.bus.on('transformChanged', update)
      })
      onCleanup(() => {
        smodels.forEach(smodel => {
          smodel.bus.off('transformChanged', update)
        })
      })
    })
    sdk.sceneBus.on("cameraChange", update);
  }, 16);

  return supperModel;
};

export const analysisPose = (pose: Pose) => {
  if ("model" in pose && pose.model) {
    let info: GuidePath["panoInfo"] | undefined = undefined;
    let fuseMode = getFuseModel(pose.model);
    if (fuseMode!) {
      info = {
        panoId: pose.panoId,
        modelId: fuseMode.id,
        posInModel: pose.posInModel,
        rotInModel: pose.rotInModel,
      };
      return {
        position: pose.position,
        target: pose.target,
        panoInfo: info,
      };
    }
  }
  return pose;
};

export const analysisPoseInfo = (info: ReturnType<typeof analysisPose>) => {
  let pose: Pose = { target: info.target, position: info.position };
  if ("panoInfo" in info && info.panoInfo) {
    let sceneModel: SceneModel;
    for (const [k, v] of Array.from(sceneModelMap.entries())) {
      if (k.id === info.panoInfo.modelId) {
        sceneModel = toRaw(v);
      }
    }

    if (sceneModel!) {
      pose = {
        ...pose,
        model: sceneModel,
        panoId: info.panoInfo.panoId,
        posInModel: info.panoInfo.posInModel,
        rotInModel: info.panoInfo.rotInModel,
      };
    }
  }
  return pose;
};

export const setPose = (info: ReturnType<typeof analysisPose>, _sdk = sdk) => {
  const pose = analysisPoseInfo(info);
  if ("model" in pose) {
    setTimeout(() => {
      for (const [k, v] of Array.from(sceneModelMap.entries())) {
        if (toRaw(v) === toRaw(pose.model)) {
          activeModel({ showMode: "pano", active: k });
          return;
        }
      }
    }, 300);
  } else {
    activeModel({ showMode: "fuse" });
  }
  setTimeout(() => {
    sdk.comeTo({ ...pose, dur: 300 });
  });
};

export const setupAssociation = (mountEl: HTMLDivElement, sdk: SDK) => {
  associationModels(sdk);

  const stopWatch = watchEffect(() => {
    if (fuseModelsLoaded.value && setting.value) {
      associationTaggings(sdk, mountEl);
      associationMessaures(sdk);
      associationSetting(sdk, mountEl);
      associationPaths(sdk, mountEl)
      nextTick(() => stopWatch());
    }
  });
};

export * from "./fuseMode";
export * from "./guide";
export * from "./measure";
export * from "./setting";
export * from "./tagging";