/**
 * Organization API
 * 组织架构管理统一 API（用户、部门、岗位、角色、权限、同步）
 */

import apiClient from '@/lib/api-client';
const ENABLE_DEMO_MOCK = process.env.NEXT_PUBLIC_PERFORMANCE_DEMO === 'true';

// ============================================
// Types - Users
// ============================================

export type UserStatus = 'ACTIVE' | 'INACTIVE' | 'SUSPENDED' | 'TERMINATED';
export type UserSource = 'LOCAL' | 'ENTRA' | 'LDAP';

export interface User {
  id: string;
  username: string;
  email: string;
  displayName: string;
  phone?: string | null;
  avatar?: string | null;
  status: UserStatus;
  source?: UserSource;
  employeeId?: string | null;
  region?: string | null;
  workCity?: string | null;
  
  // 主部门信息（向后兼容）
  department?: {
    id: string;
    name: string;
    code?: string;
  } | null;
  position?: {
    id: string;
    name: string;
    title?: string; // Alias for name, for backwards compatibility
    level?: number;
  } | null;
  manager?: {
    id: string;
    displayName: string;
    email?: string;
  } | null;
  
  // 多部门归属（新）
  departmentMemberships?: Array<{
    id: string;
    departmentId: string;
    positionId?: string | null;
    managerId?: string | null;
    isPrimary: boolean;
    title?: string | null;
    department?: {
      id: string;
      name: string;
      code?: string;
    };
    position?: {
      id: string;
      name: string;
      level?: number;
    };
    manager?: {
      id: string;
      displayName: string;
      email?: string;
    };
  }>;
  
  roles?: Array<{
    id: string;
    name: string;
    code: string;
  }>;
  hiredAt?: string | null;
  ldapSyncedAt?: string | null;
  deletedAt?: string | null;
  createdAt: string;
  updatedAt: string;

  // v2.4：SSO 绑定信息（来自 User 表 externalId / externalSource 列；
  // 后端 findOne 返回完整 user 对象时携带，前端只读展示）
  externalId?: string | null;
  externalSource?: string | null; // 'entra' | 'ldap' | null（小写枚举，与 schema 对齐）
}

export interface UserListResponse {
  items: User[];
  total: number;
  page: number;
  limit: number;
  totalPages: number;
  hasNext: boolean;
  hasPrev: boolean;
}

export interface UserQueryParams {
  page?: number;
  pageSize?: number;
  keyword?: string;
  status?: UserStatus;
  departmentId?: string;
  region?: string;
  sortBy?: string;
  sortOrder?: 'asc' | 'desc';
}

export interface CreateUserDto {
  username: string;
  email: string;
  password?: string; // LOCAL 用户必填，LDAP/ENTRA 用户不需要
  ldapUsername?: string; // v2.1.1: LDAP 用户必填（sAMAccountName）
  displayName: string;
  source?: UserSource; // 身份源：LOCAL, LDAP, ENTRA
  phone?: string;
  employeeId?: string;
  departmentId?: string;
  positionId?: string;
  managerId?: string;
  region?: string;
  hiredAt?: string;
}

export interface UpdateUserDto {
  displayName?: string;
  email?: string;
  phone?: string;
  employeeId?: string;
  departmentId?: string | null;
  positionId?: string | null;
  managerId?: string | null;
  region?: string;
  workCity?: string | null;
  status?: UserStatus;
}

export interface TerminateUserDto {
  reason?: string;
  terminatedAt?: string;
}

export interface ActivateUserDto {
  reason?: string;
}

export interface RestoreUserDto {
  reason?: string;
}

// ============================================
// Types - Regions
// ============================================

export interface Region {
  id: string;
  code: string;
  name: string;
  nameEn?: string | null;
  nameZh?: string | null;
  timezone?: string | null;
  currency?: string | null;
  locale?: string | null;
  isActive: boolean;
  order: number;
  metadata?: Record<string, any>;
  createdAt: string;
  updatedAt: string;
  defaultOrganization?: { // ✅ 新增：默认组织信息
    id: string;
    name: string;
    code: string;
  } | null;
  _count?: {
    departments: number;
  };
}

export interface RegionQueryParams {
  keyword?: string;
  isActive?: boolean;
}

export interface CreateRegionDto {
  code: string;
  name: string;
  nameEn?: string;
  nameZh?: string;
  timezone?: string;
  currency?: string;
  locale?: string;
  isActive?: boolean;
  order?: number;
}

export interface UpdateRegionDto {
  name?: string;
  nameEn?: string;
  nameZh?: string;
  timezone?: string;
  currency?: string;
  locale?: string;
  isActive?: boolean;
  order?: number;
}

// ============================================
// Types - Organizations (v2.0 新增：独立组织实体)
// ============================================

export type OrganizationStatus = 'ACTIVE' | 'INACTIVE' | 'SUSPENDED' | 'DISSOLVED';

