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 { formatDate, tempStrFill } from "@/utils/shared";
import {
  type LatLng,
  latlngStrTransform,
} from "../dialog/basemap/leaflet/useLeaflet";
import mitt from "mitt";

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

export 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,
};

export 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,
};
export const getHeaders = () => ({
  token: token.value || localStorage.getItem("token") || "",
  "page-type": "edit",
});

export const bus = mitt();

export 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: window.platform.getHeaders() })
  );
};

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

export 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: window.platform.getHeaders(),
      method: "post",
      body: formData,
    })
  );
};

export const login = (isBack = true) => {
  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) {
    let url: URL;
    try {
      url = new URL(link);
    } catch {
      url = new URL(link, location.origin);
    }
    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>) => {
  let res: any;
  const response = await fet;
  if (response.status !== 200) {
    if (response.status === 404) {
      res = {
        code: 404,
        message: "网络异常",
      };
    } else {
      res = {
        code: 500,
        message: "服务异常",
      };
    }
  } else {
    try {
      res = await response.json();
    } catch {
      res = {
        code: 500,
        message: "服务异常",
      };
    }
  }

  if (res.code === 8034) {
    if (!import.meta.env.DEV) {
      setTimeout(() => {
        history.back();
      }, 1000);
    }
    throw `${res.message}，即将退出`;
  }

  if ([4008, 4010, 7012].includes(res.code)) {
    setTimeout(() => {
      window.platform.login(res.code !== 7012);
    }, 1000);
    throw res.message;
  }

  if (res.code !== 0) {
    bus.emit("requestError", res);
  }
  if (res.code !== 0) {
    throw res.message;
  } else {
    return res.data;
  }
};

export const getSceneList = (keyword: string) => {
  let page = 1;
  let final = false;

  const list: Scene[] = [];
  const request = genLoading(async () => {
    const data = await post(`fusion/case/sceneListPost`, {
      isMesh: 1,
      caseId: params.value.caseId,
      pageNum: page,
      sceneName: keyword,
    });
    const current = data.list.map(
      (item: any) =>
        ({
          type: SCENE_TYPE.mesh,
          m: item.num,
          title: item.sceneName,
          id: item.id.toString(),
          mapping: item.mapping,
          token,
        } as Scene)
    );
    list.push(...current);
    page++;
    final = Math.ceil(data.total / data.pageSize) < page;
  });
  let next = async () => {
    if (!final) {
      await request();
    }
    return {
      next,
      final,
      list,
    };
  };
  return { next, final, list };
};

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

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

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

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

export 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,
      ...data,
      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;
  }
);

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

export const getResource = (url: string) => {
  return url;
  // if (url.includes("//")) {
  //   return url;
  // } else if (import.meta.env.DEV && import.meta.env.VITE_STATIC) {
  //   console.log(url, import.meta.env.VITE_STATIC)
  //   return `${import.meta.env.VITE_STATIC}${url}`;
  // } else {
  //   return url;
  // }
};

let tempCache: any
export let getTableTemp = async () => {
  if (tempCache) return tempCache;
  let table: Record<string, string>;
  let title: string = params.value.title;
  if (params.value.table) {
    try {
      table = JSON.parse(params.value.table);
    } catch (e) {
      console.log("tableTemp模板解析失败");
    }
  }


  if (!table!) {
    table = {
      案发时间: "",
      案发地点: "",
      绘图单位: "",
      绘图人: "",
      绘图时间: "",
    };

    if (params.value.overviewId) {
      const item = await get("fusion/caseOverview/settingInfo", {
        overviewId: params.value.overviewId,
      });
      if (item) {
        table.案发时间 = item.crimeTimeBegin;
        table.案发地点 = item.caseLocation;
        table.绘图单位 = item.orgName;
        table.绘图人 = item.investigatorName;
        table.绘图时间 = formatDate(new Date(), 'yyyy.mm.dd hh:MM:ss')
      }
      if (!title) {
        title = `“${item.crimeTimeBegin}”${item.caseLocation}${item.caseTypeName}现场平面示意图`
      }
    }
  }
  if (!title) {
    title = "默认标题";
  }
  return tempCache = { table, title }
};

export const getTileGroups = async () => {
  const data = await get(`fusion/notAuth/getMapConfig`, {});
  return data.map((item: any) => {
    const mitem = JSON.parse(item.mapUrl);
    return {
      id: item.id,
      name: item.name,
      tiles: mitem.map((tileItem: any) => ({
        url: tileItem.tempUrl,
        minimumLevel: tileItem.minimumLevel || 1,
        maximumLevel: tileItem.maximumLevel || 18,
      })),
    };
  });
};

export const searchAddress = async (keyword: string, mapId: number) => {
  const data = await post(`fusion/mapConfig/geocode`, {
    address: keyword,
    mapId,
  });
  return data.map((item: any) => ({
    ...item,
    latlng: latlngStrTransform(item.location.split(",").reverse().join(",")),
  }));
};

export const getDefaultAddress = () => {
  try {
    console.log(params.value.latlng);
    let latlng: LatLng = JSON.parse(params.value.latlng);
    return latlng;
  } catch {
    return null;
  }
};