import {
  MyBetaModalFormProps,
  MyButtons,
  MyFormItems,
  MyModalFormProps,
  rulesHelper,
} from '@/common';
import { Selects } from '@/components/Select';
import { SelectContract } from '@/components/SelectContract';
import { Apis } from '@/gen/Apis';
import { ApprovalTemplateNodesNodeTypeEnum } from '@/gen/Enums';
import { BetaSchemaForm } from '@ant-design/pro-components';
import { Button, Form, message, Space } from 'antd';

export default function Create(props: MyBetaModalFormProps) {
  const [form] = Form.useForm();
  // const [ApprovalTemplates, setApprovalTemplates] = useState<any[]>([]);
  let ApprovalTemplates: any = [];
  return (
    <BetaSchemaForm<ApiTypes.Contract.ContractOthers.Store>
      {...MyModalFormProps.props}
      title={`其他用印申请`}
      trigger={<MyButtons.Create title="其他用印" />}
      layout="horizontal"
      labelCol={{ span: 4 }}
      wrapperCol={{ span: 20 }}
      labelAlign="left"
      width="680px"
      form={form}
      key={new Date().getTime()}
      onOpenChange={(open: any) => {
        if (open && props.item) {
          form.resetFields();
          form.setFieldsValue({
            ...props.item,
          });
        }
      }}
      onFinish={async (values: any) => {
        const { node_approvers } = values;
        if (ApprovalTemplates?.length > 0 && node_approvers?.length > 0) {
          // 遍历模板节点，通过名称找到对应的提交节点进行校验
          for (const templateNode of ApprovalTemplates) {
            // 通过名称找到对应的提交节点
            const submittedNode = node_approvers.find(
              (node: any) => node?.name === templateNode?.name,
            );

            // 如果模板节点在提交数据中不存在，说明被删除了，报错
            if (!submittedNode) {
              message.error(`节点"${templateNode?.name}"不能删除`);
              return false;
            }

            // 校验审批人
            if (
              templateNode?.node_type ===
              ApprovalTemplateNodesNodeTypeEnum.Approver.value
            ) {
              const originalMembers =
                templateNode?.approval_template_node_members?.map(
                  (member: any) => member?.company_employees_id,
                );

              if (originalMembers?.length > 0) {
                const submittedMembers = submittedNode?.members || [];

                const isMatch =
                  originalMembers.length === submittedMembers.length &&
                  originalMembers.every((memberId: number) =>
                    submittedMembers.includes(memberId),
                  );

                if (!isMatch) {
                  message.error(
                    `节点"${templateNode?.name}"的审批人必须与审批模板设置保持一致`,
                  );
                  return false;
                }
              }
            }
          }
        }

        return Apis.Contract.ContractOthers.Store({
          ...values,
        })
          .then(() => {
            props.reload?.();
            message.success(props.title + '成功');
            return true;
          })
          .catch(() => false);
      }}
      columns={[
        {
          key: 'title',
          title: '申请标题',
          colProps: { span: 24 },
          formItemProps: { ...rulesHelper.text },
        },
        {
          key: 'reason',
          title: '申请原因',
          valueType: 'textarea',
          colProps: { span: 24 },
          formItemProps: { ...rulesHelper.text },
        },
        SelectContract.AssetProjects({
          key: 'asset_projects_id',
          title: '关联项目',
          colProps: { span: 24 },
          required: true,
          fieldProps: {
            showSearch: true,
            // mode: 'multiple',
          },
        }),
        {
          title: '合同份数',
          key: 'copies',
          valueType: 'digit',
          colProps: { span: 24 },
          formItemProps: { ...rulesHelper.number },
          fieldProps: {
            style: { width: '100%' },
          },
        },
        SelectContract.ContractSeals({
          key: 'seals',
          required: true,
          title: '选择印章',
          colProps: { span: 24 },
          params: {
            is_enabled: true,
          },
          fieldProps: {
            showSearch: true,
            mode: 'multiple',
          },
        }),
        MyFormItems.UploadImages({
          key: 'files',
          title: '上传附件',
          tooltip: '支持上传任意格式的文件',
          uploadType: 'file',
          colProps: { span: 24 },
          // accept: '.docx,.doc,.pdf',
          max: 100,
          required: true,
        }),

        Selects?.ApprovalTemplates({
          key: 'approval_templates_id',
          title: '审批模版',
          params: {
            type: 'OtherContractSeal',
            is_enabled: '1',
          },
          colProps: { span: 24 },
          formItemProps: { ...rulesHelper.number },
          fieldProps: {
            onChange: (e: any) => {
              // 确保e是有效值，并且使用正确的value字段
              if (e) {
                const templateId = typeof e === 'object' ? e.value : e;
                Apis.Approval.ApprovalTemplates.Show({
                  id: templateId,
                }).then((res) => {
                  ApprovalTemplates = res?.data?.approval_template_nodes || [];
                  // setApprovalTemplates(
                  //   res?.data?.approval_template_nodes || [],
                  // );
                  form.setFieldsValue({
                    approval_templates_id: templateId,
                    node_approvers: res?.data?.approval_template_nodes?.map(
                      (item: any) => ({
                        ...item,
                        members: item?.approval_template_node_members?.map(
                          (member: any) => member?.company_employees_id,
                        ),
                      }),
                    ),
                  });
                });
              }
              // 不返回任何值，防止默认行为
            },
          },
        }),
        {
          valueType: 'dependency',
          name: ['approval_templates_id'],
          columns: ({ approval_templates_id }) => {
            return approval_templates_id
              ? [
                  {
                    valueType: 'formList',
                    dataIndex: 'node_approvers',
                    // title: '审批节点',
                    fieldProps: {
                      copyIconProps: false,
                      deleteIconProps: false,
                      creatorButtonProps: false,
                      actionRender: (field: any, action: any) => [
                        <Space key={`items_${field.name}`}>
                          <Button
                            key="add"
                            type="link"
                            size="small"
                            onClick={() => {
                              const currentNodeType = form.getFieldValue([
                                'node_approvers',
                                field.name,
                                'node_type',
                              ]);
                              if (
                                currentNodeType ===
                                ApprovalTemplateNodesNodeTypeEnum.CC.value
                              ) {
                                message.warning('抄送节点不允许添加');
                                return;
                              }
                              action.add(
                                {
                                  node_type:
                                    ApprovalTemplateNodesNodeTypeEnum.Approver
                                      .value,
                                },
                                field.name + 1,
                              );
                            }}
                          >
                            添加
                          </Button>
                          <Button
                            key="delete"
                            type="link"
                            size="small"
                            danger
                            onClick={() => {
                              action.remove(field.name);
                            }}
                          >
                            删除
                          </Button>
                        </Space>,
                      ],
                    },
                    formItemProps: {
                      ...rulesHelper.array,
                      wrapperCol: { span: 24 },
                    },
                    columns: [
                      {
                        valueType: 'group',
                        colProps: { span: 24 },
                        columns: [
                          MyFormItems.EnumSelect({
                            key: 'node_type',
                            // title: `类型`,
                            valueEnum: ApprovalTemplateNodesNodeTypeEnum,
                            colProps: { span: 6 },
                            formItemProps: {
                              ...rulesHelper.text,
                            },
                            fieldProps: {
                              disabled: true,
                            },
                          }),
                          {
                            // title: '节点名称',
                            key: 'name',
                            colProps: { span: 6 },
                            formItemProps: {
                              ...rulesHelper.text,
                            },
                            fieldProps: {
                              disabled: true,
                            },
                          },
                          {
                            valueType: 'dependency',
                            name: ['node_type'],
                            columns: ({ node_type }) => {
                              return [
                                Selects.Employees({
                                  key: 'members',
                                  title: ``,
                                  colProps: { span: 12 },
                                  formItemProps: {
                                    ...rulesHelper.array,
                                  },
                                  fieldProps: {
                                    mode: 'multiple',
                                    showSearch: true,
                                    maxCount:
                                      node_type ===
                                      ApprovalTemplateNodesNodeTypeEnum.Approver
                                        .value
                                        ? 1
                                        : 9,
                                    maxTagTextLength: 3,
                                    labelRender: (res: any) => {
                                      if (res?.label) {
                                        return res?.label;
                                      } else {
                                        return ApprovalTemplates?.map(
                                          (item: any) => {
                                            if (
                                              item?.node_type === node_type &&
                                              item
                                                ?.approval_template_node_members
                                                ?.length
                                            ) {
                                              return item?.approval_template_node_members?.map(
                                                (i: any) => {
                                                  if (
                                                    i?.company_employees_id ===
                                                    res?.value
                                                  ) {
                                                    return (
                                                      i?.company_employee
                                                        ?.name || ''
                                                    );
                                                  }
                                                },
                                              );
                                            }
                                          },
                                        );
                                      }
                                    },
                                  },
                                }),
                              ];
                            },
                          },
                        ],
                      },
                    ],
                  },
                ]
              : [];
          },
        },
      ]}
    />
  );
}