smart-steward-admin/apps/web-ele/src/views/system/taskDesign/taskTemplate/taskTemplate...

import type { FormSchemaGetter } from '#/adapter/form';
import type { VxeGridProps } from '#/adapter/vxe-table';

// @ts-ignore
import { ElButton, ElMessage } from 'element-plus';

// import type { SelectProps } from '#/adapter/form';
import { getPostList } from '#/api/system/post/post';
import { querybaseApilist as queryCheckFormList } from '#/api/system/tasksettings/checktheform';
import { querybaseApilist } from '#/api/system/tasksettings/tasktemplate';
import { getUserList } from '#/api/system/user/user';
import { getDictOptions } from '#/utils/dict';
// 字典标识常量
const DICT_KEYS = {
  // 任务类型字典标识
  TASK_TYPE: 'task_type',
  // 表单类型
  FORM_TYPE: 'wf_form_type',
  // 任务频率
  TASK_FREQUENCY: 'task_frequency',
};

// @ts-ignore:获取执行岗位列表
export let positionsOptions = [] as any[];
// @ts-ignore:任务负责人
export let PersoninchargeOptions = [] as any[];

const getPositionsList = async () => {
  const { rows } = await getPostList({});

  positionsOptions = rows.map((item: any) => ({
    label: item.postName,
    value: item.postId,
    type: item.type,
  }));
};
// postId 1  管理部
// postId 2  片区经理
// postId 3  站长
// postId 4  当班经理
// postId 5  测试
// postId 6  安全管理部
// 初始化岗位数据
getPositionsList().catch(console.error);

const deptTreefn = async () => {
  // @ts-ignore
  const res = await getUserList({});
  PersoninchargeOptions = res.rows.map((item: any) => ({
    label: item.userName,
    value: item.userId,
  }));
};
deptTreefn();
// 获取任务类型字典选项
const getTaskTypeOptions = () => getDictOptions(DICT_KEYS.TASK_TYPE);
// 获取表单类型字典选项
const getFormTypeOptions = () => getDictOptions(DICT_KEYS.FORM_TYPE);
// console.log('表单类型',getFormTypeOptions());
// console.log('过滤表单类型',getFormTypeOptions()?.filter((item: any) => item?.value !== 'form'));

// 获取任务频率字典选项
export const getTaskFrequencyOptions = () =>
  getDictOptions(DICT_KEYS.TASK_FREQUENCY);
// console.log('任务频率', getTaskFrequencyOptions());

// 通用Select组件配置函数
const createSearchSelectConfig = (options: any[], placeholder: string) => ({
  allowClear: true,
  placeholder,
  showSearch: true,
  filterOption: (input: string, option: any) =>
    (option?.label || '').toLowerCase().includes(input.toLowerCase()),
  options,
});

// 通用RadioGroup组件配置函数
const createRadioConfig = (
  options: { label: string; value: string }[],
  defaultValue?: string,
) => ({
  options,
  defaultValue,
});

