import { findDictItemByCode } from '/@/api/system/dict';
import { FormSchema, useComponentRegister } from '/@/components/Form';
import { DictEnum } from '/@/enums/dictEnum';
import { createPickerSearch } from '/@/utils/pickerSearch';
import { ControlGroup } from '../ControlGroup';
import { useI18n } from '/@/hooks/web/useI18n';

useComponentRegister('ControlGroup', ControlGroup);

export enum FormFieldsEnum {
  // 设备地址码
  DEVICE_CODE = 'deviceCode',
  // 功能码
  METHOD = 'method',
  // 寄存器地址
  REGISTER_ADDRESS = 'registerAddress',
  // 数据校验算法
  CRC = 'crc',
  // 线圈个数
  COIL_NUMBER = 'coilNumber',
  // 寄存器个数
  REGISTER_NUMBER = 'registerNumber',
  // 线圈值
  COIL_VALUE = 'coilValue',
  // 寄存器值
  REGISTER_VALUE = 'registerValue',
  // 线圈组值
  COIL_VALUES = 'coilValues',
  // 寄存器组值
  REGISTER_VALUES = 'registerValues',
}

export enum FunctionCodeEnum {
  // 读取线圈状态01
  READ_COIL_STATE_01 = '01',
  // 读取输入状态02
  READ_INPUT_STATE_02 = '02',
  // 读取保持寄存器
  READ_KEEP_REGISTER_03 = '03',
  // 读取输入寄存器
  READ_INPUT_REGISTER_04 = '04',
  // 写入耽搁线圈寄存器
  WRITE_SINGLE_COIL_REGISTER_05 = '05',
  // 写入单个保持寄存器
  WRITE_SINGLE_KEEP_COIL_REGISTER_06 = '06',
  // 写入多个线圈状态
  WRITE_MULTIPLE_COIL_STATE_15 = '15',
  // 写入多个保持寄存器
  WRITE_MULTIPLE_KEEP_REGISTER_16 = '16',
}

export enum CRCValidTypeEnum {
  CRC_32_HIGH = 'CRC_32_HIGH',
  CRC_32_LOWER = 'CRC_32_LOWER',
  AND_TOTAL_XOR = 'AND_TOTAL_XOR',
  TOTAL_AND_SUM = 'TOTAL_AND_SUM',
  CRC_8 = 'CRC_8',
  CRC_16_HIGH = 'CRC_16_HIGH',
  CRC_16_LOWER = 'CRC_16_LOWER',
}

export const showCoilNumber = (value: FunctionCodeEnum) =>
  [
    FunctionCodeEnum.READ_COIL_STATE_01,
    FunctionCodeEnum.READ_INPUT_STATE_02,
    FunctionCodeEnum.WRITE_MULTIPLE_COIL_STATE_15,
  ].includes(value);

export const showRegisterNumber = (value: FunctionCodeEnum) =>
  [
    FunctionCodeEnum.READ_KEEP_REGISTER_03,
    FunctionCodeEnum.READ_INPUT_REGISTER_04,
    FunctionCodeEnum.WRITE_MULTIPLE_KEEP_REGISTER_16,
  ].includes(value);

export const showCoilValue = (value: FunctionCodeEnum) =>
  [FunctionCodeEnum.WRITE_SINGLE_COIL_REGISTER_05].includes(value);

export const showRegisterValue = (value: FunctionCodeEnum) =>
  [FunctionCodeEnum.WRITE_SINGLE_KEEP_COIL_REGISTER_06].includes(value);

export const isWriteCoilGroup = (value: FunctionCodeEnum) =>
  [FunctionCodeEnum.WRITE_MULTIPLE_COIL_STATE_15].includes(value);

export const isWriteRegisterGroup = (value: FunctionCodeEnum) =>
  [FunctionCodeEnum.WRITE_MULTIPLE_KEEP_REGISTER_16].includes(value);

