var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/hooks/useIntelligentTracking/index.tsx
var useIntelligentTracking_exports = {};
__export(useIntelligentTracking_exports, {
  ModifyTrackCameras: () => ModifyTrackCameras,
  createIntelligentTrack: () => createIntelligentTrack,
  deleteTrackById: () => deleteTrackById,
  emitHeartbeat: () => emitHeartbeat,
  getCameraInfoByCircle: () => getCameraInfoByCircle,
  getDefaultRadius: () => getDefaultRadius,
  getSearchIntervalDuration: () => getSearchIntervalDuration,
  getTackCameraInfo: () => getTackCameraInfo,
  getTackDetailInfo: () => getTackDetailInfo,
  getTaskCameraByCenterAndPower: () => getTaskCameraByCenterAndPower,
  getTrackTaskById: () => getTrackTaskById,
  modifyTrackConf: () => modifyTrackConf,
  modifyTrackImgs: () => modifyTrackImgs,
  operateTrackById: () => operateTrackById,
  setDefaultRadius: () => setDefaultRadius,
  setIntelligentTrackCircleInfo: () => setIntelligentTrackCircleInfo,
  setSearchIntervalDuration: () => setSearchIntervalDuration,
  taskInfoToSearchItem: () => taskInfoToSearchItem
});
module.exports = __toCommonJS(useIntelligentTracking_exports);
var turf = __toESM(require("@turf/turf"));
var import_useTaskState = require("../useTaskState");
var import_Tree = __toESM(require("@common/components/CameraTree/Tree"));
var import_request = __toESM(require("../../utils/request"));
var import_antd = require("antd");
var import_utils = require("@common/components/CameraTree/utils");
var import_func = require("@zhst/func");
var defaultFaceThreshold = 0.68;
var defaultBodyThreshold = 0.7;
var defaultFaceResultNum = 5;
var defaultRadius = 0.15;
var defaultQueryCycle = 10;
var getDefaultRadius = () => {
  return defaultRadius;
};
var setDefaultRadius = (radius) => {
  defaultRadius = radius;
};
var searchIntervalDuration = 10;
var setSearchIntervalDuration = (duration) => {
  searchIntervalDuration = duration;
};
var getSearchIntervalDuration = (time) => {
  return time;
};
var operateTrackById = async (smartTrackId, operationType) => {
  try {
    const data = {
      operationType,
      smartTrackId
    };
    await (0, import_request.default)({
      method: "PUT",
      url: "/singer.SmartTrackService/OperationSmartTrack",
      data
    });
    import_antd.message.success("操作成功");
  } catch (err) {
    console.error(err);
    import_antd.message.success("操作失败");
  }
};
var deleteTrackById = async (smartTrackId) => {
  try {
    await (0, import_request.default)({
      method: "DELETE",
      url: "/singer.SmartTrackService/DeleteSmartTrack",
      data: {
        smartTrackId
      }
    });
  } catch (err) {
    console.error(err);
  }
};
var modifyTrackImgs = async (smartTrackId, images) => {
  try {
    await (0, import_request.default)({
      method: "PUT",
      url: "/singer.SmartTrackService/ModifyTrackImg",
      data: {
        images,
        smartTrackId
      }
    });
  } catch (err) {
    console.log("err", err);
  }
};
var modifyTrackConf = async (conf, smartTrackId) => {
  try {
    await (0, import_request.default)({
      method: "PUT",
      url: "/singer.SmartTrackService/ModifyTrackConf",
      data: {
        conf,
        smartTrackId
      }
    });
  } catch (err) {
    console.log("err", err);
  }
};
var getTrackTaskById = async (smartTrackId = 0) => {
  try {
    const data = smartTrackId ? {
      smartTrackId
    } : {};
    let req = await (0, import_request.default)({
      method: "POST",
      url: "/singer.SmartTrackService/GetSmartTrack",
      data
    });
    return req;
  } catch (err) {
    console.error(err);
  }
};
var getTackDetailInfo = async (smartTrackId = 0) => {
  const data = smartTrackId ? {
    smartTrackId
  } : {};
  let req = await (0, import_request.default)({
    method: "POST",
    url: "/singer.SmartTrackService/GetTrackOverView",
    data
  });
  return req;
};
var getTaskCameraByCenterAndPower = async (value) => {
  let realCameraInfos = value["cameraInfos"];
  let realPreprocessInfos = [];
  if (!(0, import_func.isEmpty)(realCameraInfos)) {
    const { taskStatus } = await (0, import_useTaskState.getListTaskStatus)();
    realPreprocessInfos = (0, import_useTaskState.getCameraStatusFunc)(taskStatus);
  }
  const runRealCameraInfos = [];
  realCameraInfos = realCameraInfos.filter((v) => {
    if (import_Tree.default.judgeOccupyPowerById(v["id"], realPreprocessInfos)) {
      runRealCameraInfos.push(v);
    }
    return !import_Tree.default.judgeOccupyPowerById(v["id"], realPreprocessInfos);
  });
  let from = turf.point(value["center"]);
  if (realCameraInfos.length > value["taskPower"]["bodyPower"]) {
    realCameraInfos.map((v) => {
      let dis = turf.distance(from, turf.point([v["longitude"], v["latitude"]]));
      return {
        ...v,
        dis
      };
    }).sort((a, b) => {
      return a - b;
    });
    realCameraInfos = realCameraInfos.slice(0, value["taskPower"]["bodyPower"]);
  }
  return [...runRealCameraInfos, ...realCameraInfos];
};
var createIntelligentTrack = async (value) => {
  const data = {
    images: value["images"],
    type: value["model"],
    normalComputerPower: value["bodyPower"] || 0,
    faceComputerPower: value["facePower"] || 0,
    // deviceIds: ['129537'],
    deviceIds: value["deviceIds"],
    conf: {
      faceThreshold: defaultFaceThreshold,
      bodyThreshold: defaultBodyThreshold,
      faceResultNum: defaultFaceResultNum,
      radius: value["circleRadius"] * 1e3,
      queryCycle: defaultQueryCycle
    },
    centerConf: {
      centerX: value["circleCenter"][0],
      centerY: value["circleCenter"][1]
    }
  };
  const res = await (0, import_request.default)({
    method: "PUT",
    url: "/singer.SmartTrackService/CreateSmartTrack",
    data
  });
  return res;
};
var emitHeartbeat = async (smartTrackId) => {
  try {
    await (0, import_request.default)({
      method: "POST",
      url: "/singer.SmartTrackService/SmartTrackHeartBeat",
      data: {
        smartTrackId
      }
    });
  } catch (err) {
    console.error(err);
  }
};
var ModifyTrackCameras = async (value) => {
  try {
    await setIntelligentTrackCircleInfo(value["smartTrackId"], value["centerPoint"]);
    await (0, import_request.default)({
      url: "/singer.SmartTrackService/ModifyTrackCameras",
      method: "PUT",
      data: {
        smartTrackId: value["smartTrackId"],
        deviceIds: value["deviceIds"]
      }
    });
  } catch (err) {
    import_antd.message.error(err);
  }
};
var setIntelligentTrackCircleInfo = async (smartTrackId, circleCenter) => {
  try {
    await (0, import_request.default)({
      url: "/singer.SmartTrackService/ModifyTrackScopeConf",
      method: "PUT",
      data: {
        smartTrackId,
        centerConf: {
          centerX: (0, import_func.get)(circleCenter, "0"),
          centerY: (0, import_func.get)(circleCenter, "1")
        }
      }
    });
  } catch (err) {
    import_antd.message.error(err);
  }
};
var getTackCameraInfo = async (value) => {
  let circleCameraInfos = await getCameraInfoByCircle(
    value["circleCenter"],
    value["radius"],
    value["zoom"]
  );
  return circleCameraInfos;
};
var getCameraInfoByCircle = async (circleCenter, radius, zoom = 16) => {
  try {
    let centerFeature = turf.circle(turf.point(circleCenter), radius, {
      units: "kilometers",
      steps: 64
    });
    let minx = 0;
    let maxx = 0;
    let miny = 0;
    let maxy = 0;
    for (let i = 0; i < 4; i++) {
      let point2 = turf.destination(turf.point(circleCenter), radius, 90 * i, {
        units: "kilometers"
      }).geometry.coordinates;
      if (point2[0] < minx || minx === 0) {
        minx = point2[0];
      }
      if (point2[0] > maxx || maxx === 0) {
        maxx = point2[0];
      }
      if (point2[1] < miny || miny === 0) {
        miny = point2[1];
      }
      if (point2[1] > maxy || maxy === 0) {
        maxy = point2[1];
      }
    }
    let { clusterPoint } = await (0, import_request.default)({
      url: "/singer.DeviceService/GetClusters",
      method: "POST",
      data: {
        northEast: { X: maxx, Y: maxy },
        southWest: { X: minx, Y: miny },
        zoom
      }
    });
    let cameraIds = [];
    clusterPoint.forEach((v) => {
      cameraIds.push(...v["cameraIDs"]);
    });
    const { cameras } = await (0, import_utils.SearchCamera)({
      cameraId: cameraIds,
      maxResults: cameraIds.length
    });
    const cameraInfos = cameras.filter((v) => {
      let cameraPoint = turf.point([(0, import_func.get)(v, "longitude"), (0, import_func.get)(v, "latitude")]);
      return turf.booleanPointInPolygon(cameraPoint, centerFeature);
    });
    return cameraInfos;
  } catch (err) {
    console.error(err);
    return [];
  }
};
var taskInfoToSearchItem = (taskInfo) => {
  let imageList = [];
  (0, import_func.get)(taskInfo, "images", []).forEach((v) => {
    const url = (0, import_func.get)(v, "conds.0.srcImageUrl");
    const objectId = (0, import_func.get)(v, "conds.0.featureInfo.objectId");
    let imageItem = {
      index: 0,
      url,
      objectId,
      odRects: (0, import_func.get)(v, "conds").map((item) => {
        return {
          fileKey: (0, import_func.get)(item, "objectImageUrl"),
          extendRect: {
            algorithmVersion: (0, import_func.get)(item, "alg", ""),
            ...(0, import_func.get)(item, "rect", {})
          },
          rect: {
            algorithmVersion: (0, import_func.get)(item, "alg", ""),
            rect: (0, import_func.get)(item, "rect", {})
          }
        };
      })
    };
    imageList.push(imageItem);
  });
  return imageList;
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  ModifyTrackCameras,
  createIntelligentTrack,
  deleteTrackById,
  emitHeartbeat,
  getCameraInfoByCircle,
  getDefaultRadius,
  getSearchIntervalDuration,
  getTackCameraInfo,
  getTackDetailInfo,
  getTaskCameraByCenterAndPower,
  getTrackTaskById,
  modifyTrackConf,
  modifyTrackImgs,
  operateTrackById,
  setDefaultRadius,
  setIntelligentTrackCircleInfo,
  setSearchIntervalDuration,
  taskInfoToSearchItem
});