import { unref } from 'vue';
import { useSelectWidgetKeys, useSelectWidgetMode } from '../../dataSourceBindPanel/useContext';
import { PackagesCategoryEnum } from '../index.type';
import { getDeviceProfile } from '/@/api/alarm/position';
import { getDeviceAttributes, getMeetTheConditionsDevice } from '/@/api/dataBoard';
import { DeviceAttributeParams } from '/@/api/dataBoard/model';
import { getModelServices } from '/@/api/device/modelOfMatter';
import { findDictItemByCode } from '/@/api/system/dict';
import { ApiCascader, FormSchema, useComponentRegister } from '/@/components/Form';
import { OrgTreeSelect } from '/@/views/common/OrgTreeSelect';
import { DataActionModeEnum } from '/@/enums/toolEnum';
import { TaskTypeEnum } from '/@/views/task/center/config';
import { createPickerSearch } from '/@/utils/pickerSearch';
import { DataTypeEnum } from '/@/enums/objectModelEnum';
import { CommandTypeEnum, CommandTypeNameEnum } from '/@/enums/deviceEnum';
import { TransportTypeEnum } from '/@/enums/deviceEnum';
import { DeviceTypeEnum } from '/@/api/device/model/deviceModel';
import { ControlComponentEnum } from '../components/Control';
import { isNullOrUnDef } from '/@/utils/is';
import { validateTCPCustomCommand } from '/@/components/Form/src/components/ThingsModelForm';
import { CategoryEnum } from '../components';

useComponentRegister('OrgTreeSelect', OrgTreeSelect);
useComponentRegister('ApiCascader', ApiCascader);

export interface CommonDataSourceBindValueType extends Record<DataSourceField, string> {
  customCommand?: {
    transportType?: string;
    service?: string;
    command?: string;
    commandType?: string;
    callType?: string;
    [ksy: string]: string | undefined;
  };
}

export enum DataSourceField {
  // IS_GATEWAY_DEVICE = 'gatewayDevice',
  DEVICE_TYPE = 'deviceType',
  TRANSPORT_TYPE = 'transportType',
  ORIGINATION_ID = 'organizationId',
  DEVICE_ID = 'deviceId',
  // DEVICE_CODE = 'deviceCode', //设备地址码
  DEVICE_PROFILE_ID = 'deviceProfileId',
  ATTRIBUTE = 'attribute',
  // ATTRIBUTE_NAME = 'attributeName',
  ATTRIBUTE_RENAME = 'attributeRename',
  DEVICE_NAME = 'deviceName',
  DEVICE_RENAME = 'deviceRename',

  CODE_TYPE = 'codeType',
  // COMMAND = 'command',

  OPEN_COMMAND = 'openCommand',
  CLOSE_COMMAND = 'closeCommand',

  COMMAND_TYPE = 'commandType',

  // SERVICE = 'service',

  /**
   * @description 关服务标识符
   */
  OPEN_SERVICE = 'openService',

  /**
   * @description 开服务标识符
   */
  CLOSE_SERVICE = 'closeService',

  /**
   * @description 经度标识符
   */
  LONGITUDE_IDENTIFIER = 'longitudeIdentifier',

  /**
   * @description 纬度标识符号
   */
  LATITUDE_IDENTIFIER = 'latitudeIdentifier',

  // EXTENSION_DESC = 'extensionDesc',
  // CALL_TYPE = 'callType',
}

const isTcpProfile = (transportType: string) => transportType === TransportTypeEnum.TCP;

const isControlComponent = (category?: string) => PackagesCategoryEnum.CONTROL === category;

const isBooleanComponent = (componentKeys: { categoryKey?: string; componentKey?: string }) => {
  const { categoryKey, componentKey } = componentKeys;
  return (
    categoryKey == 'OTHER' &&
    (componentKey == 'SwitchSignalLight' || componentKey == 'SwitchStatus')
  );
};

const getDeviceAttribute = async (params: DeviceAttributeParams) => {
  try {
    const data = await getDeviceAttributes(params);
    if (data) return data.map((item) => ({ ...item, label: item.name, value: item.identifier }));
  } catch (error) {}
  return [];
};