export interface Organization {
  id: string;
  code: string;
  name: string;
  displayName?: string | null;
  nameEn?: string | null;
  nameZh?: string | null;
  legalName?: string | null;
  legalRepresentative?: string | null;
  registrationNumber?: string | null;
  taxId?: string | null;
  address?: string | null;
  phone?: string | null;
  email?: string | null;
  website?: string | null;
  description?: string | null;
  primaryRegionId: string;
  primaryRegion?: {
    id: string;
    code: string;
    name: string;
    timezone?: string | null;
  } | null;
  organizationRegions?: Array<{
    id: string;
    regionId: string;
    isPrimary: boolean;
    region: {
      id: string;
      code: string;
      name: string;
      timezone?: string | null;
    };
  }>;
  status: OrganizationStatus;
  isActive: boolean;
  order: number;
  establishedAt?: string | null;
  departmentCount?: number;
  employeeCount?: number;
  settings?: Record<string, any>;
  financialConfig?: Record<string, any>;
  complianceConfig?: Record<string, any>;
  createdAt: string;
  updatedAt: string;
}

export interface OrganizationListResponse {
  items: Organization[];
  total: number;
  page: number;
  limit: number;
  totalPages: number;
}

export interface OrganizationQueryParams {
  page?: number;
  limit?: number;
  search?: string;
  regionId?: string;
  status?: OrganizationStatus;
}

export interface CreateOrganizationDto {
  code: string;
  name: string;
  displayName?: string;
  nameEn?: string;
  nameZh?: string;
  legalName?: string;
  legalRepresentative?: string;
  registrationNumber?: string;
  taxId?: string;
  address?: string;
  phone?: string;
  email?: string;
  website?: string;
  primaryRegionId: string;
  operatingRegionIds?: string[];
  establishedAt?: string;
  settings?: Record<string, any>;
  financialConfig?: Record<string, any>;
  complianceConfig?: Record<string, any>;
  order?: number;
}

export interface UpdateOrganizationDto {
  name?: string;
  displayName?: string;
  nameEn?: string;
  nameZh?: string;
  legalName?: string;
  legalRepresentative?: string;
  registrationNumber?: string;
  taxId?: string;
  address?: string;
  phone?: string;
  email?: string;
  website?: string;
  description?: string;
  primaryRegionId?: string;
  operatingRegionIds?: string[];
  status?: OrganizationStatus;
  establishedAt?: string;
  settings?: Record<string, any>;
  financialConfig?: Record<string, any>;
  complianceConfig?: Record<string, any>;
  order?: number;
}

export interface OrganizationRegionDto {
  operatingRegionIds: string[];
  primaryRegionId?: string;
}

export interface OrganizationStats {
  organizationId: string;
  organizationName: string;
  organizationCode: string;
  totalEmployees: number;
  activeEmployees: number;
  inactiveEmployees: number;
  suspendedEmployees: number;
  terminatedEmployees: number;
  totalDepartments: number;
  topLevelDepartments: number;
  byDepartment?: Array<{
    departmentId: string;
    departmentName: string;
    departmentCode: string;
    count: number;
    activeCount: number;
    inactiveCount: number;
  }>;
}

// ============================================
// Types - Departments (部门/组织统一模型)
// ============================================
// parentId = null 表示顶级组织（通过 DepartmentRegion 关联多个区域）
// parentId != null 表示子部门

export interface DepartmentRegion {
  id: string;
  code: string;
  name: string;
  isDefault?: boolean; // 是否为该区域的默认组织
}

export interface Department {
  id: string;
  name: string;
  code: string;
  organizationId?: string; // 部门所属组织ID（v2.0）
  parentId?: string | null;
  headId?: string | null; // ✅ 修复：后端使用 headId
  head?: {  // ✅ 修复：后端返回 head 对象
    id: string;
    displayName: string;
    username?: string;
    email?: string;
    avatar?: string;
  } | null;
  // 兼容旧字段（前端内部可能还在用）
  managerId?: string | null;
  manager?: {
    id: string;
    displayName: string;
    username?: string;
    email?: string;
    avatar?: string;
  } | null;
  parent?: {
    id: string;
    name: string;
    code?: string;
  } | null;
  regions?: DepartmentRegion[]; // 关联的区域列表
  isRegionDefault?: boolean; // 是否为任一区域的默认组织
  description?: string | null;
  order: number;
  employeeCount?: number; // ✅ 后端返回的计算字段（来自 userMemberships）
  childCount?: number;
  children?: Department[];
  // ✅ 已废弃：后端不再返回 _count.users，改为 employeeCount
  _count?: {
    users?: number;
    children?: number;
  };
  metadata?: Record<string, any>;
  createdAt: string;
  updatedAt: string;
}

export interface DepartmentQueryParams {
  keyword?: string;
  regionId?: string; // 按区域 ID 过滤
  parentId?: string;
  topLevelOnly?: boolean;
}

export interface CreateDepartmentDto {
  organizationId?: string; // 部门所属组织ID（后端必填）
  name: string;
  code: string;
  parentId?: string;
  managerId?: string;
  regionIds?: string[]; // 区域 ID 数组
  defaultRegionId?: string; // 设为默认组织的区域 ID
  description?: string;
  order?: number;
}

export interface UpdateDepartmentDto {
  name?: string;
  parentId?: string | null;
  managerId?: string | null;
  regionIds?: string[]; // 区域 ID 数组
  defaultRegionId?: string; // 设为默认组织的区域 ID
  description?: string;
  order?: number;
}

// ============================================
// Types - Positions
// ============================================