export const queryFormSchema: FormSchemaGetter = () => [
  {
    component: 'Input',
    fieldName: 'taskName',
    label: '任务名称',
    componentProps: {
      placeholder: '请输入任务名称',
      clearable: true,
    },
  },
  {
    component: 'Select',
    fieldName: 'taskType',
    label: '任务类型',
    componentProps: {
      allowClear: true,
      placeholder: '请选择任务类型',
      options: getTaskTypeOptions(),
      clearable: true,
    },
  },
  {
    component: 'ApiSelect',
    fieldName: 'taskLeader',
    label: '任务负责人',
    componentProps: {
      placeholder: '请选择任务来源',
      api: async () => {
        const resp: any = await getUserList({
          pageNum: 1,
          pageSize: 100,
        });
        return resp.rows.map((item: any) => ({
          label: item.nickName || item.userName,
          value: item.userId.toString(),
        }));
      },
      filterable: true,
      labelField: 'label',
      valueField: 'value',
    },
  },
  {
    component: 'Select',
    fieldName: 'executePosition',
    label: '执行岗位',
    componentProps: {
      allowClear: true,
      placeholder: '请选择执行岗位',
      options: positionsOptions,
      clearable: true,
    },
  },
  {
    component: 'Select',
    fieldName: 'taskFrequency',
    label: '任务频率',
    componentProps: {
      allowClear: true,
      placeholder: '请选择任务频率',
      options: getTaskFrequencyOptions(),
      defaultValue: 'daily',
      clearable: true,
    },
  },
  {
    component: 'Select',
    fieldName: 'status',
    label: '状态',
    componentProps: {
      allowClear: true,
      placeholder: '请选择状态',
      options: [
        { label: '关闭', value: '1' },
        { label: '启用', value: '0' },
      ],
      clearable: true,
    },
  },
  {
    component: 'Select',
    fieldName: 'level',
    label: '任务级别',
    componentProps: {
      allowClear: true,
      placeholder: '请选择任务级别',
      options: [
        { label: '低', value: '0' },
        { label: '中', value: '1' },
        { label: '高', value: '2' },
      ],
      clearable: true,
    },
  },
  {
    component: 'Select',
    fieldName: 'formType',
    label: '表单类型',
    componentProps: () => {
      return {
        allowClear: true,
        placeholder: '请选择表单类型',
        options: getFormTypeOptions(),
        clearable: true,
      };
    },
  },

  {
    component: 'Select',
    fieldName: 'isTiming',
    label: '定时分发',
    componentProps: {
      allowClear: true,
      placeholder: '请选择定时分发',
      options: [
        { label: '否', value: '0' },
        { label: '是', value: '1' },
      ],
      clearable: true,
    },
  },
  // {
  //   component: 'Select',
  //   fieldName: 'taskSource',
  //   label: '任务来源',
  //   componentProps: {
  //     allowClear: true,
  //     placeholder: '请选择任务来源',
  //     optiolns: [
  //       { label: '默认', value: '默认' },
  //       { label: '新增', value: '新增' },
  //     ],
  //     clearable: true,
  //   },
  // },
];
export const tableColumns: VxeGridProps['columns'] = [
  {
    type: 'checkbox',
    width: 80,
  },
  {
    field: 'taskName',
    title: '任务名称',
    minWidth: 150,
  },
  {
    field: 'taskTypeName',
    title: '任务类型',
    minWidth: 120,
  },
  {
    field: 'formTypeName',
    title: '表单类型',
    minWidth: 120,
  },
  {
    field: 'taskLeader',
    title: '任务负责人',
    minWidth: 120,
    slots: { default: 'taskLeader' },
  },
  {
    field: 'executePosition',
    title: '执行岗位',
    minWidth: 120,
    slots: { default: 'executePosition' },
  },
  {
    field: 'taskFrequency',
    title: '任务频率',
    minWidth: 120,
    slots: { default: 'taskFrequency' },
  },
  {
    field: 'status',
    title: '状态',
    minWidth: 100,
    slots: { default: 'status' },
  },
  {
    field: 'isTiming',
    title: '定时分发',
    minWidth: 100,
    slots: { default: 'isTiming' },
  },
  // {
  //   field: 'taskSource',
  //   title: '任务来源',
  //   minWidth: 100,
  // },
  // {
  //   field: 'operator',
  //   title: '操作人',
  //   minWidth: 120,
  // },
  // {
  //   field: 'operationTime',
  //   title: '操作时间',
  //   minWidth: 180,
  // },
  {
    field: 'action',
    fixed: 'right',
    slots: { default: 'action' },
    title: '操作',
    width: 300,
  },
];

// 定义通用的是/否选项
const yesNoOptions = [
  { label: '是', value: '1' },
  { label: '否', value: '0' },
];

