import { defHttp } from '/@/utils/http/axios';
import {
  DeviceModel,
  DeviceModelOfMatterAttrs,
  DeviceProfileModel,
  DeviceProfileQueryParam,
  DeviceQueryParam,
  DeviceRecord,
  DeviceTypeEnum,
  DeviceStateLogModel,
} from '/@/api/device/model/deviceModel';
import { ChildDeviceParams } from './model/deviceModel';
import { PaginationResult } from '/#/axios';
import { AlarmLogItem } from './model/deviceConfigModel';
import { omit } from 'lodash-es';
import { CommandDeliveryWayEnum } from '/@/enums/toolEnum';
enum DeviceManagerApi {
  /**
   * 设备URL
   */
  DEVICE_URL = '/device',
  /**
   * 设备配置URL
   */
  DEVICE_PROFILE_URL = '/device_profile',

  DEVICE_PROFILE_URL_ME = '/device_profile/me/list',

  DEVICE_ALARM_URL = '/alarm',

  ALARM_BATCH_ACK = '/alarm/batch/ack',

  ALARM_BATCH_CLEAR = '/alarm/batch/clear',

  DEVICE_CREDENTIALS = '/device/credentials',

  COMMAND_ISSUANCE = '/rpc',

  DEVICE_ATTR = '/device/attributes',

  GATEWAY_DEVICE = '/device/gateway/list',

  DEVICE_STATE_LOG_URL = '/device/state/log',

  DEVICE_PUBLIC = '/customer/public/device',

  DEVICE_PRIVATE = '/customer/device',
  DEVICE_COLLECT = '/collect/DEVICE_COLLECT', //收藏

  /**
   * @description 通过设备列表获取设备信息
   */
  QUERY_DEVICES = '/device/get/devices',
}

export const devicePage = (params: DeviceQueryParam) => {
  const { page, pageSize } = params;
  const otherParams = omit(params, ['page', 'pageSize']);
  return defHttp.post<PaginationResult<DeviceModel>>({
    url: `${DeviceManagerApi.DEVICE_URL}?page=${page}&pageSize=${pageSize}`,
    params: otherParams,
  });
};

export const deviceCollect = (params: string[]) => {
  return defHttp.post({
    url: `${DeviceManagerApi.DEVICE_COLLECT}`,
    params,
  });
};

/**
 * 分页查询设备配置页面
 * @param params pageSize page name
 */
export const deviceProfilePage = (params: DeviceProfileQueryParam) => {
  return defHttp.get<DeviceProfileModel>({
    url: DeviceManagerApi.DEVICE_PROFILE_URL,
    params,
  });
};
/**
 * 删除设备配置
 * @param ids 删除的ids
 */
export const deleteDeviceProfile = (ids: string[]) => {
  return defHttp.delete({
    url: DeviceManagerApi.DEVICE_PROFILE_URL,
    data: {
      ids: ids,
    },
  });
};

/**
 * 删除设备
 * @param ids 删除的ids
 */
export const deleteDevice = (ids: string[]) => {
  return defHttp.delete({
    url: DeviceManagerApi.DEVICE_URL,
    data: {
      ids: ids,
    },
  });
};

/**
 * 查询设备配置
 * @param params pageSize page name
 */
export const deviceProfile = () => {
  return defHttp.get<DeviceRecord[]>({
    url: DeviceManagerApi.DEVICE_PROFILE_URL_ME,
  });
};

export const queryDeviceProfileBy = (params: Recordable) => {
  return defHttp.get<DeviceRecord[]>({
    url: DeviceManagerApi.DEVICE_PROFILE_URL_ME,
    params,
  });
};

// 创建或编辑设备
export const createOrEditDevice = (data) => {
  return defHttp.post({
    url: DeviceManagerApi.DEVICE_URL,
    data,
  });
};

// 查询设备详情
export const getDeviceDetail = (id: string) => {
  return defHttp.get({
    url: DeviceManagerApi.DEVICE_URL + `/${id}`,
  });
};

// 查询设备详情中的告警
export const getDeviceAlarm = (params?: DeviceProfileQueryParam) => {
  return defHttp.get<PaginationResult<AlarmLogItem>>({
    url: DeviceManagerApi.DEVICE_ALARM_URL,
    params,
  });
};

// 如果是flag为true 就是清除报警,否则是处理报警
export const clearOrAckAlarm = (id: string, flag: boolean) => {
  return defHttp.post(
    {
      url: `${DeviceManagerApi.DEVICE_ALARM_URL}/${id}/${flag ? 'clear' : 'ack'}`,
    },
    {
      joinPrefix: false,
    }
  );
};

// 获取设备凭证详情
export const getDeviceToken = (id: string) => {
  return defHttp.get(
    {
      url: `${DeviceManagerApi.DEVICE_URL}/${id}/credentials`,
    },
    {
      joinPrefix: false,
    }
  );
};

// 保存设备凭证详情

export const saveDeviceToken = (data) => {
  return defHttp.post(
    {
      url: DeviceManagerApi.DEVICE_CREDENTIALS,
      data,
    },
    {
      joinPrefix: false,
    }
  );
};

