/**
 * 认证服务核心实现
 * 
 * 这个文件包含了用户认证、会话管理、Token 刷新等核心功能的具体实现。
 * 
 * 主要功能：
 * - 基于 Cookie 的会话管理
 * - OAuth2.0 Token 自动刷新
 * - 用户登录状态检查
 * - 会话创建和销毁
 * - 用户信息保存到数据库
 * 
 * 技术栈：
 * - Remix Session Storage (Cookie-based)
 * - OAuth2.0 Token Management
 * - TypeScript 类型安全
 * 
 */

import { createCookieSessionStorage } from "@remix-run/node";
import { tokenManager } from "./token-manager.server";
import { postgrestGet, postgrestPost, postgrestPut } from "../postgrest-client";
import { JWTUtils, type UserInfoForJWT } from "~/utils/jwt";
import { OAUTH_CONFIG, API_BASE_URL } from "~/config/api-config";

/**
 * 用户角色类型定义
 * 
 * @typedef {string} UserRole
 * @property {'common'} common - 普通用户，有基本的系统访问权限
 * @property {'developer'} developer - 开发者/管理员，有完整的系统管理权限
 */
export type UserRole = 'common' | 'admin' | 'deptLeader' | 'groupLeader';

/**
 * 用户信息接口，对应 sso_users 表结构
 */
export interface UserInfo {
  sub: string;           // IDaaS用户唯一标识
  username?: string;     // 显示用户名称/工号
  nick_name?: string;    // 用户真实姓名
  nickname?: string;     // OAuth返回的昵称字段
  name?: string;         // 用户姓名（通常映射到 nick_name）
  phone_number?: string; // 手机号
  email?: string;        // 邮箱地址
  ou_id?: string;        // 所属组织单位ID
  ou_name?: string;      // 所属部门名称
  status?: number;       // 账户状态: 0=正常, 1=禁用
  is_leader?: boolean;   // 是否为部门负责人
  area?: string;         // 用户所属地区
}

/**
 * sso_users 表记录接口
 */
export interface SsoUser {
  id?: string;
  sub: string;
  username: string;
  nick_name: string;
  phone_number?: string;
  email?: string;
  ou_id: string;
  ou_name: string;
  status: number;
  is_leader: boolean;
  area?: string;
  created_at?: string;
  updated_at?: string;
  deleted_at?: string;
}

/**
 * 会话存储配置
 * 
 * 使用 Remix 的 Cookie Session Storage 来管理用户会话。
 * Cookie 存储方式的优势：
 * - 服务器端控制，安全性高
 * - 自动处理过期时间
 * - 支持 HttpOnly，防止 XSS 攻击
 * 
 * 配置说明：
 * - name: Cookie 名称，用于标识会话
 * - httpOnly: 防止客户端 JavaScript 访问，提高安全性
 * - sameSite: CSRF 保护
 * - secrets: 用于签名和加密 Cookie 内容
 * - maxAge: 会话有效期，与 OAuth Token 过期时间保持一致
 */
export const sessionStorage = createCookieSessionStorage({
  cookie: {
    name: "__lgsession", // 登录会话 Cookie 名称
    httpOnly: true, // 仅服务器端可访问，防止 XSS
    path: "/", // Cookie 作用域为整个应用
    sameSite: "lax", // CSRF 保护，允许顶级导航
    secrets: ["s3cr3t"], // TODO: 应该从环境变量读取
    maxAge: 60 * 60 * 2, // 2小时，与 OAuth Token 同步
    secure: false, // 开发环境中禁用 HTTPS 要求
  },
});

/**
 * 获取会话对象
 * 
 * 从请求中提取 Cookie 并获取对应的会话对象。
 * 这是一个底层函数，通常不直接使用，而是通过 getUserSession 使用。
 * 
 * @param request - Remix Request 对象，包含 HTTP 请求信息
 * @returns 会话对象，可以用来读取和设置会话数据
 */
export async function getSession(request: Request) {
  const cookie = request.headers.get("Cookie");
  return sessionStorage.getSession(cookie);
}

