import { FormSchema } from '/@/components/Table';
import {
  ExtendDescOperationTypeEnum,
  ExtendDescOperationTypeNameEnum,
  OriginalDataTypeEnum,
  OriginalDataTypeNameEnum,
} from '/@/enums/objectModelEnum';
import { validateValueRange } from '../DataTypeForm/config';
import { useComponentRegister } from '/@/components/Form';
import { HexInput, InputTypeEnum } from '../HexInput';
import { isFloatType } from './useParseOperationType';
import { useObjectModelFormContext } from '../useObjectModelFormContext';
import { unref } from 'vue';
import { DataActionModeEnum } from '/@/enums/toolEnum';

useComponentRegister('HexInput', HexInput);

export enum FormFieldsEnum {
  ACTION_TYPE = 'actionType',
  ZOOM_FACTOR = 'zoomFactor',

  OBJECT_MODEL_TYPE = 'objectModelType',

  ORIGINAL_DATA_TYPE = 'originalDataType',
  REGISTER_ADDRESS = 'registerAddress',
  OPERATION_TYPE = 'operationType',
  VALUE_RANGE = 'valueRange',
  SCALING = 'scaling',
  BIT_MASK = 'bitMask',

  REGISTER_COUNT = 'registerCount',

  VALUE_MAPPING = 'valueMapping',
}

export enum FormFieldsNameEnum {
  ORIGINAL_DATA_TYPE = '数据类型',
  REGISTER_ADDRESS = '寄存器地址',
  OPERATION_TYPE = '操作类型',
  VALUE_RANGE = '取值范围',
  SCALING = '缩放因子',
  BIT_MASK = '比特位置',

  REGISTER_COUNT = '寄存器个数',
  VALUE_MAPPING = '值映射',
}

export const BOOL_DEFAULT_VALUE_RANGE = { min: 0, max: 1 };

export const INT16_VALUE_RANGE = {
  min: -(2 ** 15),
  max: 2 ** 15 - 1,
};

export const UINT16_VALUE_RANGE = {
  min: 0,
  max: 2 ** 16 - 1,
};

export const INT32_VALUE_RANGE = {
  min: -(2 ** 31),
  max: 2 ** 31 - 1,
};

export const UINT32_VALUE_RANGE = {
  min: 0,
  max: 2 ** 32 - 1,
};

function getValueRangeFromOriginDataType(
  originalDataType?: OriginalDataTypeEnum
): Record<'min' | 'max', number> {
  switch (originalDataType) {
    case OriginalDataTypeEnum.BOOLEAN:
    case OriginalDataTypeEnum.BITS:
      return BOOL_DEFAULT_VALUE_RANGE;

    case OriginalDataTypeEnum.INT16_AB:
    case OriginalDataTypeEnum.INT16_BA:
      return INT16_VALUE_RANGE;

    case OriginalDataTypeEnum.UINT16_AB:
    case OriginalDataTypeEnum.UINT16_BA:
      return UINT16_VALUE_RANGE;

    case OriginalDataTypeEnum.INT32_AB_CD:
    case OriginalDataTypeEnum.INT32_BA_DC:
    case OriginalDataTypeEnum.INT32_CD_AB:
    case OriginalDataTypeEnum.INT32_DC_BA:
      return INT32_VALUE_RANGE;

    case OriginalDataTypeEnum.UINT32_AB_CD:
    case OriginalDataTypeEnum.UINT32_BA_DC:
    case OriginalDataTypeEnum.UINT32_CD_AB:
    case OriginalDataTypeEnum.UINT32_DC_BA:
      return UINT32_VALUE_RANGE;

    default:
      return INT32_VALUE_RANGE;
  }
}

const BOOL_OPERATION_TYPE = [
  ExtendDescOperationTypeEnum.INPUT_STATUS_R_02,
  ExtendDescOperationTypeEnum.COIL_STATUS_R_01,
  ExtendDescOperationTypeEnum.COIL_STATUS_RW_01_05,
  ExtendDescOperationTypeEnum.COIL_STATUS_RW_01_0F,
  ExtendDescOperationTypeEnum.COIL_STATUS_W_05,
  ExtendDescOperationTypeEnum.COIL_STATUS_W_0F,
];