export interface Position {
  id: string;
  name: string;
  code: string;
  level?: number;
  title?: string; // Alias for name, for backwards compatibility
  description?: string | null;
  userCount?: number;
  createdAt: string;
  updatedAt: string;
}

export interface PositionQueryParams {
  keyword?: string;
  sortBy?: string;
  sortOrder?: 'asc' | 'desc';
}

export interface CreatePositionDto {
  name: string;
  code: string;
  level?: number;
  description?: string;
}

export interface UpdatePositionDto {
  name?: string;
  level?: number;
  description?: string;
}

// ============================================
// Types - Roles
// ============================================

export interface Role {
  id: string;
  name: string;
  code: string;
  description?: string | null;
  isBuiltIn: boolean;
  enabled: boolean;
  userCount?: number;
  permissionCount?: number;
  createdAt: string;
  updatedAt: string;
}

export interface RoleDetail extends Role {
  permissions?: Permission[];
  users?: User[];
}

export interface CreateRoleDto {
  name: string;
  code: string;
  description?: string;
  permissionIds?: string[];
}

export interface UpdateRoleDto {
  name?: string;
  code?: string;
  description?: string;
  permissionIds?: string[];
}

// ============================================
// Types - Permissions
// ============================================

export interface Permission {
  id: string;
  resource: string;
  action: string;
  description?: string | null;
  module?: string | null;
  isBuiltIn: boolean;
  createdAt: string;
  updatedAt: string;
}

export interface PermissionGroup {
  resource: string;
  resourceName: string;
  module?: string;
  permissions: Permission[];
}

// ============================================
// Types - Workflow Roles
// ============================================

export type WorkflowRuleType = 
  | 'ORGANIZATION_RELATION' 
  | 'SYSTEM_ROLE_MAPPING' 
  | 'FIXED_USERS' 
  | 'DYNAMIC_SCRIPT';

export interface WorkflowRole {
  id: string;
  name: string;
  code: string;
  description?: string | null;
  ruleType: WorkflowRuleType;
  ruleConfig: Record<string, any>;
  userCount?: number;
  workflowCount?: number;
  createdAt: string;
  updatedAt: string;
}

export interface WorkflowRoleDetail extends WorkflowRole {
  userAssignments?: Array<{
    id: string;
    user: User;
  }>;
}

export interface CreateWorkflowRoleDto {
  name: string;
  code: string;
  description?: string;
  ruleType: WorkflowRuleType;
  ruleConfig: Record<string, any>;
}

export interface UpdateWorkflowRoleDto {
  name?: string;
  description?: string;
  ruleType?: WorkflowRuleType;
  ruleConfig?: Record<string, any>;
}

// ============================================
// Types - Sync
// ============================================

export interface SyncStatus {
  isSyncing: boolean;
  lastSyncTime?: string | null;
  lastSyncResult?: {
    success: boolean;
    totalUsers: number;
    syncedUsers: number;
    createdUsers: number;
    updatedUsers: number;
    skippedUsers: number;
    conflictUsers?: number;
    errors: string[];
    duration: number;
    timestamp: string;
  } | null;
}

export interface SyncResult {
  success: boolean;
  totalUsers: number;
  syncedUsers: number;
  createdUsers: number;
  updatedUsers: number;
  skippedUsers: number;
  conflictUsers?: number;
  errors: string[];
  duration: number;
  timestamp: string;
}

export interface EntraSyncExecution {
  id: string;
  status: 'PENDING' | 'RUNNING' | 'SUCCESS' | 'FAILED' | 'TIMEOUT' | 'CANCELLED';
  startedAt: string;
  completedAt: string | null;
  duration: number | null;
  triggerType: string;
  error: string | null;
  result: SyncResult | null;
  logs: string | null;
}

export interface EntraSyncExecutionQuery {
  page?: number;
  limit?: number;
  startDate?: string;
  endDate?: string;
  hideEmpty?: boolean;
}

export interface PaginatedEntraSyncExecutions {
  items: EntraSyncExecution[];
  total: number;
  page: number;
  limit: number;
}

export interface OrganizationStats {
  users: {
    total: number;
    active: number;
    inactive: number;
    suspended: number;
    terminated: number;
  };
  departments: {
    total: number;
    topLevel: number;
  };
  positions: {
    total: number;
  };
  roles: {
    system: number;
    workflow: number;
  };
  lastSyncTime?: string | null;
}

// ============================================
// Users API
// ============================================

/**
 * 获取用户列表
 */
export async function getUsers(params?: UserQueryParams): Promise<UserListResponse> {
  return apiClient.get('/users', { params });
}

/**
 * 获取已删除用户列表
 */
export async function getDeletedUsers(params?: UserQueryParams): Promise<UserListResponse> {
  return apiClient.get('/users', { 
    params: {
      ...params,
      status: 'TERMINATED',
      includeDeleted: true,
    }
  });
}

/**
 * 获取当前用户信息
 */
export async function getCurrentUser(): Promise<User> {
  return apiClient.get('/users/me');
}

/**
 * 获取用户详情
 */
export async function getUserById(id: string): Promise<User> {
  return apiClient.get(`/users/${id}`);
}

/**
 * 创建用户
 */
