import {
  type ReactNode,
  useCallback,
  useEffect,
  useMemo,
  useRef,
  useState,
} from 'react';

import { useGameSettings } from '../../hooks/useGameSettings';
import {
  AUTH_STATE_EVENT,
  refreshStoredAccessToken,
} from '../../services/apiClient';
import {
  type AuthAuditLogEntry,
  type AuthCaptchaChallenge,
  authEntry,
  type AuthLoginMethod,
  type AuthRiskBlockSummary,
  type AuthSessionSummary,
  type AuthUser,
  bindWechatPhone,
  changePassword,
  changePhoneNumber,
  consumeAuthCallbackResult,
  getAuthAuditLogs,
  getAuthLoginOptions,
  getAuthRiskBlocks,
  getAuthSessions,
  getCaptchaChallengeFromError,
  getCurrentAuthUser,
  liftAuthRiskBlock,
  loginWithPhoneCode,
  logoutAllAuthSessions,
  logoutAuthUser,
  redeemRegistrationInviteCode,
  resetPassword,
  revokeAuthSession,
  sendPhoneLoginCode,
  setStoredLastLoginPhone,
  startWechatLogin,
} from '../../services/authService';
import { AccountModal } from './AccountModal';
import { AuthUiContext, type PlatformSettingsSection } from './AuthUiContext';
import { BindPhoneScreen } from './BindPhoneScreen';
import { LoginScreen } from './LoginScreen';
import { RegistrationInviteModal } from './RegistrationInviteModal';

type AuthGateProps = {
  children: ReactNode;
};

type AuthStatus =
  | 'checking'
  | 'recovering'
  | 'unauthenticated'
  | 'pending_bind_phone'
  | 'ready'
  | 'error';

const FALLBACK_LOGIN_METHODS: AuthLoginMethod[] = ['password'];

function readInviteCodeFromLocation(): string {
  const params = new URLSearchParams(window.location.search || '');
  return (params.get('inviteCode') || params.get('invite_code') || '')
    .trim()
    .replace(/[^0-9a-z]/gi, '')
    .toUpperCase();
}

function normalizeAvailableLoginMethods(
  methods: AuthLoginMethod[] | null | undefined,
): AuthLoginMethod[] {
  const normalizedMethods = Array.from(new Set(methods ?? []));

  // 密码登录由 Rust auth entry 固定承载，不依赖短信或微信环境开关。
  // 当 login-options 联调失败或配置返回空数组时，仍要保留账号入口，避免登录弹窗失去可操作方式。
  return normalizedMethods.length > 0
    ? normalizedMethods
    : FALLBACK_LOGIN_METHODS;
}

