import moment, { Moment } from 'moment';
import { getPacketIntervalByRange, getPacketIntervalByValue, intervalOption } from './helper';
import { FormSchema } from '/@/components/Form';
import { ColEx } from '/@/components/Form/src/types';
import { useGridLayout } from '/@/hooks/component/useGridLayout';
import { useI18n } from '/@/hooks/web/useI18n';
export enum QueryWay {
  LATEST = 'latest',
  TIME_PERIOD = 'timePeriod',
}

export enum SchemaFiled {
  WAY = 'way',
  TIME_PERIOD = 'timePeriod',
  KEYS = 'keys',
  DATE_RANGE = 'dataRange',
  START_TS = 'startTs',
  END_TS = 'endTs',
  INTERVAL = 'interval',
  LIMIT = 'limit',
  AGG = 'agg',
  ORDER_BY = 'orderBy',
}

export enum OrderByEnum {
  DESC = 'DESC',
  ASC = 'ASC',
}

export enum OrderByNameEnum {
  DESC = '降序',
  ASC = '升序',
}

export enum AggregateDataEnum {
  MIN = 'MIN',
  MAX = 'MAX',
  AVG = 'AVG',
  SUM = 'SUM',
  COUNT = 'COUNT',
  NONE = 'NONE',
}

const { t } = useI18n();
export const defaultSchemas: FormSchema[] = [
  {
    field: SchemaFiled.WAY,
    label: t('deviceManagement.device.queryTypeText'),
    component: 'RadioGroup',
    defaultValue: QueryWay.LATEST,
    componentProps({ formActionType }) {
      const { setFieldsValue } = formActionType;
      return {
        options: [
          { label: t('deviceManagement.device.lastestText'), value: QueryWay.LATEST },
          { label: t('deviceManagement.device.timeRangeText'), value: QueryWay.TIME_PERIOD },
        ],
        onChange(event: ChangeEvent) {
          (event.target as HTMLInputElement).value === QueryWay.LATEST
            ? setFieldsValue({
                [SchemaFiled.DATE_RANGE]: [],
                [SchemaFiled.START_TS]: null,
                [SchemaFiled.END_TS]: null,
              })
            : setFieldsValue({ [SchemaFiled.START_TS]: null });
        },
        getPopupContainer: () => document.body,
      };
    },
  },
  {
    field: SchemaFiled.START_TS,
    label: t('deviceManagement.device.latestDataText'),
    component: 'Select',
    ifShow({ values }) {
      return values[SchemaFiled.WAY] === QueryWay.LATEST;
    },
    componentProps({ formActionType }) {
      const { setFieldsValue } = formActionType;
      return {
        options: intervalOption,
        onChange() {
          setFieldsValue({ [SchemaFiled.INTERVAL]: null });
        },
        getPopupContainer: () => document.body,
      };
    },
    required: true,
  },
  {
    field: SchemaFiled.DATE_RANGE,
    label: t('deviceManagement.device.timeRangeText'),
    component: 'RangePicker',
    ifShow({ values }) {
      return values[SchemaFiled.WAY] === QueryWay.TIME_PERIOD;
    },
    required: true,
    componentProps({ formActionType }) {
      const { setFieldsValue } = formActionType;
      let dates: Moment[] = [];
      return {
        showTime: {
          defaultValue: [moment('00:00:00', 'HH:mm:ss'), moment('23:59:59', 'HH:mm:ss')],
        },
        onCalendarChange(value: Moment[]) {
          dates = value;
        },
        disabledDate(current: Moment) {
          if (!dates || dates.length === 0 || !current) {
            return false;
          }
          const diffDate = current.diff(dates[0], 'years', true);
          return Math.abs(diffDate) > 1;
        },
        onChange() {
          dates = [];
          setFieldsValue({ [SchemaFiled.INTERVAL]: null });
        },
        getPopupContainer: () => document.body,
      };
    },
    colProps: useGridLayout(1.5, 1.5, 1.5, 1.5, 1.5, 1.5) as unknown as ColEx,
  },
  {
    field: SchemaFiled.AGG,
    label: t('deviceManagement.device.dataAggregateText'),
    component: 'Select',
    // defaultValue: AggregateDataEnum.NONE,
    componentProps: {
      getPopupContainer: () => document.body,
      options: [
        { label: t('enum.aggregateData.min'), value: AggregateDataEnum.MIN },
        { label: t('enum.aggregateData.max'), value: AggregateDataEnum.MAX },
        { label: t('enum.aggregateData.avg'), value: AggregateDataEnum.AVG },
        { label: t('enum.aggregateData.sum'), value: AggregateDataEnum.SUM },
        { label: t('enum.aggregateData.count'), value: AggregateDataEnum.COUNT },
        { label: t('enum.aggregateData.none'), value: AggregateDataEnum.NONE },
      ],
    },
  },
  {
    field: SchemaFiled.INTERVAL,
    label: t('deviceManagement.device.timeIntervalText'),
    component: 'Select',
    dynamicRules: ({ model }) => {
      return [
        {
          message: t('deviceManagement.device.intervalErrorText'),
          required: model[SchemaFiled.AGG] !== AggregateDataEnum.NONE,
          type: 'number',
        },
      ];
    },
    ifShow({ values }) {
      return values[SchemaFiled.AGG] !== AggregateDataEnum.NONE;
    },
    componentProps({ formModel, formActionType }) {
      const options =
        formModel[SchemaFiled.WAY] === QueryWay.LATEST
          ? getPacketIntervalByValue(formModel[SchemaFiled.START_TS])
          : getPacketIntervalByRange(formModel[SchemaFiled.DATE_RANGE]);
      if (formModel[SchemaFiled.AGG] !== AggregateDataEnum.NONE) {
        formActionType.setFieldsValue({ [SchemaFiled.LIMIT]: null });
      }
      return {
        options,
        getPopupContainer: () => document.body,
      };
    },
  },
  {
    field: SchemaFiled.LIMIT,
    label: t('deviceManagement.device.maxLimitText'),
    component: 'InputNumber',
    // defaultValue: 7,
    ifShow({ values }) {
      return values[SchemaFiled.AGG] === AggregateDataEnum.NONE;
    },
    helpMessage: t('deviceManagement.device.maxLimitHelpText'),
    componentProps() {
      return {
        max: 50000,
        min: 7,
        getPopupContainer: () => document.body,
      };
    },
  },
];