import axios from 'axios'

import { unwrapApiResponse, unwrapNullableApiResponse } from '@/utils/api-response'
import { mockFlags } from '@/utils/mock-flags'
import { request } from '@/utils/request'
import type { ApiResponse, PageResult } from '@/types/common'

import type {
  BackendCollection,
  BackendPage,
  CreateUserRequest,
  PasswordResetRequest,
  UpdateUserRequest,
  UserImportCommitRequest,
  UserImportJobResponseDto,
  UserImportPreviewResponseDto,
  UserListResponse,
  UserQuery,
  UserRecord,
  UserResponseDto,
  UserRoleSummaryDto,
  UserRolesUpdateRequest,
} from './types'

const useMockData = mockFlags.users

export const isUserMockEnabled = useMockData

const mockRecords: UserRecord[] = [
  {
    id: 'user-001',
    name: '张文静',
    account: 'zhangwenjing',
    department: '医务管理',
    role: '系统管理员',
    status: 'enabled',
    lastLoginAt: '2026-08-27 08:12',
  },
  {
    id: 'user-002',
    name: '王医生',
    account: 'wangdoctor',
    department: '消化内科',
    role: '医生',
    status: 'enabled',
    lastLoginAt: '2026-08-27 08:35',
  },
  {
    id: 'user-003',
    name: '李护士',
    account: 'linurse',
    department: '儿科急诊',
    role: '护士',
    status: 'disabled',
    lastLoginAt: '2026-08-20 14:26',
  },
]

