import { ScriptSelectItem } from './components';
import { findDictItemByCode } from '/@/api/system/dict';
import { FormSchema, useComponentRegister } from '/@/components/Form';
import CustomMinMaxInput from '/@/components/Form/src/components/CustomMinMaxInput.vue';
import {
  TCPProtocolAccessAuthTypeEnum,
  TCPProtocolTypeEnum,
  TransportTypeEnum,
} from '/@/enums/deviceEnum';
import { useI18n } from '/@/hooks/web/useI18n';
import { isNullOrUnDef } from '/@/utils/is';
import { ScriptTypeEnum } from '/@/views/rule/script/TcpConversionScript/config';

useComponentRegister('CustomMinMaxInput', CustomMinMaxInput);
useComponentRegister('ScriptSelectItem' as 'Input', ScriptSelectItem);

export enum FormFieldsEnum {
  UpScriptId = 'upScriptId',
  Protocol = 'protocol',
  AuthType = 'tcpAuthType',
  HexLength = 'hexLength',
  SplitRang = 'splitRange',
  FilterPrefix = 'filterPrefix',
  SubEndIndex = 'subEndIndex',
  SubBeginIndex = 'subBeginIndex',
}

export interface FormFieldsValueType {
  [FormFieldsEnum.FilterPrefix]?: string;
  [FormFieldsEnum.HexLength]?: number;
  [FormFieldsEnum.Protocol]: TCPProtocolTypeEnum;
  [FormFieldsEnum.AuthType]: TCPProtocolAccessAuthTypeEnum;
  [FormFieldsEnum.UpScriptId]?: string;
  [FormFieldsEnum.SplitRang]: {
    [FormFieldsEnum.SubBeginIndex]: number;
    [FormFieldsEnum.SubEndIndex]: number;
  };
}

export interface TCPConfigurationType {
  [FormFieldsEnum.Protocol]: TCPProtocolTypeEnum;
  type: TransportTypeEnum;
  [FormFieldsEnum.AuthType]: TCPProtocolAccessAuthTypeEnum;
  [FormFieldsEnum.UpScriptId]?: string;
  combinationInfo?: {
    [FormFieldsEnum.SubBeginIndex]: number;
    [FormFieldsEnum.SubEndIndex]: number;
    [FormFieldsEnum.HexLength]: number;
    [FormFieldsEnum.FilterPrefix]?: string;
  };
}

