import { FormSchema } from '/@/components/Form';
import { findDictItemByCode } from '/@/api/system/dict';
import { BasicInfoFormField, DataSourceType } from '../enum';
import { DeviceRecord } from '/@/api/device/model/deviceModel';
import { useMessage } from '/@/hooks/web/useMessage';
import { doQueryRuleChainList, doQueryDeviceProfileList } from '/@/api/device/deviceConfigApi';
import { RuleChainRecord } from '/@/api/device/model/deviceConfigModel';
import { useI18n } from '/@/hooks/web/useI18n';

const { t } = useI18n(); // 加载国际化

export const stepConfig = [
  t('rule.dataflow.index.chooseCirculationMethod'),
  t('rule.dataflow.index.improveConfigurationParameters'),
];

export const removeFieldByModeForm = ['name', 'description'];

const handleGroupDevice = (options: DeviceRecord[]) => {
  const map = new Map<string, string[]>();
  options.forEach((item) => {
    if (map.has(item.profileId)) {
      const deviceList = map.get(item.profileId)!;
      deviceList.push(item.tbDeviceId);
    } else {
      map.set(item.profileId, [item.tbDeviceId]);
    }
  });
  const value = Array.from(map.entries()).map(([product, devices]) => ({ product, devices }));

  return value;
};

//表单通用配置
export const modelFormPublicConfig = {
  labelWidth: 120,
  actionColOptions: {
    span: 14,
  },
  showResetButton: false,
  showSubmitButton: false,
};

const { createMessage } = useMessage();
export const modeForm = (disabled: boolean): FormSchema[] => {
  return [
    {
      field: BasicInfoFormField.CONVERT_CONFIG_ID,
      label: '',
      component: 'Input',
      show: false,
    },
    {
      field: BasicInfoFormField.DATA_SOURCE_TYPE,
      label: t('rule.dataflow.index.datasourceType'),
      component: 'RadioGroup',
      defaultValue: DataSourceType.ALL,
      componentProps: {
        options: [
          { label: t('rule.dataflow.index.all'), value: DataSourceType.ALL },
          { label: t('rule.dataflow.index.product'), value: DataSourceType.PRODUCT },
          { label: t('rule.dataflow.index.device'), value: DataSourceType.DEVICE },
        ],
      },
    },
    {
      field: BasicInfoFormField.RULE_CHAIN_ID,
      label: t('deviceManagement.product.ruleChainText'),
      component: 'ApiSelect',
      required: true,
      componentProps: ({ formModel, formActionType: { setFieldsValue } }) => {
        return {
          api: async () => {
            const res = await doQueryRuleChainList();
            return res.map((item) => ({ ...item, label: item.name, value: item.id.id }));
          },
          placeholder: t('common.chooseText') + t('deviceManagement.product.ruleChainText'),
          onChange() {
            setFieldsValue({
              [BasicInfoFormField.DATA_SOURCE_PRODUCT]: [],
              [BasicInfoFormField.DATA_SOURCE_DEVICE]: [],
            });
          },
          onOptionsChange(options: (RuleChainRecord & Record<'label' | 'value', string>)[]) {
            if (formModel[BasicInfoFormField.RULE_CHAIN_ID]) return;

            const root = options.find((item) => item.root);
            root && setFieldsValue({ [BasicInfoFormField.RULE_CHAIN_ID]: root.value });
          },
        };
      },
    },
    {
      field: BasicInfoFormField.DATA_SOURCE_PRODUCT,
      label: t('rule.dataflow.index.datasourceProduct'),
      component: 'TransferModal',
      rules: [
        {
          required: true,
          message: t('rule.dataflow.index.dataSourceProductIsAMandatoryOption'),
          type: 'array',
        },
      ],
      ifShow: ({ model }) => {
        return model[BasicInfoFormField.DATA_SOURCE_TYPE] !== DataSourceType.ALL;
      },
      valueField: 'value',
      changeEvent: 'update:value',
      componentProps: ({ formActionType, formModel }) => {
        const { setFieldsValue } = formActionType;
        return {
          api: doQueryDeviceProfileList,
          labelField: 'name',
          valueField: 'tbProfileId',
          disabled,
          selectProps: {
            disabled,
            placeholder: t('rule.dataflow.index.pleaseSelectProduct'),
          },
          params: {
            ruleChainId: formModel[BasicInfoFormField.RULE_CHAIN_ID],
          },
          transferProps: {
            listStyle: { height: '400px' },
            showSearch: true,
            filterOption: (inputValue: string, option: Recordable) => {
              const upperCaseInputValue = inputValue.toUpperCase();
              const upperCaseOptionValue = option.name.toUpperCase();
              return upperCaseOptionValue.includes(upperCaseInputValue);
            },
          },
          onChange: () => {
            setFieldsValue({
              [BasicInfoFormField.DATA_SOURCE_DEVICE]: [],
              [BasicInfoFormField.CONVERT_CONFIG_ID]: null,
            });
          },
        };
      },
    },
    {
      field: BasicInfoFormField.DATA_SOURCE_DEVICE,
      label: t('rule.dataflow.index.datasourceDevice'),
      component: 'TransferTableModal',
      ifShow: ({ model }) => {
        return model[BasicInfoFormField.DATA_SOURCE_TYPE] === DataSourceType.DEVICE;
      },
      valueField: 'value',
      changeEvent: 'update:value',
      rules: [
        {
          required: true,
          message: t('rule.dataflow.index.dataSourceDeviceIsAMandatoryOption'),
          type: 'array',
        },
      ],
      componentProps: ({ formModel }) => {
        const convertConfigId = formModel[BasicInfoFormField.CONVERT_CONFIG_ID];
        const deviceProfileIds = formModel[BasicInfoFormField.DATA_SOURCE_PRODUCT];
        const organizationId = formModel[BasicInfoFormField.ORGANIZATION_ID];
        return {
          disabled,
          params: { convertConfigId, deviceProfileIds, organizationId },
          transformValue: handleGroupDevice,
          openModalValidate: () => {
            if (!deviceProfileIds || !deviceProfileIds?.length) {
              createMessage.warning(t('rule.dataflow.index.pleaseSelectDevice'));
            }
            return deviceProfileIds && deviceProfileIds?.length;
          },
        };
      },
    },
    {
      field: 'type',
      label: t('rule.dataflow.index.conversionMethod'),
      component: 'ApiSelect',
      required: true,
      colProps: {
        span: 24,
      },
      componentProps({}) {
        return {
          api: findDictItemByCode,
          params: {
            dictCode: 'convert_data_to',
          },
          labelField: 'itemText',
          valueField: 'itemValue',
        };
      },
    },
    {
      field: 'remark',
      label: t('rule.dataflow.index.remark'),
      colProps: { span: 24 },
      component: 'Input',
      componentProps: {
        maxLength: 255,
        placeholder: t('rule.dataflow.index.pleaseEnterDescription'),
      },
    },
  ];
};