/**
 * 获取用户登录状态（带自动Token刷新）
 * 
 * 这是认证系统的核心函数，负责：
 * 1. 检查用户是否已登录
 * 2. 验证 OAuth Token 是否有效
 * 3. 自动刷新即将过期的 Token
 * 4. 返回用户信息和认证状态
 * 
 * Token 刷新机制：
 * - 检查 access_token 是否即将过期（距离过期时间 < 5 分钟）
 * - 如果即将过期，使用 refresh_token 自动获取新的 access_token
 * - 如果刷新失败，则认为用户未登录
 * 
 * @param request - Remix Request 对象
 * @returns 包含以下字段的对象：
 *   - isAuthenticated: 是否已认证
 *   - userRole: 用户角色 ('common' | 'developer')
 *   - accessToken: OAuth 访问令牌
 *   - refreshToken: OAuth 刷新令牌
 *   - userInfo: 用户详细信息
 *   - isTokenExpired: Token 是否已过期
 *   - refreshedSession: 如果刷新了 Token，返回更新后的会话对象
 */
/**
 * 生成前端JWT
 * @param userInfo 用户信息
 * @param expiresIn OAuth token过期时间（秒）
 * @returns JWT字符串
 */
async function generateFrontendJWT(userInfo: UserInfo, savedUserData: SsoUser, userRole: UserRole, expiresIn: number): Promise<string> {
  const jwtUserInfo: UserInfoForJWT = {
    sub: userInfo.sub,
    user_id: savedUserData.id!,
    username: savedUserData.username,
    nick_name: savedUserData.nick_name,
    email: savedUserData.email,
    phone_number: savedUserData.phone_number,
    ou_id: savedUserData.ou_id,
    ou_name: savedUserData.ou_name,
    is_leader: savedUserData.is_leader,
    user_role: userRole
  };

  return JWTUtils.generateJWT(jwtUserInfo, expiresIn);
}

/**
 * 创建包含JWT的用户信息对象
 * @param userInfo OAuth用户信息
 * @param savedUserData 数据库中保存的用户数据
 * @param userRole 用户角色
 * @param frontendJWT 前端JWT
 * @returns 完整的用户信息对象
 */
function createUserInfoWithJWT(userInfo: UserInfo, savedUserData: SsoUser, userRole: UserRole, frontendJWT: string) {
  return {
    // 保持与callback.tsx中enhancedUserInfo相同的数据结构
    sub: userInfo.sub,
    username: savedUserData.username,
    nick_name: savedUserData.nick_name,
    phone_number: savedUserData.phone_number,
    email: savedUserData.email,
    ou_id: savedUserData.ou_id,
    ou_name: savedUserData.ou_name,
    status: savedUserData.status,
    is_leader: savedUserData.is_leader,
    // 增强字段，与OAuth登录保持一致
    user_id: savedUserData.id,
    user_role: userRole,
    frontend_jwt: frontendJWT
  };
}

