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

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

console.log(import.meta.env.VITE_OSS_ROOT)
const resourceURLS = {
  oss: import.meta.env.VITE_MESH_OSS,
  ossRoot: import.meta.env.VITE_OSS_ROOT,
  [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 getHeaders = () => ({
  token: token.value || localStorage.getItem("token") || "",
  caseId: params.value.caseId || "",
  "page-type": "edit",
});
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: getHeaders() }));
};

const post = (url: string, data: Record<string, any>) => {
  const l = `${resourceURLS[SCENE_TYPE.fuse]}${url}`;
  console.log(data)
  return after(
    fetch(l, {
      headers: {
        "Content-Type": "application/json;charset=UTF-8",
        ...getHeaders(),
      },
      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: getHeaders(),
      method: "post",
      body: formData,
    })
  );
};

const login = (isBack = true) => {
  if (import.meta.env.VITE_LOGIN_VIEW) {
    const p: any = { ...params.value };
    delete p.token;

    const cur = urlUpdateQuery(location.href, p, true);
    let link = tempStrFill(import.meta.env.VITE_LOGIN_VIEW, { redirect: escape(cur) })
    
    if (!isBack) {
      const url = new URL(link);
      url.searchParams.delete("redirect");
      const query = urlGetQuery(url.toString())
      delete query['redirect']
      link = urlUpdateQuery(url.toString(), query, true)
    }
    location.replace(link);
  }
};

const after = async (fet: Promise<Response>) => {
  const res = await fet.then((res) => res.json());
  if ([4008, 4010, 7012].includes(res.code)) {
    setTimeout(() => {
      login(res.code !== 7012);
    }, 1000);
    throw res.message;
  } else if (res.code !== 0) {
    throw res.message;
  } else {
    return res.data;
  }
};

if (!params.value.caseId || !token) {
  login(!!params.value.caseId);
}

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

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.value,
      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.value,
      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) => {
  const url = await postFile(`fusion/upload/file`, { file });
  if (url.includes("//")) {
    return url;
  }
  if (import.meta.env.DEV && import.meta.env.VITE_STATIC) {
    return `${import.meta.env.VITE_STATIC}${url}`;
  } else {
    return url;
  }
});

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

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