import {
  MyBetaModalFormProps,
  MyFormItems,
  MyModalFormProps,
  rulesHelper,
} from '@/common';
import { MyModal } from '@/components/MyModal';
import { Selects } from '@/components/Select';
import { Apis } from '@/gen/Apis';
import { ApprovalTemplateNodesNodeTypeEnum } from '@/gen/Enums';
import { BetaSchemaForm } from '@ant-design/pro-components';
import { Button, Form, message } from 'antd';
import { useRef, useState } from 'react';
interface DataType {
  key: React.Key;
  id: React.Key;
  is_enabled: boolean;
}
export default function SubmitApproval(
  props: MyBetaModalFormProps & {
    onChange?: (selectedRows: DataType[]) => void;
    onCancel?: () => void;
  },
) {
  const modalRef = useRef<any>();

  const [form] = Form.useForm();
  const [ApprovalTemplates, setApprovalTemplates] = useState<any>([]);

  return (
    <MyModal
      title={'选择审批模版'}
      width="900px"
      myRef={modalRef}
      size="middle"
      defaultOpen={props?.open}
      mode="default"
      onOpen={() => {
        // setSelectedRow(props?.item);
      }}
      onCancel={() => {
        props?.onCancel?.();
      }}
      node={
        <BetaSchemaForm<ApiTypes.Contract.Contracts.Store>
          {...MyModalFormProps.props}
          title={props?.title}
          width="800px"
          layoutType="form"
          wrapperCol={{ span: 24 }}
          form={form}
          onFinish={async (values: any) => {
            console.log(values, 'values222');
            
            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;
                    }
                  }
                }
              }
            }
            
            Apis.Contract.Contracts.SubmitApproval({
              ...values,
              id: props.item?.contracts_id ?? 0,
            })
              .then(() => {
                props.reload?.();
                message.success('提交成功');
                return true;
              })
              .catch(() => false);
          }}
          columns={[
            Selects?.ApprovalTemplates({
              key: 'approval_templates_id',
              title: '审批模版',
              params: {
                type: props?.item?.type,
                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) => {
                      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) => [
                            <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>,
                          ],
                        },
                        formItemProps: {
                          ...rulesHelper.array,
                          wrapperCol: { span: 24 },
                        },
                        columns: [
                          {
                            valueType: 'group',
                            colProps: { span: 24 },
                            columns: [
                              MyFormItems.EnumSelect({
                                key: 'node_type',
                                // title: `类型`,
                                valueEnum: ApprovalTemplateNodesNodeTypeEnum,
                                colProps: { span: 5 },
                                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: 13 },
                                      formItemProps: {
                                        ...rulesHelper.array,
                                      },
                                      fieldProps: {
                                        mode: 'multiple',
                                        showSearch: true,
                                        maxCount:
                                          node_type ===
                                          ApprovalTemplateNodesNodeTypeEnum
                                            .Approver.value
                                            ? 1
                                            : 9,
                                        maxTagTextLength: 3,
                                        labelRender: (res: any) => {
                                          console.log(res, '222');
                                          if (res?.label) {
                                            return res?.label;
                                          } else {
                                            return ApprovalTemplates?.map(
                                              (item: any) => {
                                                if (
                                                  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 || ''
                                                        );
                                                      }
                                                    },
                                                  );
                                                }
                                              },
                                            );
                                          }
                                        },
                                      },
                                    }),
                                  ];
                                },
                              },
                            ],
                          },
                        ],
                      },
                    ]
                  : [];
              },
            },
          ]}
        />
      }
    ></MyModal>
  );
}