export async function createUser(data: CreateUserDto): Promise<User> {
  return apiClient.post('/users', data);
}

/**
 * 更新用户
 */
export async function updateUser(id: string, data: UpdateUserDto): Promise<User> {
  return apiClient.patch(`/users/${id}`, data);
}

/**
 * 删除用户（软删除）
 */
export async function deleteUser(id: string): Promise<void> {
  return apiClient.delete(`/users/${id}`);
}

/**
 * 修改当前用户密码
 */
export async function changePassword(oldPassword: string, newPassword: string): Promise<{ message: string }> {
  return apiClient.put('/auth/change-password', { oldPassword, newPassword });
}

/**
 * 重置用户密码（管理员）
 */
export async function resetUserPassword(userId: string, newPassword: string): Promise<{ message: string }> {
  return apiClient.post(`/users/${userId}/reset-password`, { newPassword });
}

/**
 * 获取用户角色
 */
export async function getUserRoles(userId: string): Promise<Role[]> {
  return apiClient.get(`/users/${userId}/roles`);
}

/**
 * 为用户分配角色
 */
export async function assignRolesToUser(userId: string, roleIds: string[]): Promise<any> {
  return apiClient.post(`/users/${userId}/roles`, { roleIds });
}

/**
 * 移除用户角色
 */
export async function removeRoleFromUser(userId: string, roleId: string): Promise<void> {
  return apiClient.delete(`/users/${userId}/roles/${roleId}`);
}

/**
 * 获取用户权限
 */
export interface UserPermission {
  resource: string;
  action: string;
  code: string;
  description?: string | null;
  sources?: string[];
}

export async function getUserPermissions(userId: string): Promise<{ userId: string; permissions: UserPermission[]; roles: Role[] }> {
  return apiClient.get(`/users/${userId}/permissions`);
}

/**
 * 获取用户下属
 */
export async function getUserSubordinates(userId: string): Promise<User[]> {
  return apiClient.get(`/users/${userId}/subordinates`);
}

/**
 * 用户离职
 */
export async function terminateUser(id: string, data?: TerminateUserDto): Promise<any> {
  return apiClient.post(`/users/${id}/terminate`, data || {});
}

/**
 * 激活用户
 */
export async function activateUser(id: string, data?: ActivateUserDto): Promise<any> {
  return apiClient.post(`/users/${id}/activate`, data || {});
}

/**
 * 恢复已删除用户（永久可恢复）
 */
export async function restoreUser(id: string, data?: RestoreUserDto): Promise<any> {
  return apiClient.post(`/users/${id}/restore`, data || {});
}

// ============================================
// Departments API
// ============================================

const DEMO_DEPARTMENTS: Department[] = [
  {
    id: 'dept-demo-1',
    code: 'PROD',
    name: '产品部',
    description: 'Demo 部门',
    organizationId: 'org-demo-1',
    order: 1,
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
    regions: [{ id: 'region-demo-1', code: 'CN', name: '中国区', isDefault: true }],
    _count: { users: 2, children: 1 },
  },
  {
    id: 'dept-demo-2',
    code: 'ENG',
    name: '研发部',
    description: 'Demo 部门',
    organizationId: 'org-demo-1',
    order: 2,
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
    regions: [{ id: 'region-demo-1', code: 'CN', name: '中国区' }],
    _count: { users: 3, children: 0 },
  },
];

/**
 * 获取部门列表
 */
export async function getDepartments(params?: DepartmentQueryParams): Promise<Department[]> {
  if (ENABLE_DEMO_MOCK) {
    const keyword = (params?.keyword || '').toLowerCase();
    const filtered = DEMO_DEPARTMENTS.filter((d) =>
      keyword ? [d.name, d.code, d.description || ''].some((v) => v.toLowerCase().includes(keyword)) : true,
    );
    return JSON.parse(JSON.stringify(filtered));
  }
  return apiClient.get('/departments', { params });
}

/**
 * 获取部门树
 * @param organizationId - 可选：指定顶级组织 ID，只返回该组织的部门树
 */
export async function getDepartmentTree(organizationId?: string): Promise<Department[]> {
  return apiClient.get('/departments/tree', { params: { organizationId } });
}

/**
 * 获取顶级组织列表（用于组织视角选择）
 * @param regionId - 可选：按区域 ID 过滤
 */
export async function getTopLevelOrganizations(regionId?: string): Promise<Department[]> {
  return apiClient.get('/departments/organizations', { params: { regionId } });
}

/**
 * 获取部门详情
 */
export async function getDepartmentById(id: string): Promise<Department> {
  return apiClient.get(`/departments/${id}`);
}

/**
 * 获取部门成员
 */
export async function getDepartmentMembers(id: string, includeSubDepartments?: boolean): Promise<User[]> {
  const params = includeSubDepartments ? { includeSubDepartments: 'true' } : {};
  return apiClient.get(`/departments/${id}/members`, { params });
}

/**
 * 获取部门统计
 */
export async function getDepartmentStats(id: string): Promise<any> {
  return apiClient.get(`/departments/${id}/stats`);
}

// 添加部门成员 DTO
export interface AddDepartmentMemberDto {
  userId: string;
  positionId?: string;
  managerId?: string;
  isPrimary?: boolean;
  title?: string;
}

