export function createUserSearchState() {
  return {
    username: '',
    nickname: '',
    phone: '',
    email: '',
    status: void 0,
    deptId: void 0,
    roleIds: [],
    code: '',
    sex: void 0,
    realName: '',
    idCard: '',
    condition: ''
  }
}

export function createUserFormState() {
  return {
    id: void 0,
    username: '',
    nickname: '',
    deptId: 0,
    roleIds: [],
    userRoleIds: [],
    password: '',
    confirmPassword: '',
    sex: 0,
    code: '',
    phone: '',
    email: '',
    realName: '',
    idCard: '',
    memo: '',
    status: 1
  }
}

export function buildUserSearchParams(params = {}) {
  const searchParams = {
    username: params.username,
    nickname: params.nickname,
    phone: params.phone,
    email: params.email,
    status: params.status,
    deptId: params.deptId,
    roleIds: normalizeRoleIds(params),
    code: params.code,
    sex: params.sex,
    realName: params.realName,
    idCard: params.idCard,
    condition: params.condition
  }

  return Object.fromEntries(
    Object.entries(searchParams).filter(([, value]) => {
      if (Array.isArray(value)) {
        return value.length > 0
      }
      return value !== '' && value !== undefined && value !== null
    })
  )
}

export function buildUserPageQueryParams(params = {}) {
  const { current, size, pageSize, ...filters } = params
  return {
    current: current || 1,
    pageSize: pageSize || size || 20,
    ...buildUserSearchParams(filters)
  }
}

export function buildUserDialogModel(record = {}) {
  const roleIds = normalizeRoleIds(record)
  return {
    ...createUserFormState(),
    id: record.id !== undefined && record.id !== null && record.id !== '' ? record.id : void 0,
    username: record.username || '',
    nickname: record.nickname || '',
    deptId: normalizeDeptId(record.deptId),
    roleIds,
    userRoleIds: [...roleIds],
    sex: record.sex !== undefined && record.sex !== null ? record.sex : 0,
    code: record.code || '',
    phone: record.phone || '',
    email: record.email || '',
    realName: record.realName || '',
    idCard: record.idCard || '',
    memo: record.memo || '',
    status: record.status !== undefined && record.status !== null ? record.status : 1
  }
}

export function mergeUserDetailRecord(detail = {}, fallback = {}) {
  const merged = {
    ...(fallback && typeof fallback === 'object' ? fallback : {}),
    ...(detail && typeof detail === 'object' ? detail : {})
  }

  if (!hasRoleSelection(detail) && hasRoleSelection(fallback)) {
    merged.roles = fallback.roles
  }

  if (merged.deptLabel === undefined && fallback?.deptLabel) {
    merged.deptLabel = fallback.deptLabel
  }

  if (merged.roleNames === undefined && fallback?.roleNames) {
    merged.roleNames = fallback.roleNames
  }

  return merged
}

export function buildUserSavePayload(form = {}) {
  const roleIds = normalizeRoleIds(form)
  const password = form.password || form.newPassword || ''
  const payload = {
    id: form.id !== undefined && form.id !== null && form.id !== '' ? form.id : void 0,
    username: form.username || '',
    nickname: form.nickname || '',
    deptId: normalizeDeptId(form.deptId),
    roleIds,
    sex: form.sex !== undefined && form.sex !== null ? form.sex : 0,
    code: form.code || '',
    phone: form.phone || '',
    email: form.email || '',
    realName: form.realName || '',
    idCard: form.idCard || '',
    memo: form.memo || '',
    status: form.status !== undefined && form.status !== null ? form.status : 1
  }

  if (password) {
    payload.password = password
  }

  return payload
}

export function normalizeUserListRow(record = {}) {
  const roles = Array.isArray(record.roles) ? record.roles : []
  const statusMeta = getUserStatusMeta(record.statusBool ?? record.status)
  return {
    ...record,
    deptLabel:
      record.deptLabel ||
      record.deptId$ ||
      record.deptName ||
      record.dept?.name ||
      (record.deptId === 0 ? '根部门' : '-'),
    roleNames: formatUserRoleNames(roles) || record.roleNames || '',
    statusBool: record.statusBool !== undefined ? Boolean(record.statusBool) : statusMeta.bool,
    statusText: statusMeta.text,
    statusType: statusMeta.type,
    createTimeText: record.createTime$ || record.createTime || '',
    updateTimeText: record.updateTime$ || record.updateTime || ''
  }
}

export function normalizeDeptTreeOptions(tree = []) {
  if (!Array.isArray(tree)) {
    return []
  }

  return tree
    .map((node) => normalizeDeptTreeNode(node))
    .filter(Boolean)
}

export function normalizeRoleOptions(roles = []) {
  if (!Array.isArray(roles)) {
    return []
  }

  return roles
    .map((role) => {
      if (!role || typeof role !== 'object') {
        return null
      }
      const value = normalizeRoleId(role.id ?? role.roleId)
      if (value === void 0) {
        return null
      }
      return {
        value,
        label: role.name || role.roleName || role.code || ''
      }
    })
    .filter(Boolean)
}

export function getUserStatusMeta(status) {
  if (status === true || status === 1) {
    return { type: 'success', text: '正常', bool: true }
  }
  if (status === false || status === 0) {
    return { type: 'danger', text: '禁用', bool: false }
  }
  return { type: 'info', text: '未知', bool: false }
}

export function formatUserRoleNames(roles = []) {
  if (!Array.isArray(roles) || roles.length === 0) {
    return ''
  }

  const names = roles
    .map((role) => {
      if (typeof role === 'string') {
        return role
      }
      if (role && typeof role === 'object') {
        return role.name || role.roleName || role.code || ''
      }
      return ''
    })
    .filter(Boolean)

  return names.join('、')
}

function normalizeDeptTreeNode(node) {
  if (!node || typeof node !== 'object') {
    return null
  }

  return {
    value: normalizeDeptId(node.id ?? node.value),
    label: node.name || node.label || '',
    children: normalizeDeptTreeOptions(node.children)
  }
}

function normalizeRoleIds(source) {
  if (!source || typeof source !== 'object') {
    return []
  }

  const directRoleIds = Array.isArray(source.roleIds)
    ? source.roleIds
    : Array.isArray(source.userRoleIds)
      ? source.userRoleIds
      : Array.isArray(source.roles)
        ? source.roles.map((item) => item?.id ?? item?.roleId)
        : []

  return Array.from(
    new Set(
      directRoleIds
        .map((item) => normalizeRoleId(item))
        .filter((item) => item !== void 0)
    )
  )
}

function normalizeDeptId(value) {
  if (value === '' || value === null || value === undefined) {
    return 0
  }
  return value
}

function normalizeRoleId(value) {
  if (value === '' || value === null || value === undefined) {
    return void 0
  }
  const numeric = Number(value)
  if (Number.isNaN(numeric)) {
    return value
  }
  return numeric
}

function hasRoleSelection(source) {
  if (!source || typeof source !== 'object') {
    return false
  }
  if (Array.isArray(source.roleIds) && source.roleIds.length > 0) {
    return true
  }
  if (Array.isArray(source.userRoleIds) && source.userRoleIds.length > 0) {
    return true
  }
  return Array.isArray(source.roles) && source.roles.length > 0
}