function getOriginalDataTypeByOperationType(
  operationType: ExtendDescOperationTypeEnum
): Record<'label' | 'value', string>[] {
  switch (operationType) {
    case ExtendDescOperationTypeEnum.INPUT_STATUS_R_02:
    case ExtendDescOperationTypeEnum.COIL_STATUS_R_01:
    case ExtendDescOperationTypeEnum.COIL_STATUS_RW_01_05:
    case ExtendDescOperationTypeEnum.COIL_STATUS_RW_01_0F:
    case ExtendDescOperationTypeEnum.COIL_STATUS_W_05:
    case ExtendDescOperationTypeEnum.COIL_STATUS_W_0F:
      return [{ label: OriginalDataTypeNameEnum.BOOLEAN, value: OriginalDataTypeEnum.BOOLEAN }];

    case ExtendDescOperationTypeEnum.HOLDING_REGISTER_RW_03_06:
    case ExtendDescOperationTypeEnum.HOLDING_REGISTER_W_06:
      return [
        { label: OriginalDataTypeNameEnum.INT16_AB, value: OriginalDataTypeEnum.INT16_AB },
        { label: OriginalDataTypeNameEnum.INT16_BA, value: OriginalDataTypeEnum.INT16_BA },
        { label: OriginalDataTypeNameEnum.UINT16_AB, value: OriginalDataTypeEnum.UINT16_AB },
        { label: OriginalDataTypeNameEnum.UINT16_BA, value: OriginalDataTypeEnum.UINT16_BA },
        { label: OriginalDataTypeNameEnum.BITS, value: OriginalDataTypeEnum.BITS },
        { label: OriginalDataTypeNameEnum.BOOLEAN, value: OriginalDataTypeEnum.BOOLEAN },
      ];

    case ExtendDescOperationTypeEnum.HOLDING_REGISTER_RW_03_10:
    case ExtendDescOperationTypeEnum.HOLDING_REGISTER_W_10:
    case ExtendDescOperationTypeEnum.HOLDING_REGISTER_R_03:
    case ExtendDescOperationTypeEnum.INPUT_REGISTER_R_04:
      return Object.keys(OriginalDataTypeEnum).map((key) => ({
        label: OriginalDataTypeNameEnum[key],
        value: OriginalDataTypeEnum[key],
      }));
  }
}