function formatDateTime(value: string | null | undefined) {
  if (!value) {
    return '—'
  }

  const date = new Date(value)

  if (Number.isNaN(date.getTime())) {
    return value
      .replace('T', ' ')
      .replace(/\.\d+Z$/, '')
      .replace(/Z$/, '')
  }

  const pad = (part: number) => String(part).padStart(2, '0')
  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(
    date.getHours(),
  )}:${pad(date.getMinutes())}`
}

function normalizeStatus(value: string | null | undefined): UserRecord['status'] {
  if (value === 'LOCKED') {
    return 'locked'
  }

  return value === 'DISABLED' || value === 'INACTIVE' ? 'disabled' : 'enabled'
}

function mapUser(dto: UserResponseDto): UserRecord {
  const roles = dto.roles ?? []
  const roleNames = roles.map((role) => role.name).filter(Boolean)

  return {
    id: dto.id,
    employeeId: dto.employeeId,
    name: dto.displayName,
    account: dto.username,
    department: dto.departmentName ?? (dto.departmentId ? '未知科室' : '未指定科室'),
    role: roleNames.length ? roleNames.join('、') : '未分配角色',
    status: normalizeStatus(dto.status),
    lastLoginAt: formatDateTime(dto.lastLoginAt),
    employeeNo: dto.employeeNo,
    position: dto.position,
    professionalTitle: dto.professionalTitle,
    phone: dto.phone,
    email: dto.email,
    campusId: dto.campusId,
    campusName: dto.campusName ?? undefined,
    departmentId: dto.departmentId,
    departmentName: dto.departmentName ?? undefined,
    roleNames,
    roleIds: roles.map((role) => role.id),
    roleDataScopes: roles.map((role) => role.dataScope ?? 'SELF'),
    version: dto.version ?? undefined,
    passwordChangeRequired: dto.passwordChangeRequired,
  }
}

function normalizePage<T>(
  data: BackendPage<T> | T[],
  fallbackPage: number,
  fallbackPageSize: number,
): PageResult<T> {
  const records = Array.isArray(data) ? data : (data.records ?? data.items ?? data.content ?? [])

  return {
    records,
    total: Array.isArray(data) ? records.length : (data.total ?? records.length),
    page: Array.isArray(data) ? fallbackPage : (data.page ?? fallbackPage),
    pageSize: Array.isArray(data) ? fallbackPageSize : (data.size ?? fallbackPageSize),
  }
}

function toBackendQuery(query: UserQuery) {
  const params: Record<string, string | number> = {
    page: Math.max(query.page, 1),
    size: Math.min(Math.max(query.pageSize, 1), 200),
  }

  if (query.keyword?.trim()) {
    params.keyword = query.keyword.trim()
  }

  if (query.campusId) {
    params.campusId = query.campusId
  }

  if (query.departmentId) {
    params.departmentId = query.departmentId
  }

  return params
}

export function getUsers(query: UserQuery): Promise<UserListResponse> {
  if (!useMockData) {
    return request
      .get<ApiResponse<BackendCollection<UserResponseDto>>>('/v1/users', {
        params: toBackendQuery(query),
      })
      .then((response) => {
        const page = normalizePage(unwrapApiResponse(response), query.page, query.pageSize)

        return {
          ...page,
          records: page.records.map(mapUser),
        }
      })
  }

  const keyword = query.keyword?.trim().toLowerCase()
  const filteredRecords = mockRecords.filter((record) => {
    const matchesKeyword =
      !keyword || [record.name, record.account].join(' ').toLowerCase().includes(keyword)
    const matchesDepartment = !query.department || record.department === query.department
    const matchesDepartmentId = !query.departmentId || record.departmentId === query.departmentId
    const matchesStatus = !query.status || query.status === 'all' || record.status === query.status
    const matchesCampus = !query.campusId || record.campusId === query.campusId

    return (
      matchesKeyword && matchesDepartment && matchesDepartmentId && matchesStatus && matchesCampus
    )
  })
  const page = Math.max(query.page, 1)
  const pageSize = Math.max(query.pageSize, 1)
  const start = (page - 1) * pageSize

  return Promise.resolve({
    records: filteredRecords.slice(start, start + pageSize),
    total: filteredRecords.length,
    page,
    pageSize,
  })
}

export async function getUserDetail(id: string): Promise<UserRecord | null> {
  if (useMockData) {
    const record = mockRecords.find((item) => item.id === id)
    return record ? { ...record } : null
  }

  try {
    const response = await request.get<ApiResponse<UserResponseDto>>(
      `/v1/users/${encodeURIComponent(id)}`,
    )
    return mapUser(unwrapApiResponse(response))
  } catch (error) {
    if (axios.isAxiosError(error) && error.response?.status === 404) {
      return null
    }

    throw error
  }
}

export function createUser(payload: CreateUserRequest): Promise<UserRecord> {
  if (useMockData) {
    return Promise.reject(new Error('Mock 模式不执行用户写操作'))
  }

  return request
    .post<ApiResponse<UserResponseDto>>('/v1/users', payload)
    .then(unwrapApiResponse)
    .then(mapUser)
}

export function updateUser(id: string, payload: UpdateUserRequest): Promise<UserRecord> {
  if (useMockData) {
    return Promise.reject(new Error('Mock 模式不执行用户写操作'))
  }

  return request
    .put<ApiResponse<UserResponseDto>>(`/v1/users/${encodeURIComponent(id)}`, payload)
    .then(unwrapApiResponse)
    .then(mapUser)
}

export async function getUserRoles(userId: string): Promise<UserRoleSummaryDto[]> {
  if (useMockData) {
    return []
  }

  const response = await request.get<ApiResponse<UserRoleSummaryDto[]>>(
    `/v1/users/${encodeURIComponent(userId)}/roles`,
  )
  return unwrapApiResponse(response)
}

export async function updateUserRoles(
  userId: string,
  payload: UserRolesUpdateRequest,
): Promise<void> {
  if (useMockData) {
    return Promise.reject(new Error('Mock 模式不执行用户角色写操作'))
  }

  const response = await request.put<ApiResponse<null>>(
    `/v1/users/${encodeURIComponent(userId)}/roles`,
    payload,
  )
  unwrapNullableApiResponse(response)
}

export async function resetUserPassword(
  userId: string,
  payload: PasswordResetRequest,
): Promise<void> {
  if (useMockData) {
    throw new Error('Mock 模式不执行密码重置')
  }

  const response = await request.post<ApiResponse<null>>(
    `/v1/users/${encodeURIComponent(userId)}/password/reset`,
    payload,
  )
  unwrapNullableApiResponse(response)
}

export async function previewUserImport(
  file: File,
  campusId?: string,
): Promise<UserImportPreviewResponseDto> {
  if (useMockData) {
    throw new Error('Mock 模式不执行用户导入')
  }

  const formData = new FormData()
  formData.append('file', file)

  if (campusId) {
    formData.append('campusId', campusId)
  }

  const response = await request.post<ApiResponse<UserImportPreviewResponseDto>>(
    '/v1/users/import/preview',
    formData,
  )
  return unwrapApiResponse(response)
}

export async function commitUserImport(
  payload: UserImportCommitRequest,
): Promise<UserImportJobResponseDto> {
  if (useMockData) {
    throw new Error('Mock 模式不执行用户导入')
  }

  const response = await request.post<ApiResponse<UserImportJobResponseDto>>(
    '/v1/users/import/commit',
    payload,
  )
  return unwrapApiResponse(response)
}

export async function getUserImportJob(jobId: string): Promise<UserImportJobResponseDto> {
  if (useMockData) {
    throw new Error('Mock 模式不执行用户导入')
  }

  const response = await request.get<ApiResponse<UserImportJobResponseDto>>(
    `/v1/users/import/jobs/${encodeURIComponent(jobId)}`,
  )
  return unwrapApiResponse(response)
}

export function deleteUser(id: string): Promise<void> {
  if (useMockData) {
    return Promise.reject(new Error('Mock 模式不执行用户写操作'))
  }

  return request
    .delete<ApiResponse<null>>(`/v1/users/${encodeURIComponent(id)}`)
    .then((response) => {
      unwrapNullableApiResponse(response)
    })
}