// 获取当前租户下的客户列表
export const getCustomerList = (params) => {
  return defHttp.get({
    url: '/user/customers/' + params.organizationId,
  });
};

// 分配客户
export const dispatchCustomer = (data) => {
  const { customerId, tbDeviceId } = data;
  return defHttp.post(
    {
      url: `/customer/${customerId}/device/${tbDeviceId}`,
    },
    {
      joinPrefix: false,
    }
  );
};
// 检查设备是否被占用
export const checkDeviceOccupied = (id) => {
  return defHttp.get({
    url: `/device/used/${id}`,
  });
};

// 取消分配客户
export const cancelDispatchCustomer = (data) => {
  const { tbDeviceId } = data;
  return defHttp.delete(
    {
      url: `/customer/device/${tbDeviceId}`,
    },
    {
      joinPrefix: false,
    }
  );
};

// 获取组织下的的所有网关设备
export const getGATEWAYdevice = async (params: {
  organizationId: string;
  deviceType: DeviceTypeEnum.GATEWAY;
}) => {
  const { organizationId, deviceType } = params;
  const res = await defHttp.get({
    url: `/device/list`,
    params: {
      organizationId,
      deviceType,
    },
  });
  return Promise.resolve<{ label: string; value: string }[]>(
    res.map((item) => ({ label: item.name, value: item.tbDeviceId }))
  );
};

export const getGatewayDevice = (params: Record<'organizationId' | 'transportType', string>) => {
  const { organizationId, transportType } = params;
  return defHttp.get<DeviceRecord[]>({
    url: DeviceManagerApi.GATEWAY_DEVICE,
    params: {
      organizationId,
      transportType,
    },
  });
};

// 获取网关设备
export const getGATEWAY = (tbDeviceId: string) => {
  return defHttp.get({
    url: '/device/gateway/' + tbDeviceId,
  });
};

// 获取子设备的分页
export const getChildDevicePage = (params: ChildDeviceParams) => {
  return defHttp.get({
    url: '/device/relation',
    params,
  });
};

export const generateSNCode = () => {
  return defHttp.get({
    url: '/device/sn',
  });
};

//命令下发
export const commandIssuanceApi = (
  type: CommandDeliveryWayEnum,
  tbDeviceId: string,
  data: Recordable
) => {
  return defHttp.post(
    {
      url: `${DeviceManagerApi.COMMAND_ISSUANCE}/${type}/${tbDeviceId}`,
      data,
    },
    {
      joinPrefix: false,
    }
  );
};

export const getDeviceAttrs = (params: { deviceProfileId: string; dataType?: string }) => {
  const { deviceProfileId, dataType } = params;
  return defHttp.get<DeviceModelOfMatterAttrs[]>({
    url: `${DeviceManagerApi.DEVICE_ATTR}/${deviceProfileId}`,
    params: { dataType },
  });
};

/**
 * 设备上下线记录相关api
 */
export const deviceStateLogPage = (params: DeviceQueryParam) => {
  return defHttp.get<DeviceStateLogModel>({
    url: DeviceManagerApi.DEVICE_STATE_LOG_URL,
    params,
  });
};

export const deleteStateLogDevice = (ids: string[]) => {
  return defHttp.delete({
    url: DeviceManagerApi.DEVICE_STATE_LOG_URL,
    data: {
      ids: ids,
    },
  });
};

export const deviceStateLogDetail = (id) => {
  return defHttp.get<DeviceStateLogModel>({
    url: DeviceManagerApi.DEVICE_STATE_LOG_URL + '/' + id,
  });
};

export const deviceStateLogPost = (data) => {
  return defHttp.post(
    {
      url: DeviceManagerApi.DEVICE_STATE_LOG_URL,
      data,
    }
    // {
    //   joinPrefix: false,
    // }
  );
};

export const publicDevice = (tbDeviceId: string) => {
  return defHttp.post(
    {
      url: `${DeviceManagerApi.DEVICE_PUBLIC}/${tbDeviceId}`,
    },
    { joinPrefix: false }
  );
};

export const privateDevice = (tbDeviceId: string) => {
  return defHttp.delete(
    {
      url: `${DeviceManagerApi.DEVICE_PRIVATE}/${tbDeviceId}`,
    },
    { joinPrefix: false }
  );
};

export const getDevicesByDeviceIds = (ids: string[]) => {
  return defHttp.post<Record<'data', DeviceModel[]>>({
    url: DeviceManagerApi.QUERY_DEVICES,
    data: ids,
  });
};

export const doBatchAckAlarm = (ids: string[]) => {
  return defHttp.post(
    {
      url: DeviceManagerApi.ALARM_BATCH_ACK,
      data: { alarmIds: ids },
    },
    { joinPrefix: false }
  );
};

export const doBatchClearAlarm = (ids: string[]) => {
  return defHttp.post(
    {
      url: DeviceManagerApi.ALARM_BATCH_CLEAR,
      data: { alarmIds: ids },
    },
    { joinPrefix: false }
  );
};