export interface AddDepartmentMembersDto {
  userIds: string[];
  positionId?: string;
  isPrimary?: boolean;
}

/**
 * 添加单个成员到部门
 */
export async function addDepartmentMember(
  departmentId: string,
  data: AddDepartmentMemberDto
): Promise<any> {
  return apiClient.post(`/departments/${departmentId}/members`, data);
}

/**
 * 批量添加成员到部门
 */
export async function addDepartmentMembers(
  departmentId: string,
  data: AddDepartmentMembersDto
): Promise<any> {
  return apiClient.post(`/departments/${departmentId}/members/batch`, data);
}

/**
 * 从部门移除成员
 */
export async function removeDepartmentMember(
  departmentId: string,
  userId: string
): Promise<{ message: string; warning?: string }> {
  return apiClient.delete(`/departments/${departmentId}/members/${userId}`);
}

/**
 * 创建部门
 */
export async function createDepartment(data: CreateDepartmentDto): Promise<Department> {
  return apiClient.post('/departments', data);
}

/**
 * 批量创建部门
 */
export async function batchCreateDepartments(departments: CreateDepartmentDto[]): Promise<{
  total: number;
  successCount: number;
  failedCount: number;
  results: {
    success: Array<{ code: string; name: string; id: string }>;
    failed: Array<{ code: string; name: string; error: string }>;
  };
}> {
  return apiClient.post('/departments/batch', { departments });
}

// ============================================
// API - Batch Import User Memberships
// ============================================

export interface ImportUserMembershipDto {
  email: string;
  departmentCode: string;
  organizationId?: string; // ✅ 组织ID（后端必填）
  positionId?: string;
  managerEmail?: string;
  title?: string;
  isPrimary?: boolean | string;
}

/**
 * 批量导入用户成员关系
 * POST /users/import-memberships
 */
export async function batchImportUserMemberships(data: { users: ImportUserMembershipDto[] }): Promise<{
  total: number;
  successCount: number;
  failedCount: number;
  results: {
    success: Array<{
      email: string;
      userId: string;
      departmentId: string;
      action: 'created' | 'updated';
    }>;
    failed: Array<{
      email: string;
      error: string;
    }>;
  };
}> {
  return apiClient.post('/users/import-memberships', data);
}

/**
 * 更新部门
 */
export async function updateDepartment(id: string, data: UpdateDepartmentDto): Promise<Department> {
  return apiClient.put(`/departments/${id}`, data);
}

/**
 * 设置部门负责人
 */
export async function setDepartmentManager(id: string, managerId: string | null): Promise<Department> {
  return apiClient.put(`/departments/${id}/manager`, { managerId });
}

/**
 * 删除部门
 */
export async function deleteDepartment(id: string): Promise<void> {
  return apiClient.delete(`/departments/${id}`);
}

// ============================================
// Organizations API (v2.0 新增)
// ============================================

/**
 * 获取组织列表
 */
export async function getOrganizations(params?: OrganizationQueryParams): Promise<OrganizationListResponse> {
  return apiClient.get('/organizations', { params });
}

/**
 * 获取组织详情
 */
export async function getOrganizationById(id: string): Promise<Organization> {
  return apiClient.get(`/organizations/${id}`);
}

/**
 * 创建组织
 */
export async function createOrganization(data: CreateOrganizationDto): Promise<Organization> {
  return apiClient.post('/organizations', data);
}

/**
 * 更新组织
 */
export async function updateOrganization(id: string, data: UpdateOrganizationDto): Promise<Organization> {
  return apiClient.put(`/organizations/${id}`, data);
}

/**
 * 删除组织（软删除）
 */
export async function deleteOrganization(id: string): Promise<void> {
  return apiClient.delete(`/organizations/${id}`);
}

/**
 * 获取组织部门树
 */
export async function getOrganizationDepartments(id: string): Promise<{
  organizationId: string;
  organization: {
    id: string;
    name: string;
  };
  departmentTree: Department[];
  totalDepartments: number;
}> {
  return apiClient.get(`/organizations/${id}/departments`);
}

/**
 * 获取组织统计信息
 */
export async function getOrganizationStats(id: string): Promise<OrganizationStats> {
  return apiClient.get(`/organizations/${id}/stats`);
}

/**
 * 管理组织的运营区域
 */
export async function manageOrganizationRegions(
  id: string,
  data: OrganizationRegionDto
): Promise<Organization> {
  return apiClient.put(`/organizations/${id}/regions`, data);
}

/**
 * 获取用户的组织列表
 */