export function AuthGate({ children }: AuthGateProps) {
  const [status, setStatus] = useState<AuthStatus>('checking');
  const [user, setUser] = useState<AuthUser | null>(null);
  const [availableLoginMethods, setAvailableLoginMethods] = useState<
    AuthLoginMethod[]
  >([]);
  const [error, setError] = useState('');
  const [sendingCode, setSendingCode] = useState(false);
  const [loggingIn, setLoggingIn] = useState(false);
  const [bindingPhone, setBindingPhone] = useState(false);
  const [wechatLoading, setWechatLoading] = useState(false);
  const [showLoginModal, setShowLoginModal] = useState(false);
  const [pendingInviteCode, setPendingInviteCode] = useState('');
  const [showRegistrationInviteModal, setShowRegistrationInviteModal] =
    useState(false);
  const [submittingRegistrationInvite, setSubmittingRegistrationInvite] =
    useState(false);
  const [registrationInviteError, setRegistrationInviteError] = useState('');
  const [showSettingsModal, setShowSettingsModal] = useState(false);
  const [settingsEntryMode, setSettingsEntryMode] = useState<
    'settings' | 'account'
  >('settings');
  const [initialSettingsSection, setInitialSettingsSection] =
    useState<PlatformSettingsSection | null>(null);
  const [sessions, setSessions] = useState<AuthSessionSummary[]>([]);
  const [loadingSessions, setLoadingSessions] = useState(false);
  const [auditLogs, setAuditLogs] = useState<AuthAuditLogEntry[]>([]);
  const [loadingAuditLogs, setLoadingAuditLogs] = useState(false);
  const [riskBlocks, setRiskBlocks] = useState<AuthRiskBlockSummary[]>([]);
  const [loadingRiskBlocks, setLoadingRiskBlocks] = useState(false);
  const [loginCaptchaChallenge, setLoginCaptchaChallenge] =
    useState<AuthCaptchaChallenge | null>(null);
  const [bindCaptchaChallenge, setBindCaptchaChallenge] =
    useState<AuthCaptchaChallenge | null>(null);
  const [changePhoneCaptchaChallenge, setChangePhoneCaptchaChallenge] =
    useState<AuthCaptchaChallenge | null>(null);
  const pendingProtectedActionRef = useRef<(() => void) | null>(null);
  const autoOpenedInviteCodeRef = useRef<string | null>(null);
  const hasRenderedPlatformContentRef = useRef(false);
  const canKeepPlatformContentMounted =
    hasRenderedPlatformContentRef.current &&
    (status === 'checking' || status === 'recovering');
  const readyUser =
    status === 'ready' || canKeepPlatformContentMounted ? user : null;
  const settings = useGameSettings(readyUser?.id ?? null);
  const platformThemeClass = `platform-theme--${settings.platformTheme}`;

  if (status === 'ready' || status === 'unauthenticated') {
    hasRenderedPlatformContentRef.current = true;
  }

  const activateReadyUser = useCallback((nextUser: AuthUser) => {
    // 受保护业务 hook 只在 readyUser 暴露后启动，必须先保证请求层能带 Bearer token。
    setUser(nextUser);
    setStatus('ready');
  }, []);

  const clearLocalAuthenticatedState = useCallback(() => {
    // 退出动作必须先收回前端鉴权上下文，再等待后端吊销完成。
    // 否则平台壳层会在无刷新状态下继续暴露旧用户的私有作品缓存。
    pendingProtectedActionRef.current = null;
    setUser(null);
    setStatus('unauthenticated');
    setShowLoginModal(false);
    setShowRegistrationInviteModal(false);
    setShowSettingsModal(false);
    setSettingsEntryMode('settings');
    setInitialSettingsSection(null);
    setSessions([]);
    setAuditLogs([]);
    setRiskBlocks([]);
    setLoginCaptchaChallenge(null);
    setBindCaptchaChallenge(null);
    setChangePhoneCaptchaChallenge(null);
    setPendingInviteCode('');
    setRegistrationInviteError('');
    setError('');
  }, []);

  const logoutCurrentSession = useCallback(async () => {
    clearLocalAuthenticatedState();
    try {
      await logoutAuthUser();
    } catch (logoutError) {
      setError(
        logoutError instanceof Error
          ? logoutError.message
          : '退出登录失败，请刷新页面确认状态。',
      );
    }
  }, [clearLocalAuthenticatedState]);

  const logoutAllSessions = useCallback(async () => {
    clearLocalAuthenticatedState();
    try {
      await logoutAllAuthSessions();
    } catch (logoutError) {
      setError(
        logoutError instanceof Error
          ? logoutError.message
          : '退出全部设备失败，请刷新页面确认状态。',
      );
    }
  }, [clearLocalAuthenticatedState]);

  const closeLoginModal = useCallback(() => {
    pendingProtectedActionRef.current = null;
    setShowLoginModal(false);
    setLoginCaptchaChallenge(null);
    setError('');
  }, []);

  const closeRegistrationInviteModal = useCallback(() => {
    setShowRegistrationInviteModal(false);
    setRegistrationInviteError('');
    setPendingInviteCode('');
  }, []);

  const closeSettingsModal = useCallback(() => {
    setShowSettingsModal(false);
    setSettingsEntryMode('settings');
    setInitialSettingsSection(null);
  }, []);

  const openLoginModal = useCallback(
    (postLoginAction?: (() => void) | null) => {
      if (readyUser) {
        postLoginAction?.();
        return;
      }

      pendingProtectedActionRef.current = postLoginAction ?? null;
      setShowLoginModal(true);
    },
    [readyUser],
  );

  const requireAuth = useCallback(
    (action: () => void) => {
      openLoginModal(action);
    },
    [openLoginModal],
  );

  const openSettingsModal = useCallback(
    (section?: PlatformSettingsSection) => {
      if (readyUser) {
        setSettingsEntryMode('settings');
        setInitialSettingsSection(section ?? null);
        setShowSettingsModal(true);
        return;
      }

      openLoginModal();
    },
    [openLoginModal, readyUser],
  );

  const openAccountModal = useCallback(() => {
    if (readyUser) {
      setSettingsEntryMode('account');
      setInitialSettingsSection('account');
      setShowSettingsModal(true);
      return;
    }

    openLoginModal();
  }, [openLoginModal, readyUser]);

  useEffect(() => {
    if (status !== 'unauthenticated' || readyUser || showLoginModal) {
      return;
    }
    const inviteCode = readInviteCodeFromLocation();
    if (!inviteCode) {
      return;
    }
    if (autoOpenedInviteCodeRef.current === inviteCode) {
      return;
    }
    autoOpenedInviteCodeRef.current = inviteCode;
    setPendingInviteCode(inviteCode);
  }, [readyUser, showLoginModal, status]);

  useEffect(() => {
    let isActive = true;

    const hydrate = async () => {
      const callbackResult = consumeAuthCallbackResult();
      const loadLoginOptions = async () => {
        const options = await getAuthLoginOptions();
        if (!isActive) {
          return null;
        }

        setAvailableLoginMethods(
          normalizeAvailableLoginMethods(options.availableLoginMethods),
        );
        return options;
      };

      const resolveGuestFallback = async () => {
        try {
          await loadLoginOptions();
          if (!isActive) {
            return;
          }

          setUser(null);
          setStatus('unauthenticated');
        } catch (optionsError) {
          if (!isActive) {
            return;
          }

          setAvailableLoginMethods(FALLBACK_LOGIN_METHODS);
          setUser(null);
          // 中文注释：登录方式接口失败时按产品约定保留密码登录入口；
          // 这里不展示接口读取错误，避免用户误以为登录本身不可用。
          setError(callbackResult?.error ?? '');
          setStatus('unauthenticated');
        }
      };

      if (callbackResult?.error && isActive) {
        setError(callbackResult.error);
        setShowLoginModal(true);
      }

      try {
        // 中文注释：打开已登录页面也要主动轮换 refresh cookie。
        // 后端只在 refresh/session 成功续期时写每日登录埋点；如果本地 access token 尚未过期，
        // 仅调用 /auth/me 不会进入续期链路，导致“打开网页”没有登录埋点。
        await refreshStoredAccessToken();
        const nextSession = await getCurrentAuthUser();
        if (!isActive) {
          return;
        }

        if (!nextSession.user) {
          setAvailableLoginMethods(
            normalizeAvailableLoginMethods(nextSession.availableLoginMethods),
          );
          await resolveGuestFallback();
          return;
        }

        setUser(nextSession.user);
        setAvailableLoginMethods(
          normalizeAvailableLoginMethods(nextSession.availableLoginMethods),
        );
        setStatus(
          nextSession.user.bindingStatus === 'pending_bind_phone'
            ? 'pending_bind_phone'
            : 'ready',
        );
        setError(callbackResult?.error ?? '');
      } catch {
        if (!isActive) {
          return;
        }

        await resolveGuestFallback();
      }
    };

    void hydrate();

    const handleAuthStateChange = () => {
      setStatus('checking');
      void hydrate();
    };

    window.addEventListener(AUTH_STATE_EVENT, handleAuthStateChange);

    return () => {
      isActive = false;
      window.removeEventListener(AUTH_STATE_EVENT, handleAuthStateChange);
    };
  }, [activateReadyUser]);

  useEffect(() => {
    if (!readyUser) {
      setShowSettingsModal(false);
      return;
    }

    setShowLoginModal(false);

    const pendingAction = pendingProtectedActionRef.current;
    pendingProtectedActionRef.current = null;
    pendingAction?.();
  }, [readyUser]);

  useEffect(() => {
    if (!showSettingsModal || status !== 'ready') {
      return;
    }

    let isActive = true;
    setLoadingRiskBlocks(true);
    setLoadingSessions(true);
    setLoadingAuditLogs(true);
    void getAuthRiskBlocks()
      .then((nextBlocks) => {
        if (!isActive) {
          return;
        }
        setRiskBlocks(nextBlocks);
      })
      .catch((blockError) => {
        if (!isActive) {
          return;
        }
        setError(
          blockError instanceof Error
            ? blockError.message
            : '读取安全状态失败，请稍后再试。',
        );
      })
      .finally(() => {
        if (!isActive) {
          return;
        }
        setLoadingRiskBlocks(false);
      });
    void getAuthSessions()
      .then((nextSessions) => {
        if (!isActive) {
          return;
        }
        setSessions(nextSessions);
      })
      .catch((sessionError) => {
        if (!isActive) {
          return;
        }
        setError(
          sessionError instanceof Error
            ? sessionError.message
            : '读取登录设备失败，请稍后再试。',
        );
      })
      .finally(() => {
        if (!isActive) {
          return;
        }
        setLoadingSessions(false);
      });

    void getAuthAuditLogs()
      .then((nextLogs) => {
        if (!isActive) {
          return;
        }
        setAuditLogs(nextLogs);
      })
      .catch((auditError) => {
        if (!isActive) {
          return;
        }
        setError(
          auditError instanceof Error
            ? auditError.message
            : '读取账号操作记录失败，请稍后再试。',
        );
      })
      .finally(() => {
        if (!isActive) {
          return;
        }
        setLoadingAuditLogs(false);
      });

    return () => {
      isActive = false;
    };
  }, [showSettingsModal, status]);

  const authUiValue = useMemo(
    () => ({
      user: readyUser,
      // 平台内容在 checking/recovering 阶段可以继续挂载，避免闪烁；
      // 但受保护请求只能在真实 ready 且存在用户时再启动。
      canAccessProtectedData: status === 'ready' && Boolean(readyUser),
      openLoginModal,
      requireAuth,
      openSettingsModal,
      openAccountModal,
      setCurrentUser: setUser,
      logout: logoutCurrentSession,
      musicVolume: settings.musicVolume,
      setMusicVolume: settings.setMusicVolume,
      platformTheme: settings.platformTheme,
      setPlatformTheme: settings.setPlatformTheme,
      isHydratingSettings: settings.isHydratingSettings,
      isPersistingSettings: settings.isPersistingSettings,
      settingsError: settings.settingsError,
    }),
    [
      openAccountModal,
      openLoginModal,
      openSettingsModal,
      readyUser,
      requireAuth,
      logoutCurrentSession,
      status,
      settings.isHydratingSettings,
      settings.isPersistingSettings,
      settings.musicVolume,
      settings.platformTheme,
      settings.setMusicVolume,
      settings.setPlatformTheme,
      settings.settingsError,
    ],
  );

  if (status === 'checking' && !canKeepPlatformContentMounted) {
    return (
      <div
        className={`platform-theme ${platformThemeClass} flex min-h-screen items-center justify-center bg-[var(--platform-body-fill)] text-sm text-[var(--platform-text-base)]`}
      >
        正在校验登录状态...
      </div>
    );
  }

  if (status === 'recovering' && !canKeepPlatformContentMounted) {
    return (
      <div
        className={`platform-theme ${platformThemeClass} flex min-h-screen items-center justify-center bg-[var(--platform-body-fill)] text-sm text-[var(--platform-text-base)]`}
      >
        正在恢复登录状态...
      </div>
    );
  }

  if (status === 'pending_bind_phone' && user) {
    return (
      <BindPhoneScreen
        user={user}
        platformTheme={settings.platformTheme}
        sendingCode={sendingCode}
        binding={bindingPhone}
        error={error}
        captchaChallenge={bindCaptchaChallenge}
        onSendCode={async (phone, captcha) => {
          setSendingCode(true);
          setError('');
          try {
            const result = await sendPhoneLoginCode(
              phone,
              'bind_phone',
              captcha,
            );
            setBindCaptchaChallenge(null);
            return result;
          } catch (sendError) {
            const captchaChallenge = getCaptchaChallengeFromError(sendError);
            if (captchaChallenge) {
              setBindCaptchaChallenge(captchaChallenge);
            }
            setError(
              sendError instanceof Error
                ? sendError.message
                : '发送验证码失败，请稍后再试。',
            );
            throw sendError;
          } finally {
            setSendingCode(false);
          }
        }}
        onSubmit={async (phone, code) => {
          setBindingPhone(true);
          setError('');
          try {
            const nextUser = await bindWechatPhone(phone, code);
            setBindCaptchaChallenge(null);
            activateReadyUser(nextUser);
          } catch (bindError) {
            setError(
              bindError instanceof Error
                ? bindError.message
                : '绑定手机号失败，请稍后再试。',
            );
          } finally {
            setBindingPhone(false);
          }
        }}
        onLogout={async () => {
          await logoutCurrentSession();
        }}
      />
    );
  }

  if (
    status !== 'ready' &&
    status !== 'unauthenticated' &&
    !canKeepPlatformContentMounted
  ) {
    return (
      <div
        className={`platform-theme ${platformThemeClass} flex min-h-screen items-center justify-center bg-[var(--platform-body-fill)] px-6 text-[var(--platform-text-base)]`}
      >
        <div className="platform-auth-card max-w-md rounded-3xl px-6 py-7 text-center">
          <div className="text-base font-medium text-[var(--platform-text-strong)]">
            登录状态异常
          </div>
          <div className="mt-3 text-sm leading-6 text-[var(--platform-text-base)]">
            {error || '账号恢复失败，请刷新页面后重试。'}
          </div>
          <button
            type="button"
            className="platform-button platform-button--primary mt-5"
            onClick={() => {
              window.location.reload();
            }}
          >
            重新尝试
          </button>
        </div>
      </div>
    );
  }

  return (
    <AuthUiContext.Provider value={authUiValue}>
      <div className="relative">
        <div className={`platform-theme ${platformThemeClass}`}>
          {readyUser ? (
            <AccountModal
              user={readyUser}
              isOpen={showSettingsModal}
              entryMode={settingsEntryMode}
              initialSection={initialSettingsSection}
              platformTheme={settings.platformTheme}
              riskBlocks={riskBlocks}
              sessions={sessions}
              auditLogs={auditLogs}
              loadingRiskBlocks={loadingRiskBlocks}
              loadingSessions={loadingSessions}
              loadingAuditLogs={loadingAuditLogs}
              isHydratingSettings={settings.isHydratingSettings}
              isPersistingSettings={settings.isPersistingSettings}
              settingsError={settings.settingsError}
              onClose={closeSettingsModal}
              onPlatformThemeChange={settings.setPlatformTheme}
              onLogout={logoutCurrentSession}
              onRefreshRiskBlocks={async () => {
                setLoadingRiskBlocks(true);
                try {
                  setRiskBlocks(await getAuthRiskBlocks());
                } catch (blockError) {
                  setError(
                    blockError instanceof Error
                      ? blockError.message
                      : '读取安全状态失败，请稍后再试。',
                  );
                } finally {
                  setLoadingRiskBlocks(false);
                }
              }}
              onLiftRiskBlock={async (scopeType) => {
                try {
                  await liftAuthRiskBlock(scopeType);
                  setRiskBlocks(await getAuthRiskBlocks());
                  setAuditLogs(await getAuthAuditLogs());
                } catch (liftError) {
                  setError(
                    liftError instanceof Error
                      ? liftError.message
                      : '解除保护失败，请稍后再试。',
                  );
                }
              }}
              onRefreshSessions={async () => {
                setLoadingSessions(true);
                try {
                  setSessions(await getAuthSessions());
                } catch (sessionError) {
                  setError(
                    sessionError instanceof Error
                      ? sessionError.message
                      : '读取登录设备失败，请稍后再试。',
                  );
                } finally {
                  setLoadingSessions(false);
                }
              }}
              onRefreshAuditLogs={async () => {
                setLoadingAuditLogs(true);
                try {
                  setAuditLogs(await getAuthAuditLogs());
                } catch (auditError) {
                  setError(
                    auditError instanceof Error
                      ? auditError.message
                      : '读取账号操作记录失败，请稍后再试。',
                  );
                } finally {
                  setLoadingAuditLogs(false);
                }
              }}
              onRevokeSession={async (sessionId) => {
                try {
                  await revokeAuthSession(sessionId);
                  setSessions((current) =>
                    current.filter(
                      (session) => session.sessionId !== sessionId,
                    ),
                  );
                  setAuditLogs(await getAuthAuditLogs());
                } catch (revokeError) {
                  setError(
                    revokeError instanceof Error
                      ? revokeError.message
                      : '移除登录设备失败，请稍后再试。',
                  );
                }
              }}
              onLogoutAll={logoutAllSessions}
              changePhoneCaptchaChallenge={changePhoneCaptchaChallenge}
              onSendChangePhoneCode={async (phone, captcha) => {
                try {
                  const result = await sendPhoneLoginCode(
                    phone,
                    'change_phone',
                    captcha,
                  );
                  setChangePhoneCaptchaChallenge(null);
                  return result;
                } catch (sendError) {
                  const captchaChallenge =
                    getCaptchaChallengeFromError(sendError);
                  if (captchaChallenge) {
                    setChangePhoneCaptchaChallenge(captchaChallenge);
                  }
                  throw sendError;
                }
              }}
              onChangePhone={async (phone, code) => {
                const nextUser = await changePhoneNumber(phone, code);
                setChangePhoneCaptchaChallenge(null);
                setUser(nextUser);
              }}
              onChangePassword={async (currentPassword, newPassword) => {
                const nextUser = await changePassword(
                  currentPassword,
                  newPassword,
                );
                setUser(nextUser);
              }}
            />
          ) : null}
          <LoginScreen
            isOpen={showLoginModal}
            platformTheme={settings.platformTheme}
            availableLoginMethods={availableLoginMethods}
            sendingCode={sendingCode}
            loggingIn={loggingIn}
            wechatLoading={wechatLoading}
            error={error}
            captchaChallenge={loginCaptchaChallenge}
            onClose={closeLoginModal}
            onSendCode={async (phone, scene, captcha) => {
              setSendingCode(true);
              setError('');
              try {
                const result = await sendPhoneLoginCode(phone, scene, captcha);
                setLoginCaptchaChallenge(null);
                return result;
              } catch (sendError) {
                const captchaChallenge =
                  getCaptchaChallengeFromError(sendError);
                if (captchaChallenge) {
                  setLoginCaptchaChallenge(captchaChallenge);
                }
                setError(
                  sendError instanceof Error
                    ? sendError.message
                    : '发送验证码失败，请稍后再试。',
                );
                throw sendError;
              } finally {
                setSendingCode(false);
              }
            }}
            onPhoneSubmit={async (phone, code) => {
              setLoggingIn(true);
              setError('');
              try {
                const response = await loginWithPhoneCode(phone, code);
                setStoredLastLoginPhone(phone);
                setLoginCaptchaChallenge(null);
                setShowRegistrationInviteModal(response.created);
                setRegistrationInviteError('');
                activateReadyUser(response.user);
              } catch (loginError) {
                setError(
                  loginError instanceof Error
                    ? loginError.message
                    : '登录失败，请稍后再试。',
                );
              } finally {
                setLoggingIn(false);
              }
            }}
            onPasswordSubmit={async (phone, password) => {
              setLoggingIn(true);
              setError('');
              try {
                const nextUser = await authEntry(phone, password);
                setStoredLastLoginPhone(phone);
                activateReadyUser(nextUser);
              } catch (loginError) {
                setError(
                  loginError instanceof Error
                    ? loginError.message
                    : '登录失败，请稍后再试。',
                );
              } finally {
                setLoggingIn(false);
              }
            }}
            onResetPassword={async (phone, code, newPassword) => {
              setLoggingIn(true);
              setError('');
              try {
                const nextUser = await resetPassword(phone, code, newPassword);
                setStoredLastLoginPhone(phone);
                activateReadyUser(nextUser);
              } catch (resetError) {
                setError(
                  resetError instanceof Error
                    ? resetError.message
                    : '重置密码失败，请稍后再试。',
                );
              } finally {
                setLoggingIn(false);
              }
            }}
            onStartWechatLogin={async () => {
              setWechatLoading(true);
              setError('');
              try {
                await startWechatLogin();
              } catch (wechatError) {
                setError(
                  wechatError instanceof Error
                    ? wechatError.message
                    : '微信登录暂不可用，请稍后再试。',
                );
              } finally {
                setWechatLoading(false);
              }
            }}
          />
          <RegistrationInviteModal
            isOpen={showRegistrationInviteModal}
            platformTheme={settings.platformTheme}
            initialInviteCode={pendingInviteCode}
            submitting={submittingRegistrationInvite}
            error={registrationInviteError}
            onClose={closeRegistrationInviteModal}
            onSubmit={async (inviteCode) => {
              setSubmittingRegistrationInvite(true);
              setRegistrationInviteError('');
              try {
                await redeemRegistrationInviteCode(inviteCode);
                closeRegistrationInviteModal();
              } catch (inviteError) {
                setRegistrationInviteError(
                  inviteError instanceof Error
                    ? inviteError.message
                    : '填写邀请码失败，请稍后再试。',
                );
              } finally {
                setSubmittingRegistrationInvite(false);
              }
            }}
          />
        </div>
        {children}
      </div>
    </AuthUiContext.Provider>
  );
}
