import type { TabCover } from "./store";
import type { Scene } from "../../example/platform/platform-resource";
import type { StoreData } from "@/core/store/store";
import { params } from "../env";
import { genLoading } from "../loadding";
import { tempStrFill } from "@/utils/shared";

const SCENE_TYPE = {
  fuse: "fuse",
  mesh: "mesh",
  cloud: "cloud",
} as const;

const resourceURLS = {
  oss: import.meta.env.VITE_MESH_OSS,
  [SCENE_TYPE.mesh]: import.meta.env.VITE_MESH_API,
  [SCENE_TYPE.cloud]: import.meta.env.VITE_CLOUD_API,
  [SCENE_TYPE.fuse]: import.meta.env.VITE_FUSE_API,
};

const viewURLS = {
  [SCENE_TYPE.mesh]: import.meta.env.VITE_MESH_VIEW,
  [SCENE_TYPE.cloud]: import.meta.env.VITE_CLOUD_VIEW,
  [SCENE_TYPE.fuse]: import.meta.env.VITE_FUSE_VIEW,
};

const get = (url: string, params: Record<string, any>) => {
  const p = new URLSearchParams();
  for (const key in params) {
    p.append(key, params[key]);
  }
  const l = `${resourceURLS[SCENE_TYPE.fuse]}${url}?${p.toString()}`;
  return after(fetch(l, { method: "get", headers: { token } }));
};

const post = (url: string, data: Record<string, any>) => {
  const l = `${resourceURLS[SCENE_TYPE.fuse]}${url}`;
  return after(
    fetch(l, {
      headers: { token, "Content-Type": "application/json;charset=UTF-8" },
      method: "post",
      body: JSON.stringify(data),
    })
  );
};

const postFile = (url: string, data: Record<string, any>) => {
  const formData = new FormData();
  for (const key in data) {
    formData.append(key, data[key]);
  }

  const l = `${resourceURLS[SCENE_TYPE.fuse]}${url}`;
  return after(
    fetch(l, {
      headers: { token },
      method: "post",
      body: formData,
    })
  );
};

const login = () => {
  if (import.meta.env.VITE_LOGIN_VIEW) {
    setTimeout(() => {
      location.replace(
        tempStrFill(import.meta.env.VITE_LOGIN_VIEW, {
          redirect: escape(location.href),
        })
      );
    }, 3000);
  }
};

const after = async (fet: Promise<Response>) => {
  const res = await fet.then((res) => res.json());
  if (res.code === 4008) {
    login();
    throw res.message;
  } else if (res.code !== 0) {
    throw res.message;
  } else {
    return res.data;
  }
};

const token = params.token;
const getSceneList = genLoading(async (keyword: string): Promise<Scene[]> => {
  const list = await post(`fusion/case/sceneListPost`, {
    caseId: params.caseId,
    isMesh: 1,
    sceneName: keyword,
  });
  return list.map((item: any) => ({
    type: SCENE_TYPE.mesh,
    m: item.num,
    title: item.name,
    id: item.id.toString(),
  }));
});

const getOverviewData = genLoading(async (id: string) => {
  if (!id) {
    return {
      store: {},
      viewport: null,
    };
  }
  const data = await get("fusion/caseOverview/info", { overviewId: id });
  return {
    store: JSON.parse(data.store),
    viewport: JSON.parse(data.viewport),
  };
});

const saveOverviewData = genLoading(
  async (
    id: string,
    data: {
      store: StoreData;
      viewport: number[] | null;
    }
  ) => {
    const item = await post(`fusion/caseOverview/addOrUpdate`, {
      ...params,
      id,
      store: JSON.stringify(data.store),
      viewport: JSON.stringify(data.viewport),
    });
    return item.id;
  }
);

const getTabulationId = async (id: string) => {
  const list = await get("fusion/caseTabulation/getByOverviewId", {
    overviewId: id,
  });
  return list[0]?.id;
};

const getTabulationData = genLoading(async (id: string) => {
  if (!id) {
    return {
      store: {},
      cover: null,
      isAutoGen: true,
      viewport: null,
      paperKey: "a4",
    };
  }
  const data = await get(`fusion/caseTabulation/info`, { tabulationId: id });
  return {
    store: JSON.parse(data.store),
    viewport: JSON.parse(data.viewport),
    cover: JSON.parse(data.cover),
    isAutoGen: Number(data.isAutoGen),
    paperKey: data.paperKey,
  };
});

const saveTabulationData = genLoading(
  async (
    id: string,
    data: {
      store: StoreData;
      viewport: number[] | null;
      isAutoGen: boolean;
      cover: TabCover | null;
      paperKey?: string;
      overviewId: string;
    }
  ) => {
    const item = await post("fusion/caseTabulation/addOrUpdate", {
      ...params,
      id,
      store: JSON.stringify(data.store),
      viewport: JSON.stringify(data.viewport),
      cover: JSON.stringify(data.cover),
      isAutoGen: Number(data.isAutoGen),
      paperKey: data.paperKey,
      overviewId: data.overviewId,
    });
    return item.id;
  }
);

const uploadResourse = genLoading(async (file: File) => {
  return postFile(`fusion/upload/file`, { file });
});

window.platform = {
  resourceURLS,
  viewURLS,
  getOverviewData,
  getSceneList,
  saveOverviewData,
  getTabulationData,
  saveTabulationData,
  uploadResourse,
  getTabulationId,
};

/* @vite-ignore */
import(import.meta.env.VITE_ENTRY_EXAMPLE);