import { getAllDeviceByOrg, getDeviceAttributes, getGatewaySlaveDevice } from '/@/api/dataBoard';
import { getOrganizationList } from '/@/api/system/system';
import { FormSchema } from '/@/components/Form';
import { copyTransFun } from '/@/utils/fnUtils';

export enum BasicConfigField {
  NAME = 'name',
  REMARK = 'remark',
}

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

export enum DataSourceField {
  IS_GATEWAY_DEVICE = 'gatewayDevice',
  ORIGINATION_ID = 'organizationId',
  DEVICE_ID = 'deviceId',
  SLAVE_DEVICE_ID = 'slaveDeviceId',
  ATTRIBUTE = 'attribute',
  ATTRIBUTE_RENAME = 'attributeRename',
  DEVICE_NAME = 'deviceName',
  DEVICE_RENAME = 'deviceRename',
}

export const basicSchema: FormSchema[] = [
  {
    field: BasicConfigField.NAME,
    label: '组件名称',
    component: 'Input',
    rules: [{ required: true, message: '组件名称为必填项' }],
    componentProps: {
      placeholder: '请输入组件名称',
    },
  },
  {
    field: BasicConfigField.REMARK,
    label: '组件备注',
    component: 'InputTextArea',
    // rules: [{ required: true, message: '组件备注为必填项' }],
    componentProps: {
      placeholder: '请输入组件备注',
    },
  },
];

export const dataSourceSchema: FormSchema[] = [
  {
    field: DataSourceField.IS_GATEWAY_DEVICE,
    component: 'Switch',
    label: '是否是网关设备',
    show: false,
  },
  {
    field: DataSourceField.DEVICE_NAME,
    component: 'Input',
    label: '设备名',
    show: false,
  },
  {
    field: DataSourceField.ORIGINATION_ID,
    component: 'ApiTreeSelect',
    label: '组织',
    colProps: { span: 8 },
    rules: [{ required: true, message: '组织为必填项' }],
    componentProps({ formActionType }) {
      const { setFieldsValue } = formActionType;
      return {
        placeholder: '请选择组织',
        api: async () => {
          const data = await getOrganizationList();
          copyTransFun(data as any as any[]);
          return data;
        },
        onChange() {
          setFieldsValue({
            [DataSourceField.DEVICE_ID]: null,
            [DataSourceField.ATTRIBUTE]: null,
            [DataSourceField.SLAVE_DEVICE_ID]: null,
            [DataSourceField.IS_GATEWAY_DEVICE]: false,
          });
        },
        getPopupContainer: () => document.body,
      };
    },
  },
  {
    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];
      return {
        api: async () => {
          if (organizationId) {
            try {
              const data = await getAllDeviceByOrg(organizationId);
              if (data)
                return data.map((item) => ({
                  label: item.name,
                  value: item.id,
                  deviceType: item.deviceType,
                }));
            } catch (error) {}
          }
          return [];
        },
        onChange(_value, record: Record<'value' | 'label' | 'deviceType', string>) {
          setFieldsValue({
            [DataSourceField.ATTRIBUTE]: null,
            [DataSourceField.IS_GATEWAY_DEVICE]: record?.deviceType === 'GATEWAY',
            [DataSourceField.SLAVE_DEVICE_ID]: null,
            [DataSourceField.DEVICE_NAME]: record?.label,
          });
        },
        placeholder: '请选择设备',
        getPopupContainer: () => document.body,
      };
    },
  },
  {
    field: DataSourceField.SLAVE_DEVICE_ID,
    label: '网关子设备',
    component: 'ApiSelect',
    colProps: { span: 8 },
    rules: [{ required: true, message: '网关子设备为必填项' }],
    ifShow({ model }) {
      return model[DataSourceField.IS_GATEWAY_DEVICE];
    },
    dynamicRules({ model }) {
      return [{ required: model[DataSourceField.IS_GATEWAY_DEVICE], message: '请选择网关子设备' }];
    },
    componentProps({ formModel, formActionType }) {
      const { setFieldsValue } = formActionType;
      const organizationId = formModel[DataSourceField.ORIGINATION_ID];
      const isGatewayDevice = formModel[DataSourceField.IS_GATEWAY_DEVICE];
      const deviceId = formModel[DataSourceField.DEVICE_ID];
      return {
        api: async () => {
          if (organizationId && isGatewayDevice) {
            try {
              const data = await getGatewaySlaveDevice({ organizationId, masterId: deviceId });
              if (data)
                return data.map((item) => ({
                  label: item.name,
                  value: item.id,
                  deviceType: item.deviceType,
                }));
            } catch (error) {}
          }
          return [];
        },
        onChange(_value, record: Record<'value' | 'label' | 'deviceType', string>) {
          setFieldsValue({
            [DataSourceField.ATTRIBUTE]: null,
            [DataSourceField.DEVICE_NAME]: record?.label,
          });
        },
        placeholder: '请选择网关子设备',
        getPopupContainer: () => document.body,
      };
    },
  },
  {
    field: DataSourceField.ATTRIBUTE,
    component: 'ApiSelect',
    label: '属性',
    colProps: { span: 8 },
    rules: [{ required: true, message: '属性为必填项' }],
    componentProps({ formModel }) {
      const organizationId = formModel[DataSourceField.ORIGINATION_ID];
      const isGatewayDevice = formModel[DataSourceField.IS_GATEWAY_DEVICE];
      const deviceId = formModel[DataSourceField.DEVICE_ID];
      const slaveDeviceId = formModel[DataSourceField.SLAVE_DEVICE_ID];
      return {
        api: async () => {
          if (organizationId && deviceId) {
            try {
              if (isGatewayDevice && slaveDeviceId) {
                return await getDeviceAttribute(slaveDeviceId);
              }
              if (!isGatewayDevice) {
                return await getDeviceAttribute(deviceId);
              }
            } catch (error) {}
          }
          return [];
        },
        placeholder: '请选择属性',
        getPopupContainer: () => document.body,
      };
    },
  },
  {
    field: DataSourceField.DEVICE_RENAME,
    component: 'Input',
    label: '设备',
    colProps: { span: 8 },
    componentProps: {
      placeholder: '设备重命名',
    },
  },
  {
    field: DataSourceField.ATTRIBUTE_RENAME,
    component: 'Input',
    label: '属性',
    colProps: { span: 8 },
    componentProps: {
      placeholder: '属性重命名',
    },
  },
];