import { get } from "./pages/map2d/util";
import dataHelper from "./data-helper";
const baseUrl = "https://iot.1000my.com";
export const cdnUrl = "https://qianmu-iot.1000my.com";
export const code = "project-ey_fpaur6s6fkgvszywana";
export const post = (url, data) =>
  new Promise((resolve) => {
    wx.request({
      url: baseUrl + url,
      method: "POST",
      header: { projectCode: code },
      data: { ...data },
      success({ data, statusCode }) {
        if (statusCode !== 200) return reject();
        resolve(data);
      },
    });
  });

let mapDataAndShop = null;

export const mall = {
  isNew: true,
  baseUrl,
  cdnUrl,
  code,
  floors: [
    [true, "B3"],
    [true, "B2"],
    [true, "B1"],
    [true, "1F"],
    [true, "1MF"],
    [true, "2F"],
    [false, "景观层"],
  ],
};
const config = {
  mapDataUrl: `${cdnUrl}/ar/${code}/Aeditor/Aeditor.json?t=${new Date().getTime()}`,
  shopInfoUrl: `${cdnUrl}/ar/${code}/QueryShopListForMap/QueryShopListForMap.json?t=${new Date().getTime()}`,
};
export const getMapData = async () => {
  if (mapDataAndShop) return mapDataAndShop;
  try {
    const { mapUrl, shopUrl } = await get(
      `${cdnUrl}/ar/${code}/config.json?t=${new Date().getTime()}`
    );
    if (mapUrl) config.mapDataUrl = mapUrl;
    if (shopUrl) config.shopInfoUrl = shopUrl;
  } catch (error) {
    console.log("获取config失败");
  }

  let [
    mapData,
    serverShopInfo,
    { data: facs },
    { data: sdkMapList },
    {
      data: { projectConfig: sdkConfig },
    },
    { data: pois },
    ...rest
  ] = await Promise.all([
    (async () => {
      try {
        const {
          data: [{ mapData }],
        } = await get(config.mapDataUrl);
        return mapData;
      } catch (error) {
        console.error(error);
        return {};
      }
    })(),
    (async () => {
      try {
        const {
          data: [serverShopInfo],
        } = await get(config.shopInfoUrl);
        return serverShopInfo;
      } catch (error) {
        console.error(error);
        return {};
      }
    })(),
    get(
      `${baseUrl}/api/guidance/v1/web/getProjectUsedIconList?projectCode=${code}`
    ),
    post(`/api/ar/v1/applet/GetSdkConfigList`, { mallCode: code }),
    post(`/api/ar/v1/applet/ProjectConfig`, { mallCode: code }),
    post(`/api/ar/v1/applet/GetPoiList`, { mallCode: code }),
    ...mall.floors.map((_, i) =>
      get(`${baseUrl}/api/guidance/v1/web/getMallMapData/${code}/${i}`)
    ),
  ]);

  const poiMap = pois.reduce((acc, nxt) => ({ ...acc, [nxt.code]: nxt }), {});
  const sdkMap = sdkMapList.map(
    ({
      poiid: poi_id,
      floorid: floor_id,
      isPark: is_park,
      appid: app_id,
      mapid: map_id,
      caseid: case_id,
      transMatrix: transform_matrix,
      scale,
    }) => ({
      app_id,
      map_id,
      poi_id,
      floor_id,
      transform_matrix,
      scale,
      ...(case_id ? { case_id } : {}),
      is_park,
    })
  );
  const map2dData = rest
    .map((res) => (res.data && res.data.mapData ? res.data.mapData : null))
    .map((mapData) => (mapData ? JSON.parse(mapData) : null));
  mall.floors.forEach((floor, i) => {
    floor[2] = map2dData[i];
  });
  serverShopInfo = serverShopInfo.map(({ floorOrd: floorOrder, shopList }) => ({
    floorOrder,
    shopList: shopList.map((iot) => ({
      ...iot,
      code: iot.shopCode,
      houseNum: iot.houseNumber,
      logoPath: cdnUrl + iot.logoUrl,
      shopFormat: iot.industryFatherName,
      intro: true,
      formatColor: iot.color,
      floorOrder,
    })),
  }));
  mapData = JSON.parse(mapData)[0];
  const facilityTypeMap = facs.reduce(
    (acc, nxt) => ({
      ...acc,
      [nxt.node]: nxt.customFacilityName || nxt.name,
    }),
    {}
  );
  const facilityCodeMap = facs.reduce(
    (acc, nxt) => ({
      ...acc,
      [nxt.abbreviation]: Number(nxt.objCode),
    }),
    {}
  );
  const floors = mall.floors;
  let shopMap = {};
  serverShopInfo.forEach(({ shopList }) => {
    shopList.forEach((shop) => {
      shop.floorName = floors[shop.floorOrder]
        ? floors[shop.floorOrder][1]
        : "";
      shopMap[shop.houseNum] = shop;
    });
  });
  const dataHelperResponse = await dataHelper({
    serverShopInfo,
    mapData,
    mall,
    facilityTypeMap,
    facilityCodeMap,
  });
  const pMap = mapData.buildArr
    .map(({ mapData: { parkArea } }, i) => {
      return Object.entries(
        parkArea.reduce((acc, { parkNum, shopNav }) => {
          const key = `${i}_${shopNav}`;
          return {
            ...acc,
            [key]: [...(acc[key] ? acc[key] : []), parkNum],
          };
        }, {})
      ).map(([key, parkNo]) => {
        const [floorOrder, pathNo] = key.split("_");
        return { floorOrder, pathNo, parkNo };
      });
    })
    .reduce((acc, nxt) => [...acc, ...nxt], [])
    .reduce((acc, { floorOrder, pathNo, parkNo }) => {
      acc = { ...acc };
      parkNo.forEach((name) => {
        acc[name] = {
          name,
          navPoint: pathNo,
          floorOrder,
          floorName: floors[floorOrder][1],
          xaxis: dataHelperResponse.points[floorOrder][pathNo].position,
          yaxis: pathNo,
        };
      });
      return acc;
    }, {});
  mapDataAndShop = {
    ...dataHelperResponse,
    serverShopInfo,
    mapData,
    mall,
    shopMap,
    pMap,
    poiMap,
    config: { ...sdkConfig, map: sdkMap },
  };
  return mapDataAndShop;
};