export async function getUserSession(request: Request) {
  const session = await getSession(request);
  const isAuthenticated = session.get("isAuthenticated") === true;
  const userRole = session.get("userRole") as UserRole;
  let accessToken = session.get("accessToken");
  const refreshToken = session.get("refreshToken");
  let tokenIssuedAt = session.get("tokenIssuedAt");
  let tokenExpiresIn = session.get("tokenExpiresIn");
  const userInfo = session.get("userInfo");
  let frontendJWT = session.get("frontendJWT");
  
  let isTokenExpired = false;
  let refreshedSession = null;
  let shouldRegenerateJWT = false;
  
  // 如果有token信息，检查是否需要刷新
  if (accessToken && refreshToken && tokenIssuedAt && tokenExpiresIn) {
    try {
      const tokenInfo = {
        accessToken,
        refreshToken,
        tokenIssuedAt,
        tokenExpiresIn
      };

      // 检查并自动刷新token
      const refreshResult = await tokenManager.checkAndRefreshToken(tokenInfo);
      
      if (refreshResult.success && refreshResult.newTokenInfo) {
        const newToken = refreshResult.newTokenInfo;
        
        // 如果token被刷新了，更新session
        if (newToken.accessToken !== accessToken) {
          console.log("Token已刷新，更新session");
          
          session.set("accessToken", newToken.accessToken);
          session.set("refreshToken", newToken.refreshToken);
          session.set("tokenIssuedAt", newToken.tokenIssuedAt);
          session.set("tokenExpiresIn", newToken.tokenExpiresIn);
          
          // 更新本地变量
          accessToken = newToken.accessToken;
          tokenIssuedAt = newToken.tokenIssuedAt;
          tokenExpiresIn = newToken.tokenExpiresIn;
          
          // 标记需要重新生成JWT
          shouldRegenerateJWT = true;
          
          refreshedSession = session;
        }
        
        isTokenExpired = false;
      } else {
        console.error("Token刷新失败:", refreshResult.error);
        isTokenExpired = true;
      }
    } catch (error) {
      console.error("Token验证过程中出错:", error);
      isTokenExpired = true;
    }
  }
  
  // 检查前端JWT状态
  if (isAuthenticated && !isTokenExpired && userInfo) {
    let needsJWTRefresh = false;
    
    // 检查是否有前端JWT
    if (!frontendJWT) {
      needsJWTRefresh = true;
      console.log("缺少前端JWT，需要生成");
    } else {
      // 检查JWT是否即将过期
      if (JWTUtils.isJWTExpiringSoon(frontendJWT)) {
        needsJWTRefresh = true;
        console.log("前端JWT即将过期，需要重新生成");
      }
    }
    
    // 如果OAuth token被刷新了，也需要重新生成JWT
    if (shouldRegenerateJWT) {
      needsJWTRefresh = true;
      console.log("OAuth token已刷新，需要重新生成JWT");
    }
    
    // 重新生成JWT
    if (needsJWTRefresh && tokenExpiresIn) {
      try {
        // 从userInfo中获取用户数据
        if (userInfo.user_id && userInfo.sub) {
          const mockSavedUserData: SsoUser = {
            id: userInfo.user_id,
            sub: userInfo.sub,
            username: userInfo.username || userInfo.sub,
            nick_name: userInfo.nick_name || "未知用户",
            phone_number: userInfo.phone_number,
            email: userInfo.email,
            ou_id: userInfo.ou_id || "default",
            ou_name: userInfo.ou_name || "未知部门",
            status: 0,
            is_leader: userInfo.is_leader || false
          };
          
          const newJWT = await generateFrontendJWT(userInfo, mockSavedUserData, userRole, tokenExpiresIn);
          
          // 打印JWT重新生成信息
          console.log("=== Token刷新时重新生成JWT ===");
          // console.log("原始userInfo:", userInfo);
          // console.log("重构的用户数据:", mockSavedUserData);
          // console.log("用户角色:", userRole);
          // console.log("新生成的JWT:", newJWT);
          // console.log("JWT过期时间:", JWTUtils.getJWTExpiration(newJWT));
          
          // 更新session中的JWT
          if (!refreshedSession) {
            refreshedSession = session;
          }
          refreshedSession.set("frontendJWT", newJWT);
          
          // 更新userInfo以包含新的JWT
          const updatedUserInfo = createUserInfoWithJWT(userInfo, mockSavedUserData, userRole, newJWT);
          refreshedSession.set("userInfo", updatedUserInfo);
          
          console.log("更新后的userInfo:", updatedUserInfo);
          console.log("=== JWT重新生成完成 ===");
          
          frontendJWT = newJWT;
        }
      } catch (error) {
        console.error("生成前端JWT失败:", error);
      }
    }
  }
  
  return {
    isAuthenticated: isAuthenticated && !isTokenExpired,
    userRole,
    accessToken,
    refreshToken,
    userInfo,
    isTokenExpired,
    refreshedSession, // 如果刷新了token，返回更新后的session
    frontendJWT // 返回前端JWT
  };
}

/**
 * 创建用户登录会话（完整版）
 * 
 * 在用户成功登录后调用此函数来创建完整的会话并设置 Cookie。
 * 这个函数支持完整的OAuth2.0登录流程，包括token管理和用户信息存储。
 * 
 * 处理流程：
 * 1. 创建新的会话对象
 * 2. 设置认证状态、用户角色、token信息
 * 3. 保存用户信息和前端JWT
 * 4. 生成签名的 Cookie
 * 5. 返回重定向响应并设置 Cookie
 * 
 * @param params - 会话创建参数
 * @returns HTTP 302 重定向响应，包含设置 Cookie 的头部
 */