export const getExtendDescFormSchemas = (): FormSchema[] => {
  const DEFAULT_OPERATION_TYPE = ExtendDescOperationTypeEnum.INPUT_STATUS_R_02;
  const DEFAULT_ORIGINAL_TYPE = OriginalDataTypeEnum.BOOLEAN;
  return [
    {
      field: FormFieldsEnum.OPERATION_TYPE,
      label: FormFieldsNameEnum.OPERATION_TYPE,
      component: 'Select',
      required: true,
      defaultValue: DEFAULT_OPERATION_TYPE,
      componentProps: ({ formActionType }) => {
        return {
          options: Object.keys(ExtendDescOperationTypeEnum).map((key) => ({
            label: ExtendDescOperationTypeNameEnum[key],
            value: ExtendDescOperationTypeEnum[key],
          })),
          labelField: 'itemText',
          valueField: 'itemValue',
          getPopupContainer: () => document.body,
          placeholder: '请选择操作类型',
          allowClear: false,
          onChange(value: ExtendDescOperationTypeEnum) {
            const isBoolTypeOperationType = BOOL_OPERATION_TYPE.includes(value);
            const originalDataType = isBoolTypeOperationType
              ? OriginalDataTypeEnum.BOOLEAN
              : OriginalDataTypeEnum.INT16_AB;

            formActionType.setFieldsValue({
              [FormFieldsEnum.ORIGINAL_DATA_TYPE]: originalDataType,
              [FormFieldsEnum.VALUE_RANGE]: isBoolTypeOperationType
                ? BOOL_DEFAULT_VALUE_RANGE
                : INT16_VALUE_RANGE,
            });
          },
        };
      },
    },
    {
      field: FormFieldsEnum.REGISTER_ADDRESS,
      label: FormFieldsNameEnum.REGISTER_ADDRESS,
      component: 'HexInput',
      changeEvent: 'update:value',
      valueField: 'value',
      helpMessage: ['范围在 0x0-0xFFFF'],
      rules: [{ message: '请输入寄存器地址', required: true }],
      componentProps: {
        placeholder: '请输入寄存器地址',
        type: InputTypeEnum.HEX,
        maxValue: parseInt('0xFFFF', 16),
      },
    },
    {
      field: FormFieldsEnum.ORIGINAL_DATA_TYPE,
      label: FormFieldsNameEnum.ORIGINAL_DATA_TYPE,
      component: 'Select',
      required: true,
      defaultValue: DEFAULT_ORIGINAL_TYPE,
      dynamicDisabled: ({ model }) =>
        BOOL_OPERATION_TYPE.includes(model[FormFieldsEnum.OPERATION_TYPE]) ||
        unref(useObjectModelFormContext().getModalMode) === DataActionModeEnum.READ,
      componentProps: ({ formActionType, formModel }) => {
        const operationType = formModel[FormFieldsEnum.OPERATION_TYPE];

        return {
          options: getOriginalDataTypeByOperationType(operationType),
          labelField: 'itemText',
          valueField: 'itemValue',
          placeholder: '请选择数据类型',
          getPopupContainer: () => document.body,
          onChange(value: OriginalDataTypeEnum) {
            const { setFieldsValue } = formActionType;
            setFieldsValue({
              [FormFieldsEnum.VALUE_RANGE]: getValueRangeFromOriginDataType(
                value as OriginalDataTypeEnum
              ),
            });
          },
        };
      },
    },
    {
      field: FormFieldsEnum.BIT_MASK,
      label: FormFieldsNameEnum.BIT_MASK,
      component: 'Select',
      ifShow: ({ model }) => model[FormFieldsEnum.ORIGINAL_DATA_TYPE] === OriginalDataTypeEnum.BITS,
      required: true,
      defaultValue: 7,
      componentProps: () => {
        return {
          options: Array.from({ length: 16 }, (_, index) => ({
            label: `${index}`,
            value: index,
          })),
          allowClear: false,
          getPopupContainer: () => document.body,
        };
      },
    },
    {
      field: FormFieldsEnum.VALUE_RANGE,
      label: FormFieldsNameEnum.VALUE_RANGE,
      component: 'CustomMinMaxInput',
      rules: [{ required: true, validator: validateValueRange }],
      changeEvent: 'update:value',
      valueField: 'value',
      defaultValue: BOOL_DEFAULT_VALUE_RANGE,
      helpMessage: [
        '取值范围指的是原始数据经过缩放因子处理之后的取值范围，超出取值范围的数据会被丢弃。',
      ],
      ifShow: ({ model }) =>
        model[FormFieldsEnum.ORIGINAL_DATA_TYPE] !== OriginalDataTypeEnum.STRING,
      componentProps: ({ formModel }) => {
        const originalDataType = formModel[FormFieldsEnum.ORIGINAL_DATA_TYPE];

        const { min, max } = getValueRangeFromOriginDataType(
          originalDataType as OriginalDataTypeEnum
        );

        const flag = isFloatType(originalDataType);

        return {
          minInputProps: {
            precision: 0,
            min: flag ? undefined : min,
            max: flag ? undefined : max,
          },
          maxInputProps: {
            precision: 0,
            min: flag ? undefined : min,
            max: flag ? undefined : max,
          },
        };
      },
    },

    {
      field: FormFieldsEnum.SCALING,
      label: FormFieldsNameEnum.SCALING,
      component: 'InputNumber',
      required: true,
      defaultValue: 1,
      helpMessage: ['缩放因子，不能为 0，默认为 1'],
      ifShow: ({ model }) =>
        ![OriginalDataTypeEnum.STRING, OriginalDataTypeEnum.BOOLEAN].includes(
          model[FormFieldsEnum.ORIGINAL_DATA_TYPE]
        ),
      rules: [
        {
          validator: (_rule, value: any) => {
            if (Number(value) > 0) return Promise.resolve();
            return Promise.reject(Error('缩放因子不能为0'));
          },
        },
      ],
      componentProps: () => {},
    },
    {
      field: FormFieldsEnum.REGISTER_COUNT,
      label: FormFieldsNameEnum.REGISTER_COUNT,
      component: 'InputNumber',
      helpMessage: ['操作类型为保持寄存器/输入寄存器时限制为1~125'],
      ifShow: ({ model }) =>
        model[FormFieldsEnum.ORIGINAL_DATA_TYPE] === OriginalDataTypeEnum.STRING,
      required: true,
      componentProps: () => {
        return {
          placeholder: '请输入寄存器个数',
          min: 1,
          max: 125,
          precision: 0,
        };
      },
    },
    {
      field: FormFieldsEnum.VALUE_MAPPING,
      component: 'Input',
      label: FormFieldsNameEnum.VALUE_MAPPING,
      slot: FormFieldsEnum.VALUE_MAPPING,
      defaultValue: [
        { value: 0, name: '关' },
        { value: 1, name: '开' },
      ],
      ifShow: ({ model }) =>
        [OriginalDataTypeEnum.BOOLEAN, OriginalDataTypeEnum.BITS].includes(
          model[FormFieldsEnum.ORIGINAL_DATA_TYPE]
        ),
    },
  ];
};