const { t } = useI18n();
export const formSchemas: FormSchema[] = [
  {
    field: FormFieldsEnum.DEVICE_CODE,
    component: 'ApiSelect',
    label: t('taskCenter.task.modbus.slaveAddress'),
    rules: [{ required: true }],
    defaultValue: '01',
    componentProps: () => {
      return {
        api: async (params: Recordable) => {
          try {
            const result = await findDictItemByCode(params);
            return result.map((item, index) => ({
              ...item,
              itemText: `${index + 1} - ${item.itemText}`,
            }));
          } catch (error) {
            return [];
          }
        },
        params: {
          dictCode: DictEnum.SLAVE_ADDRESS,
        },
        labelField: 'itemText',
        valueField: 'itemValue',
        ...createPickerSearch(),
        getPopupContainer: () => document.body,
      };
    },
  },
  {
    field: FormFieldsEnum.METHOD,
    component: 'ApiSelect',
    label: t('taskCenter.task.modbus.functionCode'),
    defaultValue: '01',
    rules: [{ required: true }],
    componentProps: () => {
      return {
        api: findDictItemByCode,
        params: {
          dictCode: DictEnum.FUNCTION_CODE,
        },
        labelField: 'itemText',
        valueField: 'itemValue',
        getPopupContainer: () => document.body,
      };
    },
  },
  {
    field: FormFieldsEnum.REGISTER_ADDRESS,
    label: t('taskCenter.task.modbus.registerAddress'),
    component: 'RegisterAddressInput',
    valueField: 'value',
    changeEvent: 'update:value',
    defaultValue: 0,
  },
  {
    field: FormFieldsEnum.REGISTER_NUMBER,
    label: t('taskCenter.task.modbus.registerNumber'),
    component: 'InputNumber',
    ifShow: ({ model }) => showRegisterNumber(model[FormFieldsEnum.METHOD]),
    defaultValue: 1,
    rules: [{ required: true }],
    componentProps: {
      min: 1,
      max: 64,
      step: 1,
    },
  },
  {
    field: FormFieldsEnum.COIL_NUMBER,
    label: t('taskCenter.task.modbus.coilsNumber'),
    component: 'InputNumber',
    ifShow: ({ model }) => showCoilNumber(model[FormFieldsEnum.METHOD]),
    defaultValue: 1,
    rules: [{ required: true }],
    componentProps: {
      min: 1,
      max: 64,
      step: 1,
    },
  },
  {
    field: FormFieldsEnum.COIL_VALUE,
    label: t('taskCenter.task.modbus.coilsValue'),
    component: 'RegisterAddressInput',
    valueField: 'value',
    changeEvent: 'update:value',
    ifShow: ({ model }) => showCoilValue(model[FormFieldsEnum.METHOD]),
    defaultValue: '0',
    rules: [{ required: true, type: 'number' }],
  },
  {
    field: FormFieldsEnum.REGISTER_VALUE,
    label: t('taskCenter.task.modbus.registerValue'),
    component: 'RegisterAddressInput',
    valueField: 'value',
    changeEvent: 'update:value',
    ifShow: ({ model }) => showRegisterValue(model[FormFieldsEnum.METHOD]),
    defaultValue: '0',
    rules: [{ required: true, type: 'number' }],
  },
  {
    field: FormFieldsEnum.REGISTER_VALUES,
    label: '',
    component: 'ControlGroup',
    colProps: { span: 24 },
    valueField: 'value',
    changeEvent: 'update:value',
    ifShow: ({ model }) => isWriteRegisterGroup(model[FormFieldsEnum.METHOD]),
    componentProps: ({ formModel }) => {
      const length = formModel[FormFieldsEnum.REGISTER_NUMBER];
      return {
        length: length || 1,
        itemColProps: { span: 12, style: { paddingRight: '10px' } },
        component: 'RegisterAddressInput',
        itemLabel: (index: number) => `#${index} t('taskCenter.task.modbus.registerValue')`,
        showTotalControl: false,
        itemProps: () => {
          return {
            required: true,
            valueField: 'value',
            changeEvent: 'update:value',
          } as FormSchema;
        },
      };
    },
  },
  {
    field: FormFieldsEnum.COIL_VALUES,
    label: '',
    component: 'ControlGroup',
    colProps: { span: 24 },
    valueField: 'value',
    changeEvent: 'update:value',
    ifShow: ({ model }) => isWriteCoilGroup(model[FormFieldsEnum.METHOD]),
    componentProps: ({ formModel }) => {
      const length = formModel[FormFieldsEnum.COIL_NUMBER];
      return {
        length: length || 1,
        itemColProps: { span: 6 },
        itemLabel: (index: number) => `#${index} t('taskCenter.task.modbus.')coilsStatusValue`,
        itemProps: (index: number) => {
          return {
            defaultValue: 0,
            helpMessage: [
              `t('taskCenter.task.modbus.setStart) ${index} t('taskCenter.task.modbus.setswitchState)`,
            ],
          } as FormSchema;
        },
        totalControlProps: {
          label: t('taskCenter.task.modbus.openOrClose'),
          helpMessage: [t('taskCenter.task.modbus.totalMessage')],
          colProps: { span: 24 },
        } as FormSchema,
      };
    },
  },
  {
    field: FormFieldsEnum.CRC,
    label: t('taskCenter.task.modbus.dataCheck'),
    component: 'ApiSelect',
    colProps: { span: 24 },
    rules: [{ required: true }],
    defaultValue: CRCValidTypeEnum.CRC_16_LOWER,
    componentProps: () => {
      return {
        api: findDictItemByCode,
        params: {
          dictCode: DictEnum.DATA_VALIDATE,
        },
        labelField: 'itemText',
        valueField: 'itemValue',
        placeholder: t('taskCenter.task.modbus.dataMethod'),
        getPopupContainer: () => document.body,
      };
    },
  },
];