export async function createUserSession(params: {
  isAuthenticated: boolean;
  userRole: UserRole;
  redirectTo: string;
  accessToken?: string;
  refreshToken?: string;
  tokenExpiresIn?: number;
  userInfo?: UserInfo;
  frontendJWT?: string;
}) {
  const session = await sessionStorage.getSession();
  
  // 基础认证信息
  session.set("isAuthenticated", params.isAuthenticated);
  session.set("userRole", params.userRole);
  
  // OAuth token信息
  if (params.accessToken) {
    session.set("accessToken", params.accessToken);
    session.set("tokenIssuedAt", Date.now());
  }
  if (params.refreshToken) {
    session.set("refreshToken", params.refreshToken);
  }
  if (params.tokenExpiresIn) {
    session.set("tokenExpiresIn", params.tokenExpiresIn);
  }
  
  // 用户信息和JWT
  if (params.userInfo) {
    session.set("userInfo", params.userInfo);
  }
  if (params.frontendJWT) {
    session.set("frontendJWT", params.frontendJWT);
  }
  
  const cookie = await sessionStorage.commitSession(session);
  // console.log("创建完整会话 - 设置Cookie:", !!cookie);
  // console.log("创建完整会话 - 用户角色:", params.userRole);
  // console.log("创建完整会话 - 重定向到:", params.redirectTo);
  
  return new Response(null, {
    status: 302, // HTTP 重定向状态码
    headers: {
      Location: params.redirectTo, // 重定向目标 URL
      "Set-Cookie": cookie, // 设置会话 Cookie
    },
  });
}

/**
 * 创建用户登录会话（简化版）
 * 
 * 在用户成功登录后调用此函数来创建会话并设置 Cookie。
 * 这个函数通常在以下场景中使用：
 * - 临时管理员登录
 * - 测试用户登录
 * - 其他简单认证方式成功后
 * 
 * 处理流程：
 * 1. 创建新的会话对象
 * 2. 设置认证状态和用户角色
 * 3. 生成签名的 Cookie
 * 4. 返回重定向响应并设置 Cookie
 * 
 * @param isAuthenticated - 是否已认证，通常为 true
 * @param userRole - 用户角色，决定用户的权限级别
 * @param redirectTo - 登录成功后重定向的 URL，默认为首页
 * @returns HTTP 302 重定向响应，包含设置 Cookie 的头部
 */
export async function createSimpleUserSession(isAuthenticated: boolean, userRole: UserRole, redirectTo: string) {
  const session = await sessionStorage.getSession();
  session.set("isAuthenticated", isAuthenticated);
  session.set("userRole", userRole);
  
  const cookie = await sessionStorage.commitSession(session);
  console.log("创建简化会话 - 设置Cookie:", !!cookie);
  console.log("创建简化会话 - 用户角色:", userRole);
  console.log("创建简化会话 - 重定向到:", redirectTo);
  
  return new Response(null, {
    status: 302, // HTTP 重定向状态码
    headers: {
      Location: redirectTo, // 重定向目标 URL
      "Set-Cookie": cookie, // 设置会话 Cookie
    },
  });
}

/**
 * 销毁会话（用户登出）
 * 
 * 当用户主动登出或会话失效时调用此函数。
 * 
 * 处理流程：
 * 1. 获取当前用户的会话和访问令牌
 * 2. 调用 IDaaS 单点登出接口
 * 3. 销毁本地会话数据（清除所有存储的信息）
 * 4. 清除客户端的会话 Cookie
 * 5. 重定向到登录页面
 * 
 * 注意事项：
 * - 这个函数会同时处理本地会话和 IDaaS 的单点登出
 * - 即使 IDaaS 登出失败，也会清除本地会话
 * - 销毁会话后，用户需要重新登录才能访问受保护的页面
 * 
 * @param request - Remix Request 对象，用于获取当前会话
 * @returns HTTP 302 重定向响应，清除 Cookie 并跳转到登录页
 */