export const commonDataSourceSchemas = (): FormSchema[] => {
  const mode = useSelectWidgetMode();
  const isUpdate = unref(mode) === DataActionModeEnum.UPDATE;
  const selectWidgetKeys = useSelectWidgetKeys();
  const category = unref(selectWidgetKeys).categoryKey;

  return [
    {
      field: DataSourceField.DEVICE_TYPE,
      component: 'ApiSelect',
      label: '设备类型',
      colProps: { span: 8 },
      rules: [{ message: '请选择设备类型', required: true }],
      componentProps: ({ formActionType }) => {
        const { setFieldsValue } = formActionType;
        return {
          api: findDictItemByCode,
          params: {
            dictCode: 'device_type',
          },
          valueField: 'itemValue',
          labelField: 'itemText',
          placeholder: '请选择设备类型',
          onChange: () => {
            setFieldsValue({
              [DataSourceField.DEVICE_PROFILE_ID]: null,
              [DataSourceField.DEVICE_ID]: null,
              [DataSourceField.ATTRIBUTE]: null,
              [DataSourceField.TRANSPORT_TYPE]: null,
            });
          },
          getPopupContainer: () => document.body,
        };
      },
    },
    {
      field: DataSourceField.TRANSPORT_TYPE,
      label: '传输协议',
      component: 'Input',
      ifShow: false,
    },
    {
      field: DataSourceField.DEVICE_PROFILE_ID,
      component: 'ApiSelect',
      label: '产品',
      colProps: { span: 8 },
      rules: [{ required: true, message: '产品为必填项' }],
      componentProps: ({ formActionType, formModel }) => {
        const { setFieldsValue } = formActionType;
        const deviceType = formModel[DataSourceField.DEVICE_TYPE];
        return {
          api: async () => {
            if (!deviceType) return [];
            const list = await getDeviceProfile(deviceType);
            if (isUpdate) {
              const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
              const record = list.find((item) => item.id === deviceProfileId);
              setFieldsValue({ [DataSourceField.TRANSPORT_TYPE]: record?.transportType });
            }
            return list;
          },
          labelField: 'name',
          valueField: 'id',
          placeholder: '请选择产品',
          onChange: (_, option: Record<'transportType', string>) => {
            setFieldsValue({
              [DataSourceField.DEVICE_ID]: null,
              [DataSourceField.ATTRIBUTE]: null,
              [DataSourceField.TRANSPORT_TYPE]: option?.[DataSourceField.TRANSPORT_TYPE],
              [DataSourceField.COMMAND_TYPE]: null,
            });
          },
          getPopupContainer: () => document.body,
        };
      },
    },
    {
      field: DataSourceField.ORIGINATION_ID,
      component: 'OrgTreeSelect',
      label: '组织',
      colProps: { span: 8 },
      rules: [{ required: true, message: '组织为必填项' }],
      componentProps({ formActionType }) {
        const { setFieldsValue } = formActionType;
        return {
          placeholder: '请选择组织',
          onChange() {
            setFieldsValue({
              [DataSourceField.DEVICE_ID]: null,
            });
          },
          showCreate: false,
          apiTreeSelectProps: {
            params: { organizationId: location?.pathname?.split('/')?.pop() || '' },
          },
          getPopupContainer: () => document.body,
        };
      },
    },
    {
      field: DataSourceField.DEVICE_NAME,
      component: 'Input',
      label: '设备名称',
      ifShow: false,
    },
    {
      field: DataSourceField.DEVICE_ID,
      component: 'ApiSelect',
      label: '设备',
      colProps: { span: 8 },
      rules: [{ required: true, message: '设备名称为必填项' }],
      componentProps({ formModel, formActionType }) {
        const { setFieldsValue } = formActionType;
        const organizationId = formModel[DataSourceField.ORIGINATION_ID];
        const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
        const deviceType = formModel[DataSourceField.DEVICE_TYPE];

        return {
          api: async () => {
            if (organizationId) {
              try {
                const data = await getMeetTheConditionsDevice({
                  organizationId,
                  deviceProfileId,
                  deviceType,
                });
                if (data) {
                  const result = data.map((item) => ({
                    ...item,
                    label: item.alias || item.name,
                    value: item.tbDeviceId,
                    deviceType: item.deviceType,
                  }));

                  if (
                    unref(selectWidgetKeys).componentKey ===
                      ControlComponentEnum.LATERAL_NUMERICAL_CONTROL &&
                    isTcpProfile(formModel[DataSourceField.TRANSPORT_TYPE])
                  ) {
                    return result.filter((item) => item.codeType === TaskTypeEnum.MODBUS_RTU);
                  }

                  return result;
                }
              } catch (error) {}
            }
            return [];
          },
          onChange(_value, options: Record<'label' | 'codeType', string>) {
            setFieldsValue({
              [DataSourceField.COMMAND_TYPE]: null,
              [DataSourceField.DEVICE_NAME]: options?.label,
              [DataSourceField.CODE_TYPE]: options?.codeType,
            });
          },
          placeholder: '请选择设备',
          ...createPickerSearch(),
        };
      },
    },
    {
      field: DataSourceField.CODE_TYPE,
      label: '设备标识符类型',
      component: 'Input',
      ifShow: false,
    },
    {
      field: DataSourceField.ATTRIBUTE,
      component: 'ApiSelect',
      label: '属性',
      colProps: { span: 8 },
      rules: [{ required: true, message: '请选择属性' }],
      ifShow: () => category !== CategoryEnum.MAP,
      componentProps({ formModel, formActionType }) {
        const { setFieldsValue } = formActionType;
        const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
        return {
          api: async () => {
            try {
              if (deviceProfileId) {
                const option = await getDeviceAttribute({
                  deviceProfileId,
                  dataType:
                    (isControlComponent(category!) &&
                      unref(selectWidgetKeys).componentKey !==
                        ControlComponentEnum.LATERAL_NUMERICAL_CONTROL) ||
                    isBooleanComponent(unref(selectWidgetKeys))
                      ? DataTypeEnum.BOOL
                      : undefined,
                });

                // 选择控制组件4的时候只能选择属性且是（int double类型）
                if (
                  unref(selectWidgetKeys).componentKey ===
                  ControlComponentEnum.LATERAL_NUMERICAL_CONTROL
                ) {
                  setFieldsValue({
                    [DataSourceField.COMMAND_TYPE]: CommandTypeEnum.ATTRIBUTE.toString(),
                  });
                  return option.filter(
                    (item) =>
                      item.detail.dataType.type === DataTypeEnum.NUMBER_INT ||
                      item.detail.dataType.type == DataTypeEnum.NUMBER_DOUBLE
                  );
                }
                return option;
              }
            } catch (error) {}
            return [];
          },
          placeholder: '请选择属性',
          ...createPickerSearch(),
        };
      },
    },
    {
      field: DataSourceField.LONGITUDE_IDENTIFIER,
      label: '经度',
      component: 'ApiCascader',
      ifShow: ({}) => category === CategoryEnum.MAP,
      colProps: { span: 8 },
      changeEvent: 'update:value',
      valueField: 'value',
      componentProps: ({ formModel }) => {
        const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
        return {
          api: async () => {
            try {
              if (deviceProfileId) {
                const options = await getDeviceAttributes({
                  deviceProfileId,
                });

                const _options = options.map((item) => {
                  item = Object.assign(item, { functionName: item.name });
                  if (item.detail.dataType.type === DataTypeEnum.STRUCT) {
                    return Object.assign(item, { specs: item.detail.dataType.specs });
                  }
                  return item;
                });
                return _options;
              }
            } catch (error) {}
            return [];
          },
          placeholder: '请选择经度',
          getPopupContainer: () => document.body,
          fieldNames: { label: 'functionName', value: 'identifier', children: 'specs' },
        };
      },
    },
    {
      field: DataSourceField.LATITUDE_IDENTIFIER,
      label: '纬度',
      component: 'ApiCascader',
      ifShow: ({}) => category === CategoryEnum.MAP,
      colProps: { span: 8 },
      changeEvent: 'update:value',
      valueField: 'value',
      componentProps: ({ formModel }) => {
        const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];

        return {
          api: async () => {
            try {
              if (deviceProfileId) {
                const options = await getDeviceAttributes({
                  deviceProfileId,
                });

                const _options = options.map((item) => {
                  item = Object.assign(item, { functionName: item.name });

                  if (item.detail.dataType.type === DataTypeEnum.STRUCT) {
                    return Object.assign(item, { specs: item.detail.dataType.specs });
                  }
                  return item;
                });

                return _options;
              }
            } catch (error) {}
            return [];
          },
          placeholder: '请选择纬度',
          getPopupContainer: () => document.body,
          fieldNames: { label: 'functionName', value: 'identifier', children: 'specs' },
        };
      },
    },
    {
      field: DataSourceField.COMMAND_TYPE,
      component: 'Select',
      label: '命令类型',
      defaultValue: CommandTypeEnum.CUSTOM,
      rules: [
        {
          required: true,
          validator(_, value: number | string) {
            if (isNullOrUnDef(value)) return Promise.reject('请选择命令类型');
            return Promise.resolve();
          },
        },
      ],
      colProps: { span: 8 },
      ifShow: ({ model }) => {
        return (
          isControlComponent(category!) &&
          unref(selectWidgetKeys).componentKey !== ControlComponentEnum.LATERAL_NUMERICAL_CONTROL &&
          isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]) &&
          model[DataSourceField.CODE_TYPE] === TaskTypeEnum.CUSTOM
        );
      },
      componentProps: ({ formActionType, formModel }) => {
        const { setFieldsValue } = formActionType;
        const deviceType = formModel[DataSourceField.DEVICE_TYPE];
        const options: Record<'label' | 'value', string | number>[] = [
          { label: CommandTypeNameEnum.CUSTOM, value: CommandTypeEnum.CUSTOM },
        ];

        // 网关子设备无服务
        if (deviceType !== DeviceTypeEnum.SENSOR)
          options.push({ label: CommandTypeNameEnum.SERVICE, value: CommandTypeEnum.SERVICE });

        return {
          options,
          placeholder: '请选择命令类型',
          getPopupContainer: () => document.body,
          onChange() {
            setFieldsValue({
              [DataSourceField.OPEN_COMMAND]: null,
              [DataSourceField.CLOSE_COMMAND]: null,
              [DataSourceField.OPEN_SERVICE]: null,
              [DataSourceField.CLOSE_SERVICE]: null,
            });
          },
        };
      },
    },
    {
      field: DataSourceField.OPEN_SERVICE,
      component: 'ApiSelect',
      label: '开服务',
      colProps: { span: 8 },
      rules: [{ required: true, message: '请选择开服务' }],
      ifShow: ({ model }) =>
        isControlComponent(category!) &&
        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.SERVICE &&
        isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]),
      componentProps({ formModel }) {
        const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
        return {
          api: getModelServices,
          params: {
            deviceProfileId,
          },
          placeholder: '请选择开服务',
          labelField: 'functionName',
          valueField: 'identifier',
          getPopupContainer: () => document.body,
        };
      },
    },
    {
      field: DataSourceField.CLOSE_SERVICE,
      component: 'ApiSelect',
      label: '关服务',
      colProps: { span: 8 },
      rules: [{ required: true, message: '请选择关服务' }],
      ifShow: ({ model }) =>
        isControlComponent(category!) &&
        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.SERVICE &&
        isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]),
      componentProps({ formModel }) {
        const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
        return {
          api: getModelServices,
          params: {
            deviceProfileId,
          },
          placeholder: '请选择关服务',
          labelField: 'functionName',
          valueField: 'identifier',
          getPopupContainer: () => document.body,
        };
      },
    },
    {
      field: DataSourceField.OPEN_COMMAND,
      component: 'Input',
      label: '命令',
      colProps: { span: 8 },
      rules: [{ validator: validateTCPCustomCommand }],
      // 是控制组件  && 自定义命令  && 传输协议为TCP
      ifShow: ({ model }) =>
        isControlComponent(category!) &&
        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.CUSTOM &&
        model[DataSourceField.TRANSPORT_TYPE] &&
        isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]),
      componentProps: {
        placeholder: '请输入开下发命令',
      },
    },
    {
      field: DataSourceField.CLOSE_COMMAND,
      component: 'Input',
      label: '命令',
      colProps: { span: 8 },
      rules: [{ validator: validateTCPCustomCommand }],
      // 是控制组件  && 自定义命令  && 传输协议为TCP
      ifShow: ({ model }) =>
        isControlComponent(category!) &&
        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.CUSTOM &&
        model[DataSourceField.TRANSPORT_TYPE] &&
        isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]),
      componentProps: {
        placeholder: '请输入关下发命令',
      },
    },
    {
      field: DataSourceField.DEVICE_RENAME,
      component: 'Input',
      label: '设备名',
      colProps: { span: 8 },
      componentProps: {
        placeholder: '设备重命名',
      },
    },
    {
      field: DataSourceField.ATTRIBUTE_RENAME,
      component: 'Input',
      label: '属性',
      colProps: { span: 8 },
      componentProps: {
        placeholder: '属性重命名',
      },
    },
  ];
};