export async function getUserOrganizations(userId: string): Promise<Organization[]> {
  if (ENABLE_DEMO_MOCK) {
    const now = new Date().toISOString();
    return [
      { id: 'org-vehicle', code: 'VEHICLE', name: '车辆研发销售', displayName: '车辆研发销售', order: 1, status: 'ACTIVE' as const, isActive: true, createdAt: now, updatedAt: now },
      { id: 'org-robot', code: 'ROBOT', name: '机器人研发销售', displayName: '机器人研发销售', order: 2, status: 'ACTIVE' as const, isActive: true, createdAt: now, updatedAt: now },
      { id: 'org-mideast', code: 'MIDEAST', name: '中东项目', displayName: '中东项目', order: 3, status: 'ACTIVE' as const, isActive: true, createdAt: now, updatedAt: now },
      { id: 'org-china', code: 'CHINA', name: '中国项目', displayName: '中国项目', order: 4, status: 'ACTIVE' as const, isActive: true, createdAt: now, updatedAt: now },
    ] as Organization[];
  }
  const raw: any[] = await apiClient.get(`/organizations/users/${userId}/organizations`);
  return raw.map((item: any) => ({
    id: item.organizationId || item.id,
    code: item.organizationCode || item.code || '',
    name: item.organizationName || item.name,
    displayName: item.organizationName || item.name,
    primaryRegionId: item.primaryRegionId || '',
    status: 'ACTIVE' as const,
    isActive: true,
    order: typeof item.order === 'number' ? item.order : 0,
    createdAt: item.createdAt || new Date().toISOString(),
    updatedAt: item.updatedAt || new Date().toISOString(),
  }));
}

// ============================================
// Positions API
// ============================================

/**
 * 获取岗位列表
 */
export async function getPositions(params?: PositionQueryParams): Promise<Position[]> {
  const response = await apiClient.get('/positions', { params });
  // 响应拦截器已经解包了 data 字段，response 直接就是数据数组
  // Map _count.userMemberships to userCount
  if (!Array.isArray(response)) {
    return [];
  }
  return response.map((position: any) => ({
    ...position,
    userCount: position._count?.userMemberships ?? 0,
  }));
}

/**
 * 获取岗位详情
 */
export async function getPositionById(id: string): Promise<Position> {
  return apiClient.get(`/positions/${id}`);
}

/**
 * 创建岗位
 */
export async function createPosition(data: CreatePositionDto): Promise<Position> {
  return apiClient.post('/positions', data);
}

/**
 * 更新岗位
 */
export async function updatePosition(id: string, data: UpdatePositionDto): Promise<Position> {
  return apiClient.put(`/positions/${id}`, data);
}

/**
 * 删除岗位
 */
export async function deletePosition(id: string): Promise<void> {
  return apiClient.delete(`/positions/${id}`);
}

// ============================================
// Roles API
// ============================================

/**
 * 获取角色列表
 */
export async function getRoles(search?: string): Promise<Role[]> {
  const params = search ? { search } : {};
  return apiClient.get('/roles', { params });
}

/**
 * 获取角色详情
 */
export async function getRoleById(id: string): Promise<RoleDetail> {
  return apiClient.get(`/roles/${id}`);
}

/**
 * 创建角色
 */
export async function createRole(data: CreateRoleDto): Promise<Role> {
  return apiClient.post('/roles', data);
}

/**
 * 更新角色
 */
export async function updateRole(id: string, data: UpdateRoleDto): Promise<Role> {
  return apiClient.put(`/roles/${id}`, data);
}

/**
 * 删除角色
 */
export async function deleteRole(id: string): Promise<void> {
  return apiClient.delete(`/roles/${id}`);
}

/**
 * 获取角色权限
 */
export async function getRolePermissions(roleId: string): Promise<Permission[]> {
  return apiClient.get(`/roles/${roleId}/permissions`);
}

/**
 * 为角色分配权限（覆盖式）
 */
export async function assignPermissionsToRole(roleId: string, permissionIds: string[]): Promise<any> {
  return apiClient.put(`/roles/${roleId}/permissions`, { permissionIds });
}

/**
 * 获取角色用户
 */
export async function getRoleUsers(roleId: string): Promise<User[]> {
  return apiClient.get(`/roles/${roleId}/users`);
}

/**
 * 为角色添加用户（增量加，不动用户其他角色）
 *
 * ⚠️ 必须用 POST /users/:userId/roles/add（增量），不能用 POST /users/:userId/roles（全替换）
 * 否则会把用户其他角色全删掉。修复 BUG（详见 backend users.controller.ts:addRoles）。
 *
 * 后端 API 是从用户角度分配角色，所以前端要循环每个用户单独调。
 */
export async function addUsersToRole(roleId: string, userIds: string[]): Promise<any> {
  const results = [];
  for (const userId of userIds) {
    try {
      const result = await apiClient.post(`/users/${userId}/roles/add`, { roleIds: [roleId] });
      results.push(result);
    } catch (error) {
      console.error(`Failed to add role to user ${userId}:`, error);
      throw error;
    }
  }
  return results;
}

/**
 * 从角色移除用户
 * 注意：后端API设计为从用户角度移除角色，而不是从角色角度移除用户
 */
export async function removeUserFromRole(roleId: string, userId: string): Promise<void> {
  // 后端API: DELETE /users/:userId/roles/:roleId
  return apiClient.delete(`/users/${userId}/roles/${roleId}`);
}

// ============================================
// Permissions API
// ============================================

/**
 * 获取所有权限
 */
export async function getPermissions(search?: string): Promise<Permission[]> {
  const params = search ? { search } : {};
  return apiClient.get('/permissions', { params });
}

/**
 * 获取分组权限
 */
export async function getPermissionsGrouped(search?: string): Promise<PermissionGroup[]> {
  const params = search ? { search } : {};
  return apiClient.get('/permissions/grouped', { params });
}