export async function logout(request: Request) {
  const session = await getSession(request);
  
  // 获取访问令牌和应用ID，用于调用IDaaS单点登出
  const accessToken = session.get("accessToken");
  const appId = OAUTH_CONFIG.appId;
  
  // 如果存在访问令牌，调用IDaaS单点登出
  if (accessToken && appId) {
    try {
      await callIDaaSLogout(accessToken, appId);
      console.log("IDaaS单点登出成功");
    } catch (error) {
      console.error("IDaaS单点登出失败:", error);
      // 即使IDaaS登出失败，也继续清除本地会话
    }
  }

  return new Response(null, {
    status: 302, // HTTP 重定向状态码
    headers: {
      Location: "/login", // 重定向到登录页面
      "Set-Cookie": await sessionStorage.destroySession(session), // 清除会话 Cookie
    },
  });
}

/**
 * 调用IDaaS单点登出接口
 * 
 * @param accessToken - 用户的访问令牌
 * @param appId - 应用ID
 * @returns Promise<void>
 */
async function callIDaaSLogout(accessToken: string, appId: string): Promise<void> {
  const logoutUrl = `${OAUTH_CONFIG.serverUrl}/public/sp/slo/${appId}`;
  
  const formData = new URLSearchParams();
  formData.append('access_token', accessToken);
  formData.append('redirect_url', encodeURIComponent(OAUTH_CONFIG.redirectUri));
  
  try {
    const response = await fetch(logoutUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
      },
      body: formData.toString(),
    });
    
    if (!response.ok) {
      throw new Error(`IDaaS登出失败: ${response.status} ${response.statusText}`);
    }
    
    console.log("IDaaS单点登出请求成功");
  } catch (error) {
    console.error("调用IDaaS登出接口失败:", error);
    throw error;
  }
}

/**
 * 保存用户信息到数据库
 *
 * 此函数实现以下逻辑：
 * 1. 根据 userInfo.sub 查询 sso_users 表中是否已存在该用户
 * 2. 如果存在，则更新用户信息（如果用户已有 area 值则不更新）
 * 3. 如果不存在，则插入新的用户记录
 *
 * @param userInfo - 从 IDaaS 获取的用户信息
 * @param token - JWT令牌
 * @param area - 用户所属地区，根据端口号确定
 * @returns Promise<{success: boolean, data?: SsoUser, error?: string}>
 */
export async function saveUserInfo(userInfo: UserInfo, token?: string, area?: string): Promise<{success: boolean, data?: SsoUser, error?: string}> {
  try {
    console.log("开始保存用户信息", userInfo);

    // 验证必要字段
    if (!userInfo.sub) {
      return { success: false, error: "用户唯一标识 sub 不能为空" };
    }

    // 1. 根据 sub 查询是否已存在该用户
    const existingUserResult = await postgrestGet<SsoUser[]>("sso_users", {
      filter: {
        "sub": `eq.${userInfo.sub}`,
        "deleted_at": "is.null" // 只查询未删除的记录
      },
      token
    });

    if (existingUserResult.error) {
      console.error("查询用户失败:", existingUserResult.error);
      return { success: false, error: `查询用户失败: ${existingUserResult.error}` };
    }

    const existingUsers = existingUserResult.data || [];
    const existingUser = existingUsers.length > 0 ? existingUsers[0] : null;

    // 准备要保存的用户数据
    // 注意：OAuth返回的字段是nickname，而不是nick_name
    const userData: Partial<SsoUser> = {
      sub: userInfo.sub,
      username: userInfo.username || userInfo.name || userInfo.sub,
      nick_name: userInfo.nick_name || userInfo.nickname || userInfo.name || "未知用户",
      phone_number: userInfo.phone_number || undefined,
      email: userInfo.email || undefined,
      ou_id: userInfo.ou_id || "default",
      ou_name: userInfo.ou_name || "未知部门",
      status: userInfo.status !== undefined ? userInfo.status : 0,
      is_leader: userInfo.is_leader || false,
    };

    if (existingUser) {
      // 2. 用户已存在，执行更新操作
      console.log("用户已存在，执行更新操作", existingUser.id);

      // 只有在现有用户没有 area 或 area 为空时，才更新 area
      if (area && !existingUser.area) {
        userData.area = area;
        console.log("用户原本无地区信息，更新地区为:", area);
      } else if (existingUser.area) {
        console.log("用户已有地区信息:", existingUser.area, "不更新");
      }

      const updateResult = await postgrestPut<SsoUser[], Partial<SsoUser>>(
        "sso_users",
        userData,
        { id: existingUser.id! },
        token
      );

      if (updateResult.error) {
        console.error("更新用户失败:", updateResult.error);
        return { success: false, error: `更新用户失败: ${updateResult.error}` };
      }

      console.log("用户信息更新成功");
      return {
        success: true,
        data: Array.isArray(updateResult.data) ? updateResult.data[0] : updateResult.data as unknown as SsoUser
      };
    } else {
      // 3. 用户不存在，执行插入操作，设置地区信息
      console.log("用户不存在，执行插入操作");

      // 新用户直接设置 area
      if (area) {
        userData.area = area;
        console.log("新用户，设置地区为:", area);
      }

      const insertResult = await postgrestPost<SsoUser[], SsoUser>("sso_users", userData as SsoUser, token);

      if (insertResult.error) {
        console.error("插入用户失败:", insertResult.error);
        return { success: false, error: `插入用户失败: ${insertResult.error}` };
      }

      console.log("用户信息插入成功");

      // 4. 给这个用户默认添加一个角色，角色为common
      const userData_with_id = Array.isArray(insertResult.data) ? insertResult.data[0] : insertResult.data as unknown as SsoUser;
      if (userData_with_id?.id) {
        await addDefaultRole(userData_with_id.id, 2, token);
      }

      return {
        success: true,
        data: userData_with_id
      };
    }
  } catch (error) {
    console.error("保存用户信息时发生错误:", error);
    return { 
      success: false, 
      error: `保存用户信息失败: ${error instanceof Error ? error.message : String(error)}` 
    };
  }
}