export const drawerFormSchema: FormSchemaGetter = (props?: any) => [
  {
    component: 'Input',
    dependencies: {
      show: () => false,
      triggerFields: [''],
    },
    fieldName: 'id',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'Input',
    dependencies: {
      show: () => false,
      triggerFields: [''],
    },
    fieldName: 'isUpdate',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'Input',
    fieldName: 'executePosition',
    dependencies: {
      show: () => false,
      triggerFields: [''],
    },
  },
  {
    component: 'Select',
    fieldName: 'executePositions',
    label: '执行岗位',
    componentProps: (data: any, form: any) => {
      return {
        allowClear: true,
        multiple: true,
        placeholder: '请选择执行岗位',
        options: positionsOptions,
        clearable: true,
        onChange: () => {
          // 判断选择的数据是否有不同类型的
          const posts = data.executePositions;
          const type: any = [];
          for (const item of posts) {
            const info = positionsOptions.find((i: any) => i.value === item);
            if (type.includes(info.type)) {
              continue;
            }
            type.push(info.type);
          }
          if (type.length > 1) {
            ElMessage.error('选择的岗位类型不能不同');
            form.setFieldValue('executePositions', '');
            form.setFieldValue('executePosition', '');
          } else {
            form.setFieldValue(
              'executePosition',
              data.executePositions.join(','),
            );
          }
        },
      };
    },
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'Input',
    fieldName: 'taskName',
    label: '任务名称',
    componentProps: {
      placeholder: '请输入任务名称',
      maxlength: 100,
      clearable: true,
    },
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'Select',
    fieldName: 'taskType',
    label: '任务类型',
    componentProps: (data: any) => {
      return {
        placeholder: '请选择任务类型',
        options: getTaskTypeOptions(),
        clearable: true,
        disabled: data.isUpdate,
      };
    },
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'ApiSelect',
    fieldName: 'taskLeader',
    label: '任务负责人',
    componentProps: {
      placeholder: '请选择任务来源',
      clearable: true,
      api: async () => {
        const resp: any = await getUserList({
          pageNum: 1,
          pageSize: 100,
          postId: 1,
        });
        return resp.rows.map((item: any) => ({
          label: item.nickName || item.userName,
          value: item.userId.toString(),
        }));
      },
      showSearch: true,
      filterable: true,
      remote: true,
      reserveKeyword: true,
      // filterable: true,
      remoteMethod: async (params: any) => {
        const resp: any = await getUserList({
          pageNum: 1,
          pageSize: 100,
          userName: params.query,
        });
        return resp.rows.map((item: any) => ({
          label: item.nickName || item.userName,
          value: item.userId.toString(),
        }));
      },
      labelField: 'label',
      valueField: 'value',
    },
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'Select',
    fieldName: 'formType',
    label: '表单类型',
    componentProps: (data: any) => {
      return {
        placeholder: '请选择表单类型',
        options: getFormTypeOptions().filter(
          (item: any) => item.value !== 'form',
        ),
        clearable: true,
        disabled: data.isUpdate,
      };
    },
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'ApiSelect',
    fieldName: 'checklist',
    label: '关联表名称',
    componentProps: {
      placeholder: '请选择油站',
      clearable: true,
      api: async () => {
        const resp = await queryCheckFormList({
          pageSize: 10_000,
        });
        const data = resp?.rows || [];
        return Array.isArray(data)
          ? data.map((item: any) => ({
              label: item.name,
              value: item.id,
            }))
          : [];
      },
      labelField: 'label',
      valueField: 'value',
    },
    dependencies: {
      show(values: any) {
        return values.formType === 'inspection';
      },
      required(values: any) {
        return values.formType === 'inspection';
      },
      triggerFields: ['formType'],
    },
  },
  // {
  //   component: 'Select',
  //   fieldName: 'formType',
  //   label: '关联表名称',
  //   dependencies: {
  //     show: (values: any) => values.formType === 'inspection',
  //     triggerFields: ['formType'],
  //   },
  //   componentProps: {
  //     placeholder: '请选择关联表名称',
  //     options: getFormTypeOptions(),
  //     clearable: true,
  //   },
  //   rules: 'required',
  //   formItemClass: 'col-span-2 items-baseline',
  // },
  {
    component: 'RadioGroup',
    fieldName: 'isLicensable',
    label: '可授权',
    defaultValue: '1',
    componentProps: createRadioConfig(yesNoOptions),
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
    dependencies: {
      show(formValues: any) {
        if (!formValues.executePositions) {
          return true;
        }

        const posts = formValues.executePositions;
        const type: any = [];

        for (const item of posts) {
          const info = positionsOptions.find((i: any) => i.value === item);
          if (info && !type.includes(info.type)) {
            type.push(info.type);
          }
        }

        return !type.includes('management');
      },
      triggerFields: ['executePositions'],
    },
  },
  {
    component: 'RadioGroup',
    fieldName: 'isRating',
    label: '评分',
    defaultValue: '1',
    componentProps: createRadioConfig(yesNoOptions),
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'RadioGroup',
    fieldName: 'isMust',
    label: '必做',
    defaultValue: '1',
    componentProps: createRadioConfig(yesNoOptions),
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'RadioGroup',
    fieldName: 'distributionMethod',
    label: '分发逻辑',
    formItemClass: 'col-span-2 items-baseline',
    dependencies: {
      show(formValues: any) {
        if (!formValues.executePositions) {
          return false;
        }

        const posts = formValues.executePositions;
        const type: any = [];

        for (const item of posts) {
          const info = positionsOptions.find((i: any) => i.value === item);
          if (info && !type.includes(info.type)) {
            type.push(info.type);
          }
        }

        return (
          type.includes('headquarters') ||
          type.includes('region') ||
          type.includes('management')
        );
      },
      triggerFields: ['executePositions'],
    },
  },
  {
    component: 'RadioGroup',
    fieldName: 'executionMethod',
    label: '执行方式',
    defaultValue: '1',
    componentProps: createRadioConfig([
      { label: '人工', value: '1' },
      { label: '自动', value: '0' },
    ]),
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'Select',
    fieldName: 'taskFrequency',
    label: '任务频率',
    defaultValue: 'daily',
    componentProps: (_: any, formApi: any) => {
      return {
        placeholder: '请选择任务频率',
        options: getTaskFrequencyOptions(),
        clearable: true,
        onChange: (value: any) => {
          // 重置时间相关字段
          // if (value === 'yearly') {
          //   formApi.setFieldValue('startTimeMonth', '1');
          //   formApi.setFieldValue('startTimeYearDay', '1');
          //   formApi.setFieldValue('endTimeMonth', '1');
          //   formApi.setFieldValue('endTimeYearDay', '1');
          // } else {
          formApi.setFieldValue('startTimeDay', '1');
          formApi.setFieldValue('startTimeHour', '0');
          formApi.setFieldValue('endTimeDay', '1');
          formApi.setFieldValue('endTimeHour', '23');
          // }
          // 重置其他字段
          formApi.setFieldValue('planTime', 1);
          formApi.setFieldValue('invalidDays', 0);
          formApi.setFieldValue('daysInterval', 0);
          formApi.setFieldValue('warningTime', 0);
        },
      };
    },
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
  },
  // 每天一次 daily
  // 每周一次 weekly
  // 每月一次 monthly
  // 每两月一次 every_two_months
  // 每三月一次 every_three_months
  // 每六月一次 every_six_months
  // 每年一次 yearly
  // 非 yearly 任务的时间设置
  {
    component: 'Select',
    fieldName: 'startTimeDay',
    label: '开始时间 天',
    defaultValue: '1',
    componentProps: (_: any, formApi: any) => {
      return {
        clearable: true,
        placeholder: '请输入开始时间（天）',
        options: Array.from({ length: 24 }, (_, i) => ({
          label: i.toString().padStart(2, '0'),
          value: i,
        })),
        onChange: () => {
          formApi.setFieldValue('endTimeDay', '');
        },
        // style: { width: '160px' },
      };
    },
    dependencies: {
      show: (values: any) => values.taskFrequency !== 'yearly',
      componentProps(values: any, formApi: any) {
        let options = [];
        const defaultValue = '1';

        if (values.taskFrequency === 'daily') {
          options = [
            {
              label: '-1',
              value: '-1',
            },
            {
              label: '1',
              value: '1',
            },
          ];
        } else if (values.taskFrequency === 'weekly') {
          options = Array.from({ length: 7 }, (_, i) => ({
            label: (i + 1).toString(),
            value: i + 1,
          }));
        } else {
          let count = 7;
          switch (values.taskFrequency) {
            case 'every_six_months': {
              count = 180;
              break;
            }
            case 'every_three_months': {
              count = 90;
              break;
            }
            case 'every_two_months': {
              count = 60;
              break;
            }
            case 'monthly': {
              count = 30;
              break;
            }
            // No default
          }
          options = Array.from({ length: count }, (_, i) => ({
            label: (i + 1).toString(),
            value: i + 1,
          }));
        }

        return {
          options,
          defaultValue,
        };
      },
      triggerFields: ['taskFrequency'],
    },
    // rules: 'required',
    // slot: 'startTimeDay',
  },
  {
    component: 'Select',
    fieldName: 'startTimeHour',
    label: '时',
    defaultValue: '00',
    componentProps: {
      clearable: true,
      placeholder: '请输入开始时间（小时）',
      options: Array.from({ length: 24 }, (_, i) => ({
        label: i.toString().padStart(2, '0'),
        value: i,
      })),
      // type: 'number',
      // placeholder: '请输入开始时间（小时）',
      // min: 0,
      // style: { width: '160px' },
    },
    dependencies: {
      show: (values: any) => values.taskFrequency !== 'yearly',
      componentProps(values: any) {
        return {
          options: Array.from({ length: 24 }, (_, i) => ({
            label: i.toString().padStart(2, '0'),
            value: i,
          })),
          defaultValue: '0',
        };
      },
      triggerFields: ['taskFrequency'],
    },
    // rules: 'required',
    // slot: 'startTimeHour',
  },
  {
    component: 'Select',
    fieldName: 'endTimeDay',
    label: '结束时间 天',
    defaultValue: '1',
    dependencies: {
      show: (values: any) => values.taskFrequency !== 'yearly',
      disabled: (values: any) =>
        (Array.isArray(values.endoftheperiod) &&
          values.endoftheperiod.length > 0) ||
        (values.taskFrequency !== 'daily' &&
          values.taskFrequency !== 'yearly' &&
          Array.isArray(values.isCycleEnd) &&
          values.isCycleEnd[0] === true),
      componentProps(values: any) {
        const startDay = Number.parseInt(values.startTimeDay) || 1;

        switch (values.taskFrequency) {
          case 'daily': {
            return {
              options: [
                { label: '1', value: '1' },
                { label: '2', value: '2' },
              ],
              defaultValue: '1',
            };
          }
          case 'every_six_months': {
            const count = 180 - startDay + 1;
            return {
              options: Array.from({ length: count }, (_, i) => ({
                label: (startDay + i).toString(),
                value: startDay + i,
              })),
              defaultValue: startDay.toString(),
            };
          }
          case 'every_three_months': {
            const count = 90 - startDay + 1;
            return {
              options: Array.from({ length: count }, (_, i) => ({
                label: (startDay + i).toString(),
                value: startDay + i,
              })),
              defaultValue: startDay.toString(),
            };
          }
          case 'every_two_months': {
            const count = 60 - startDay + 1;
            return {
              options: Array.from({ length: count }, (_, i) => ({
                label: (startDay + i).toString(),
                value: startDay + i,
              })),
              defaultValue: startDay.toString(),
            };
          }
          case 'monthly': {
            const count = 30 - startDay + 1;
            return {
              options: Array.from({ length: count }, (_, i) => ({
                label: (startDay + i).toString(),
                value: startDay + i,
              })),
              defaultValue: startDay.toString(),
            };
          }
          case 'weekly': {
            return {
              options: Array.from({ length: 7 - startDay + 1 }, (_, i) => ({
                label: (startDay + i).toString(),
                value: startDay + i,
              })),
              defaultValue: startDay.toString(),
            };
          }
          // No default
        }
        return {
          defaultValue: '1',
        };
      },
      triggerFields: [
        'endoftheperiod',
        'isCycleEnd',
        'taskFrequency',
        'startTimeDay',
      ],
    },
    componentProps: {
      clearable: true,
      placeholder: '请输入结束时间（天）',
      options: Array.from({ length: 24 }, (_, i) => ({
        label: i.toString(),
        value: i,
      })),
      // style: { width: '160px' },
    },
    rules: 'required',
  },
  {
    component: 'Select',
    fieldName: 'endTimeHour',
    label: '时',
    defaultValue: '23',
    dependencies: {
      show: (values: any) => values.taskFrequency !== 'yearly',
      disabled: (values: any) =>
        (Array.isArray(values.endoftheperiod) &&
          values.endoftheperiod.length > 0) ||
        (values.taskFrequency !== 'daily' &&
          values.taskFrequency !== 'yearly' &&
          Array.isArray(values.isCycleEnd) &&
          values.isCycleEnd[0] === true),
      componentProps(values: any) {
        return {
          defaultValue: '23',
        };
      },
      triggerFields: ['endoftheperiod', 'isCycleEnd', 'taskFrequency'],
    },
    componentProps: {
      clearable: true,
      placeholder: '请输入结束时间（小时）',
      options: Array.from({ length: 24 }, (_, i) => ({
        label: i.toString().padStart(2, '0'),
        value: i,
      })),
      // style: { width: '160px' },
    },
    // rules: 'required',
  },
  // yearly 任务的时间设置
  {
    component: 'Select',
    fieldName: 'startTimeMonth',
    label: '开始时间 月',
    defaultValue: '1',
    componentProps: (_: any, formApi: any) => {
      return {
        clearable: true,
        placeholder: '请输入开始时间（月）',
        options: Array.from({ length: 12 }, (_, i) => ({
          label: (i + 1).toString(),
          value: i + 1,
        })),
        onChange: () => {
          formApi.setFieldValue('endTimeMonth', '');
          formApi.setFieldValue('endTimeYearDay', '');
        },
      };
    },
    dependencies: {
      show: (values: any) => values.taskFrequency === 'yearly',
      componentProps(values: any, formApi: any) {
        return {};
      },
      triggerFields: ['taskFrequency'],
    },
    // rules: 'required',
  },
  {
    component: 'Select',
    fieldName: 'startTimeYearDay',
    label: '开始时间 天',
    defaultValue: '1',
    componentProps: (_: any, formApi: any) => {
      return {
        clearable: true,
        placeholder: '请输入开始时间（天）',
        options: Array.from({ length: 31 }, (_, i) => ({
          label: (i + 1).toString(),
          value: i + 1,
        })),
        onChange: () => {
          formApi.setFieldValue('endTimeYearDay', '');
        },
      };
    },
    dependencies: {
      show: (values: any) => values.taskFrequency === 'yearly',
      triggerFields: ['taskFrequency'],
    },
    // rules: 'required',
  },
  {
    component: 'Select',
    fieldName: 'endTimeMonth',
    label: '结束时间 月',
    defaultValue: '1',
    dependencies: {
      show: (values: any) => values.taskFrequency === 'yearly',
      disabled: (values: any) =>
        (Array.isArray(values.endoftheperiod) &&
          values.endoftheperiod.length > 0) ||
        (values.taskFrequency !== 'daily' &&
          values.taskFrequency !== 'yearly' &&
          Array.isArray(values.isCycleEnd) &&
          values.isCycleEnd[0] === true),
      componentProps(values: any) {
        const startMonth = Number.parseInt(values.startTimeMonth) || 1;
        const startDay = Number.parseInt(values.startTimeYearDay) || 1;

        return {
          options: Array.from({ length: 12 - startMonth + 1 }, (_, i) => ({
            label: (startMonth + i).toString(),
            value: startMonth + i,
          })),
          defaultValue: startMonth.toString(),
        };
      },
      triggerFields: [
        'endoftheperiod',
        'isCycleEnd',
        'taskFrequency',
        'startTimeMonth',
      ],
    },
    componentProps: {
      clearable: true,
      placeholder: '请输入结束时间（月）',
      options: Array.from({ length: 12 }, (_, i) => ({
        label: (i + 1).toString(),
        value: i + 1,
      })),
    },
    rules: 'required',
  },
  {
    component: 'Select',
    fieldName: 'endTimeYearDay',
    label: '结束时间 天',
    defaultValue: '1',
    dependencies: {
      show: (values: any) => values.taskFrequency === 'yearly',
      disabled: (values: any) =>
        (Array.isArray(values.endoftheperiod) &&
          values.endoftheperiod.length > 0) ||
        (values.taskFrequency !== 'daily' &&
          values.taskFrequency !== 'yearly' &&
          Array.isArray(values.isCycleEnd) &&
          values.isCycleEnd[0] === true),
      componentProps(values: any) {
        const startMonth = Number.parseInt(values.startTimeMonth) || 1;
        const startDay = Number.parseInt(values.startTimeYearDay) || 1;
        const endMonth = Number.parseInt(values.endTimeMonth) || 1;
        const month = endMonth;

        // 计算每个月的天数
        let daysInMonth = 31;
        if ([4, 6, 9, 11].includes(month)) {
          daysInMonth = 30;
        } else if (month === 2) {
          daysInMonth = 28; // 简化处理，不考虑闰年
        }

        // 如果是同月，结束天数必须大于等于开始天数
        // 如果是跨月，结束天数可以从1号开始
        const start = startMonth === endMonth ? startDay : 1;
        const count = daysInMonth - start + 1;
        return {
          options: Array.from({ length: count }, (_, i) => ({
            label: (start + i).toString(),
            value: start + i,
          })),
          defaultValue: start.toString(),
        };
      },
      triggerFields: [
        'endoftheperiod',
        'isCycleEnd',
        'taskFrequency',
        'startTimeMonth',
        'startTimeYearDay',
        'endTimeMonth',
      ],
    },
    componentProps: {
      clearable: true,
      placeholder: '请输入结束时间（天）',
      options: Array.from({ length: 31 }, (_, i) => ({
        label: (i + 1).toString(),
        value: i + 1,
      })),
    },
    // rules: 'required',
  },
  // 是否周期末0否1是
  {
    component: 'CheckboxGroup',
    fieldName: 'isCycleEnd',
    label: '周期末',
    componentProps: {
      options: [
        {
          label: '',
          value: true,
        },
      ],
    },
    dependencies: {
      show: (values: any) =>
        values.taskFrequency !== 'daily' && values.taskFrequency !== 'yearly',
      triggerFields: ['taskFrequency'],
    },
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'InputNumber',
    fieldName: 'planTime',
    label: '计划时间',
    defaultValue: 1,
    componentProps: {
      type: 'number',
      placeholder: '请输入计划时间',
      min: 0,
    },
    dependencies: {
      disabled: (values: any) =>
        values.taskFrequency === 'daily' || values.taskFrequency === 'yearly',
      componentProps(values: any) {
        const min = Number.parseInt(values.startTimeDay) || 1;
        const max = Number.parseInt(values.endTimeDay) || 365;

        return {
          min,
          max,
        };
      },
      triggerFields: ['taskFrequency', 'startTimeDay', 'endTimeDay'],
    },
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'InputNumber',
    fieldName: 'invalidDays',
    label: '失效天数',
    defaultValue: 0,
    componentProps: {
      placeholder: '请输入失效天数',
      min: 0,
    },
    dependencies: {
      componentProps(values: any) {
        if (values.taskFrequency === 'daily') {
          return {
            min: 0,
            max: 1,
          };
        }
        return {
          min: 0,
        };
      },
      triggerFields: ['taskFrequency'],
    },
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'InputNumber',
    fieldName: 'daysInterval',
    label: '间隔天数',
    defaultValue: 0,
    componentProps: {
      placeholder: '请输入间隔天数',
      min: 0,
    },
    dependencies: {
      disabled: (values: any) => values.taskFrequency === 'daily',
      triggerFields: ['taskFrequency'],
    },
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'InputNumber',
    fieldName: 'warningTime',
    label: '预警时间',
    defaultValue: 0,
    componentProps: {
      placeholder: '请输入预警时间',
      min: 0,
    },
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'Select',
    fieldName: 'level',
    label: '任务级别',
    componentProps: {
      placeholder: '请选择任务级别',
      options: [
        { label: '低', value: '0' },
        { label: '中', value: '1' },
        { label: '高', value: '2' },
      ],
      clearable: true,
    },
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'ApiSelect',
    fieldName: 'repel',
    label: '任务排斥',
    componentProps: {
      placeholder: '请选择任务排斥',
      api: async () => {
        const resp = await querybaseApilist({
          pageSize: 10_000,
        });
        const data = resp?.rows || [];
        return Array.isArray(data)
          ? data.map((item: any) => ({
              label: item.taskName,
              value: item.id,
            }))
          : [];
      },
      labelField: 'label',
      valueField: 'value',
      clearable: true,
    },
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    // component: 'Input',
    fieldName: 'icon',
    label: '任务图标',
    componentProps: {
      placeholder: '请输入任务图标',
      clearable: true,
    },
    rules: 'required',
    slot: 'icon',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'Input',
    fieldName: 'description',
    label: '任务描述',
    componentProps: {
      placeholder: '请输入任务描述',
      rows: 10,
      clearable: true,
    },
    // 使用自定义插槽渲染Tinymce编辑器
    slot: 'description',
    formItemClass: 'col-span-2 items-baseline',
  },
  // 知识库
  {
    component: 'Input',
    dependencies: {
      show: () => false,
      triggerFields: [''],
    },
    fieldName: 'knowledge',
    formItemClass: 'col-span-2 items-baseline',
  },
  // 知识库类别
  {
    component: 'Input',
    dependencies: {
      show: () => false,
      triggerFields: [''],
    },
    fieldName: 'knowledgeCategory',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'Input',
    fieldName: 'standardGuidelineName',
    label: '标准指引',
    componentProps: {
      placeholder: '请选择标准指引',
      clearable: true,
    },
    renderComponentContent: (row: any, formApi: any) => {
      return {
        suffix: () => {
          return (
            <ElButton
              onClick={() => {
                props?.quoteModalApi?.open();
              }}
              type="primary"
            >
              选择
            </ElButton>
          );
        },
      };
    },
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'Upload',
    fieldName: 'attachment',
    label: '附件',
    // 注意：该组件的详细实现已在taskTemplate-drawer.vue中通过插槽自定义
    // 这里仅保留基本配置，实际渲染由插槽控制
    componentProps: {
      // 基础配置
      action: '#',
      multiple: true,
    },
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'RadioGroup',
    fieldName: 'status',
    label: '任务状态',
    componentProps: {
      options: [
        { label: '启用', value: '0' },
        { label: '关闭', value: '1' },
      ],
      defaultValue: '启用',
    },
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
  },
  {
    component: 'RadioGroup',
    fieldName: 'isTiming',
    label: '定时分发',
    componentProps: {
      options: [
        { label: '是', value: '1' },
        { label: '否', value: '0' },
      ],
      defaultValue: '是',
    },
    rules: 'required',
    formItemClass: 'col-span-2 items-baseline',
  },
];

export const formActions = [
  {
    type: 'button',
    text: '查询',
    submit: true,
    buttonProps: { type: 'primary' },
  },
  { type: 'button', text: '重置', reset: true },
  {
    type: 'button',
    text: '导出',
    buttonProps: { type: 'primary', ghost: true },
  },
];