/**
 * 搜索权限
 */
export async function searchPermissions(query: string): Promise<Permission[]> {
  return apiClient.get('/permissions/search', { params: { query } });
}

/**
 * 获取权限详情
 */
export async function getPermissionById(id: string): Promise<Permission> {
  return apiClient.get(`/permissions/${id}`);
}

// ============================================
// Workflow Roles API
// ============================================

/**
 * 获取流程角色列表
 */
export async function getWorkflowRoles(search?: string, ruleType?: string): Promise<WorkflowRole[]> {
  const params: Record<string, string> = {};
  if (search) params.search = search;
  if (ruleType) params.ruleType = ruleType;
  return apiClient.get('/workflow-roles', { params });
}

/**
 * 获取流程角色详情
 */
export async function getWorkflowRoleById(id: string): Promise<WorkflowRoleDetail> {
  return apiClient.get(`/workflow-roles/${id}`);
}

/**
 * 创建流程角色
 */
export async function createWorkflowRole(data: CreateWorkflowRoleDto): Promise<WorkflowRole> {
  return apiClient.post('/workflow-roles', data);
}

/**
 * 更新流程角色
 */
export async function updateWorkflowRole(id: string, data: UpdateWorkflowRoleDto): Promise<WorkflowRole> {
  return apiClient.put(`/workflow-roles/${id}`, data);
}

/**
 * 删除流程角色
 */
export async function deleteWorkflowRole(id: string): Promise<void> {
  return apiClient.delete(`/workflow-roles/${id}`);
}

/**
 * 获取流程角色用户
 */
export async function getWorkflowRoleUsers(workflowRoleId: string): Promise<User[]> {
  return apiClient.get(`/workflow-roles/${workflowRoleId}/users`);
}

/**
 * 为流程角色分配用户（仅 FIXED_USERS 类型）
 */
export async function assignUsersToWorkflowRole(workflowRoleId: string, userIds: string[]): Promise<WorkflowRole> {
  return apiClient.post(`/workflow-roles/${workflowRoleId}/users`, { userIds });
}


// ============================================
// Sync API
// ============================================

/**
 * 触发 Entra ID 同步
 * Note: Automatically syncs from configured group if AZURE_ENTRA_SYNC_GROUP_ID is set
 */
export async function triggerSync(): Promise<SyncResult> {
  return apiClient.post('/organization/sync');
}

/**
 * 获取同步状态
 */
export async function getSyncStatus(): Promise<SyncStatus> {
  return apiClient.get('/organization/sync/status');
}

/**
 * 获取 Entra ID 同步执行历史
 */
export async function getEntraSyncExecutions(
  params: EntraSyncExecutionQuery = {},
): Promise<PaginatedEntraSyncExecutions> {
  return apiClient.get('/organization/sync/executions', {
    params: {
      page: params.page || 1,
      limit: params.limit || 20,
      ...(params.startDate && { startDate: params.startDate }),
      ...(params.endDate && { endDate: params.endDate }),
      ...(params.hideEmpty && { hideEmpty: 'true' }),
    },
  });
}

/**
 * 获取全局组织统计信息（所有组织的汇总统计）
 */
export async function getGlobalOrganizationStats(): Promise<OrganizationStats> {
  return apiClient.get('/organization/stats');
}


// ============================================
// Regions API
// ============================================

/**
 * 获取区域列表
 */
export async function getRegions(params?: RegionQueryParams): Promise<Region[]> {
  return apiClient.get('/regions', { params });
}

/**
 * 获取活跃区域列表（用于下拉选择）
 */
export async function getActiveRegions(): Promise<Region[]> {
  return apiClient.get('/regions/active');
}

/**
 * 设置区域默认组织
 */
export async function setRegionDefaultOrganization(
  regionId: string,
  departmentId: string | null
): Promise<{ message: string; regionId: string; departmentId: string | null }> {
  return apiClient.put(`/regions/${regionId}/default-organization`, { departmentId });
}

/**
 * 获取区域详情
 */
export async function getRegionById(id: string): Promise<Region> {
  return apiClient.get(`/regions/${id}`);
}

/**
 * 根据代码获取区域
 */
export async function getRegionByCode(code: string): Promise<Region> {
  return apiClient.get(`/regions/code/${code}`);
}

/**
 * 获取区域统计
 */
export async function getRegionStats(id: string): Promise<{
  organizationCount: number;
  departmentCount: number;
  userCount: number;
}> {
  return apiClient.get(`/regions/${id}/stats`);
}

/**
 * 创建区域
 */
export async function createRegion(data: CreateRegionDto): Promise<Region> {
  return apiClient.post('/regions', data);
}

/**
 * 更新区域
 */
export async function updateRegion(id: string, data: UpdateRegionDto): Promise<Region> {
  return apiClient.patch(`/regions/${id}`, data);
}

/**
 * 删除区域
 */
export async function deleteRegion(id: string): Promise<void> {
  return apiClient.delete(`/regions/${id}`);
}


// ============================================
// Multi-Department Affiliation API (多部门归属)
// ============================================

/**
 * 用户部门归属信息
 */