export const formSchemas = (deviceTypeStr: string): FormSchema[] => {
  const { t } = useI18n();
  return [
    {
      field: FormFieldsEnum.Protocol,
      label: t('deviceManagement.product.typeText'),
      component: 'Select',
      required: true,
      defaultValue: TCPProtocolTypeEnum.MODBUS_RTU,
      componentProps({ formModel }) {
        return {
          options: Object.values(TCPProtocolTypeEnum).map((value) => ({
            label: t(`enum.tcpProtocolType.${value}`),
            value,
          })),
          onChange() {
            formModel[FormFieldsEnum.AuthType] = null;
          },
          placeholder: t('common.chooseText') + t('deviceManagement.product.typeText'),
        };
      },
    },
    {
      field: FormFieldsEnum.UpScriptId,
      label: t('deviceManagement.product.uplinkScriptText'),
      component: 'ScriptSelectItem' as 'Input',
      valueField: 'modelValue',
      changeEvent: 'update:modelValue',
      required: true,
      ifShow: ({ values }) => values?.protocol === TCPProtocolTypeEnum.CUSTOM,
      componentProps: {
        scriptType: ScriptTypeEnum.TRANSPORT_TCP_UP,
        serviceType: deviceTypeStr,
      },
    },
    {
      field: FormFieldsEnum.AuthType,
      label: t('deviceManagement.product.accessTypeText'),
      component: 'ApiSelect',
      required: true,
      defaultValue: TCPProtocolAccessAuthTypeEnum.RegisterSend,
      componentProps: ({ formActionType }) => {
        return {
          api: async (params) => {
            const values = await findDictItemByCode(params);
            const model = formActionType.getFieldsValue();
            if (model[FormFieldsEnum.Protocol] === TCPProtocolTypeEnum.MODBUS_RTU)
              return values.filter((item) => item.itemValue !== 'DATA_COMBINATION');
            return values;
          },
          params: {
            dictCode: 'tcp_access_auth_type',
          },
          labelField: 'itemText',
          valueField: 'itemValue',
          placeholder: t('common.chooseText') + t('deviceManagement.product.accessTypeText'),
          onChange() {
            formActionType.setFieldsValue({
              [FormFieldsEnum.SplitRang]: {},
              [FormFieldsEnum.HexLength]: null,
              [FormFieldsEnum.FilterPrefix]: null,
            });
          },
        };
      },
    },
    {
      field: FormFieldsEnum.HexLength,
      component: 'InputNumber',
      label: t('deviceManagement.product.hexLengthText'),
      required: true,
      ifShow: ({ values }) =>
        values[FormFieldsEnum.AuthType] === TCPProtocolAccessAuthTypeEnum.DataCombination,
      rules: [
        {
          required: true,
          validator(_rule, value) {
            const number = parseInt(value, 10);
            const isEven = number % 2 === 0;
            if (!value) {
              return Promise.reject(
                t('common.inputText') + t('deviceManagement.product.hexLengthText')
              );
            }
            if (!isEven) {
              return Promise.reject(t('validator.hexLength'));
            }
            return Promise.resolve();
          },
        },
      ],
      componentProps: {
        precision: 0,
        min: 1,
        placeholder: t('common.inputText') + t('deviceManagement.product.hexLengthText'),
      },
    },
    {
      field: FormFieldsEnum.SplitRang,
      component: 'CustomMinMaxInput',
      label: t('deviceManagement.product.splicePositionText'),
      required: true,
      ifShow: ({ values }) =>
        values[FormFieldsEnum.AuthType] === TCPProtocolAccessAuthTypeEnum.DataCombination,
      valueField: 'value',
      changeEvent: 'update:value',
      helpMessage: t('deviceManagement.product.splicePositionHelpMessageText'),
      dynamicRules: ({ values }) => [
        {
          required: true,
          validator(_rule, value) {
            const hexLength = values[FormFieldsEnum.HexLength];

            if (
              isNullOrUnDef(value[FormFieldsEnum.SubBeginIndex]) ||
              isNullOrUnDef(value[FormFieldsEnum.SubEndIndex])
            ) {
              return Promise.reject(t('deviceManagement.product.inputSpliceStartPositionText'));
            }

            if (value[FormFieldsEnum.SubBeginIndex] > value[FormFieldsEnum.SubEndIndex]) {
              return Promise.reject(t('deviceManagement.product.splicePositionValidText'));
            }

            if (
              value[FormFieldsEnum.SubBeginIndex] > hexLength ||
              value[FormFieldsEnum.SubEndIndex] > hexLength
            ) {
              return Promise.reject(t('deviceManagement.product.spliceLengthValidText'));
            }
            if (value[FormFieldsEnum.SubEndIndex] >= hexLength) {
              return Promise.reject(t('deviceManagement.product.spliceLengthEndValidText'));
            }
            if ((hexLength - value[FormFieldsEnum.SubEndIndex]) % 2 !== 0) {
              return Promise.reject(t('deviceManagement.product.spliceRemingLength'));
            }
            if (value[FormFieldsEnum.SubBeginIndex] == value[FormFieldsEnum.SubEndIndex]) {
              return Promise.reject(t('deviceManagement.product.spliceLengthNotSame'));
            }

            return Promise.resolve();
          },
        },
      ],
      componentProps: {
        minField: FormFieldsEnum.SubBeginIndex,
        maxField: FormFieldsEnum.SubEndIndex,
        minInputProps: {
          placeholder: t('deviceManagement.product.inputStartPositionText'),
          precision: 0,
        },
        maxInputProps: {
          placeholder: t('deviceManagement.product.inputEndPositionText'),
          precision: 0,
        },
      },
    },
    {
      field: FormFieldsEnum.FilterPrefix,
      component: 'Input',
      label: t('deviceManagement.product.filterPrefixText'),
      ifShow: ({ values }) =>
        values[FormFieldsEnum.AuthType] === TCPProtocolAccessAuthTypeEnum.DataCombination,
      componentProps: {
        placeholder: t('common.inputText') + t('deviceManagement.product.filterPrefixText'),
      },
    },
  ];
};