/**
 * 为用户添加默认角色
 *
 * @param userId - 用户ID
 * @param roleId - 角色ID，默认为2（common角色）
 * @param token - JWT令牌，用于调用postgrest服务
 * @returns 添加结果
 */
export async function addDefaultRole(userId: string, roleId: number = 2, token?: string) {
  try {
    console.log(`为用户 ${userId} 添加默认角色 ${roleId}`);

    // 检查用户是否已经有此角色
    const existingRoleResult = await postgrestGet<Array<{id: number, user_id: string, role_id: number}>>("user_role", {
      filter: {
        user_id: `eq.${userId}`,
        role_id: `eq.${roleId}`
      },
      token
    });

    if (existingRoleResult.error) {
      console.error("查询用户角色失败:", existingRoleResult.error);
      return { success: false, error: `查询用户角色失败: ${existingRoleResult.error}` };
    }

    const existingRoles = existingRoleResult.data || [];
    if (existingRoles.length > 0) {
      console.log("用户已经拥有此角色，跳过添加");
      return { success: true, data: existingRoles[0] };
    }

    // 添加角色
    const addRoleResult = await postgrestPost<Array<{id: number, user_id: string, role_id: number}>, {user_id: string, role_id: number}>("user_role", {
      user_id: userId,
      role_id: roleId
    }, token);

    if (addRoleResult.error) {
      console.error("添加用户角色失败:", addRoleResult.error);
      return { success: false, error: `添加用户角色失败: ${addRoleResult.error}` };
    }

    console.log("用户角色添加成功");
    return { 
      success: true, 
      data: Array.isArray(addRoleResult.data) ? addRoleResult.data[0] : addRoleResult.data
    };
  } catch (error) {
    console.error("添加用户角色时发生错误:", error);
    return { 
      success: false, 
      error: `添加用户角色失败: ${error instanceof Error ? error.message : String(error)}` 
    };
  }
}

/**
 * 通过用户sub获取用户信息
 * 
 * @param sub - 用户的唯一标识
 * @returns 用户信息
 */