export interface UserDepartment {
  id: string;
  userId: string;
  departmentId: string;
  positionId?: string | null;
  managerId?: string | null;
  isPrimary: boolean;
  title?: string | null;
  joinedAt?: string | null;
  leftAt?: string | null;
  createdAt: string;
  updatedAt: string;
  
  // Relations
  department?: {
    id: string;
    name: string;
    code: string;
  };
  position?: {
    id: string;
    name: string;
    level?: number;
  };
  manager?: {
    id: string;
    displayName: string;
    email?: string;
  };
}

/**
 * 添加用户部门归属DTO
 */
export interface AddUserDepartmentDto {
  departmentId: string;
  positionId?: string;
  managerId?: string;
  isPrimary?: boolean;
  title?: string;
  joinedAt?: string;
}

/**
 * 更新用户部门归属DTO
 */
export interface UpdateUserDepartmentDto {
  positionId?: string;
  managerId?: string;
  title?: string;
  joinedAt?: string;
}

/**
 * 用户部门归属查询参数
 */
export interface UserDepartmentQueryParams {
  includeLeft?: boolean;
}

/**
 * 获取用户所有部门归属
 */
export async function getUserDepartments(
  userId: string, 
  params?: UserDepartmentQueryParams
): Promise<UserDepartment[]> {
  return apiClient.get(`/users/${userId}/departments`, { params });
}

/**
 * 添加用户到部门
 */
export async function addUserDepartment(
  userId: string, 
  data: AddUserDepartmentDto
): Promise<UserDepartment> {
  return apiClient.post(`/users/${userId}/departments`, data);
}

/**
 * 更新用户部门归属
 */
export async function updateUserDepartment(
  userId: string, 
  departmentId: string, 
  data: UpdateUserDepartmentDto
): Promise<UserDepartment> {
  return apiClient.patch(`/users/${userId}/departments/${departmentId}`, data);
}

/**
 * 设置用户主部门
 */
export async function setUserPrimaryDepartment(
  userId: string, 
  departmentId: string
): Promise<UserDepartment> {
  return apiClient.put(`/users/${userId}/departments/${departmentId}/primary`);
}

/**
 * 移除用户部门归属
 */
export async function removeUserDepartment(
  userId: string, 
  departmentId: string
): Promise<{ message: string; warning?: string }> {
  return apiClient.delete(`/users/${userId}/departments/${departmentId}`);
}

// ============================================
// Validation APIs
// ============================================

/**
 * 检查用户名是否可用
 */
export async function checkUsernameAvailable(username: string, excludeUserId?: string): Promise<{ available: boolean }> {
  try {
    const params: any = { username };
    if (excludeUserId) params.excludeUserId = excludeUserId;
    const response = await apiClient.get('/users/check-username', { params });
    return response.data;
  } catch (error) {
    // If API doesn't exist, assume available
    return { available: true };
  }
}

/**
 * 检查邮箱是否可用
 */
export async function checkEmailAvailable(email: string, excludeUserId?: string): Promise<{ available: boolean }> {
  try {
    const params: any = { email };
    if (excludeUserId) params.excludeUserId = excludeUserId;
    const response = await apiClient.get('/users/check-email', { params });
    return response.data;
  } catch (error) {
    // If API doesn't exist, assume available
    return { available: true };
  }
}

/**
 * 检查员工编号是否可用
 */
export async function checkEmployeeIdAvailable(employeeId: string, excludeUserId?: string): Promise<{ available: boolean }> {
  try {
    const params: any = { employeeId };
    if (excludeUserId) params.excludeUserId = excludeUserId;
    const response = await apiClient.get('/users/check-employee-id', { params });
    return response.data;
  } catch (error) {
    // If API doesn't exist, assume available
    return { available: true };
  }
}

// ============================================
// Work City Import API (v1.2 签到方式校验)
// ============================================

export type WorkCityImportRow = { email: string; workCity: string };

export interface WorkCityExactRow {
  category: 'exact';
  city: string;
  rowCount: number;
}
export interface WorkCitySimilarRow {
  category: 'similar';
  city: string;
  similarTo: string;
  distance: number;
  rowCount: number;
}
export interface WorkCityNewRow {
  category: 'new';
  city: string;
  rowCount: number;
}
export type WorkCityPreviewCategory = WorkCityExactRow | WorkCitySimilarRow | WorkCityNewRow;

export interface WorkCityPreviewResult {
  total: number;
  uniqueCitiesInFile: number;
  categorized: {
    exact: WorkCityExactRow[];
    similar: WorkCitySimilarRow[];
    new: WorkCityNewRow[];
  };
  unmatchedEmails: string[];
}

export type WorkCityApprovalAction = 'use' | 'replace' | 'skip';

export interface WorkCityCommitResult {
  created: number;
  updated: number;
  skipped: number;
  unmatchedEmails: string[];
}

export async function previewWorkCityImport(
  rows: WorkCityImportRow[],
): Promise<WorkCityPreviewResult> {
  return apiClient.post('/users/import-work-city/preview', { rows });
}

export async function commitWorkCityImport(
  rows: WorkCityImportRow[],
  approvals: Record<string, { action: WorkCityApprovalAction; targetCity?: string }>,
): Promise<WorkCityCommitResult> {
  return apiClient.post('/users/import-work-city/commit', { rows, approvals });
}