export async function getUserBySub(sub: string) {
  try {
    // console.log(`查询用户: ${sub}`);
    
    const userResult = await postgrestGet<SsoUser[]>("sso_users", { 
      filter: { 
        sub: `eq.${sub}` 
      } 
    });

    if (userResult.error) {
      console.error("查询用户失败:", userResult.error);
      return { success: false, error: `查询用户失败: ${userResult.error}` };
    }

    const users = userResult.data || [];
    const user = users.length > 0 ? users[0] : null;

    if (!user) {
      return { success: false, error: "用户不存在" };
    }

    return { success: true, data: user };
  } catch (error) {
    console.error("查询用户时发生错误:", error);
    return { 
      success: false, 
      error: `查询用户失败: ${error instanceof Error ? error.message : String(error)}` 
    };
  }
}

/**
 * 账号密码登录接口
 * 
 * @param username - 用户名
 * @param password - 密码
 * @param redirectTo - 登录成功后重定向的URL
 * @returns HTTP重定向响应或错误响应
 */
export async function simpleRootLogin(
  username: string,
  password: string,
  redirectTo: string
) {
  try {
    // 输入验证
    if (!username?.trim() || !password?.trim()) {
      return new Response(JSON.stringify({
        success: false,
        error: "用户名和密码不能为空"
      }), {
        status: 400,
        headers: { "Content-Type": "application/json" }
      });
    }

    // 调用登录接口
    const loginResponse = await fetch(`${API_BASE_URL}/password_login`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        sub: username.trim(),
        password: password.trim()
      })
    });

    const loginResult = await loginResponse.json();
    console.log('登录接口返回', loginResult);
    
    // 检查重试次数
    const retryCount = loginResult.retryCount || loginResult.retry_count || 0;
    console.log('登录重试次数:', retryCount);

    if (loginResult.code === 0 && loginResult.data) {
      // 登录成功，构建用户信息
      const userData = loginResult.data;
      // console.log('管理员登录userData', userData);
      const userRole = userData.role; // 默认角色
      
      // 生成模拟的OAuth token信息
      const mockTokenExpiresIn = 7200; // 2小时
      const mockAccessToken = `mock_access_token_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
      const mockRefreshToken = `mock_refresh_token_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
      
      // 生成前端JWT
      const jwtUserInfo: UserInfoForJWT = {
        sub: userData.sub,
        user_id: userData.user_id,
        username: userData.username,
        nick_name: userData.nick_name,
        email: userData.email,
        phone_number: userData.phone_number,
        ou_id: userData.ou_id,
        ou_name: userData.ou_name,
        is_leader: userData.is_leader,
        user_role: userRole
      };
      
      const frontendJWT = JWTUtils.generateJWT(jwtUserInfo, mockTokenExpiresIn);
      
      // 构建增强的用户信息对象
      const enhancedUserInfo = {
        ...userData,
        user_id: userData.user_id,
        user_role: userRole,
        frontend_jwt: frontendJWT
      };

      // 使用统一的session创建函数
      return createUserSession({
        isAuthenticated: true,
        userRole: userRole,
        redirectTo,
        accessToken: mockAccessToken,
        refreshToken: mockRefreshToken,
        tokenExpiresIn: mockTokenExpiresIn,
        userInfo: enhancedUserInfo,
        frontendJWT
      });
    } else {
      // 登录失败，检查账户是否被锁定
      let errorMsg = loginResult.msg || "登录失败，请检查用户名和密码";
      let isLocked = false;
      
      // 检查是否因重试次数过多被锁定
      if (retryCount >= 5) {
        errorMsg = "账户已被锁定，密码错误次数过多，请联系管理员";
        isLocked = true;
      } else if (retryCount > 0) {
        // 显示剩余尝试次数
        const remainingAttempts = 5 - retryCount;
        errorMsg = `${loginResult.msg || "用户名或密码错误"}，还有 ${remainingAttempts} 次尝试机会`;
      }
      
      return new Response(JSON.stringify({
        success: false,
        error: errorMsg,
        retryCount: retryCount,
        isLocked: isLocked,
        remainingAttempts: isLocked ? 0 : (5 - retryCount)
      }), {
        status: isLocked ? 403 : 401, // 403 表示禁止访问（账户被锁）
        headers: { "Content-Type": "application/json" }
      });
    }
  } catch (error) {
    console.error("登录请求失败:", error);
    return new Response(JSON.stringify({
      success: false,
      error: "登录请求失败，请稍后重试"
    }), {
      status: 500,
      headers: { "Content-Type": "application/json" }
    });
  }
}