import request from '@/utils/request.ts'
import type { AdminUser, PageResult, PageParams } from '@/types'

export type { AdminUser }

function normalizeAdmin(raw: any): AdminUser {
  const firstRole = Array.isArray(raw?.roles) ? raw.roles[0] : undefined

  return {
    id: Number(raw?.id || 0),
    username: raw?.username || '',
    nickname: raw?.realName || raw?.nickname || raw?.username || '',
    avatar: raw?.avatar || '',
    email: raw?.email || '',
    phone: raw?.phone || '',
    role: firstRole?.code || '',
    roleName: firstRole?.name || '',
    roles: Array.isArray(raw?.roles) ? raw.roles.map((item: any) => item.code || item.name || '') : [],
    roleNames: Array.isArray(raw?.roles) ? raw.roles.map((item: any) => item.name || item.code || '') : [],
    roleIds: Array.isArray(raw?.roleIds)
      ? raw.roleIds.map((item: any) => Number(item))
      : (Array.isArray(raw?.roles) ? raw.roles.map((item: any) => Number(item.id || 0)).filter((item: number) => item > 0) : []),
    permissions: [],
    status: Number(raw?.status ?? 0),
    lastLoginTime: raw?.lastLoginTime || '',
    lastLoginIp: raw?.lastLoginIp || '',
    createTime: raw?.createTime || ''
  }
}

function normalizeAdminPage(raw: any, page: number, size: number): PageResult<AdminUser> {
  const records = Array.isArray(raw?.records) ? raw.records.map(normalizeAdmin) : []
  const total = Number(raw?.total || records.length || 0)
  const shouldPaginateLocally = (!raw?.total || raw.total === 0) && records.length > size
  const pagedRecords = shouldPaginateLocally
    ? records.slice((page - 1) * size, page * size)
    : records

  return {
    records: pagedRecords,
    total: shouldPaginateLocally ? records.length : total,
    size: Number(raw?.size || size),
    current: Number(raw?.current || page),
    pages: Number(raw?.pages || Math.ceil((shouldPaginateLocally ? records.length : total) / size) || 1)
  }
}

/**
 * 管理员管理 API
 */
export const adminApi = {
  /**
   * 获取管理员列表
   */
  async getList(params: PageParams & { keyword?: string }): Promise<PageResult<AdminUser>> {
    const page = params.page || 1
    const size = params.size || 10
    const result = await request.get<any>('/user/list', params)
    return normalizeAdminPage(result, page, size)
  },

  /**
   * 获取管理员详情
   */
  async getDetail(id: number): Promise<AdminUser> {
    const result = await request.get<any>(`/user/${id}`)
    return normalizeAdmin(result)
  },

  /**
   * 添加管理员
   */
  create(data: {
    username: string
    password: string
    nickname: string
    email?: string
    phone?: string
    roleIds: number[]
  }): Promise<void> {
    return request.post('/user', {
      username: data.username,
      password: data.password,
      realName: data.nickname,
      ...(data.email ? { email: data.email } : {}),
      ...(data.phone ? { phone: data.phone } : {}),
      roleIds: data.roleIds
    })
  },

  /**
   * 更新管理员
   */
  update(data: {
    id: number
    username: string
    nickname?: string
    email?: string
    phone?: string
    roleIds: number[]
  }): Promise<void> {
    const payload: Record<string, any> = {
      id: data.id,
      username: data.username,
      realName: data.nickname,
      roleIds: data.roleIds
    }

    if (data.email) payload.email = data.email
    if (data.phone) payload.phone = data.phone

    return request.put('/user', payload)
  },

  /**
   * 删除管理员
   */
  delete(id: number): Promise<void> {
    return request.delete(`/user/${id}`)
  },

  /**
   * 启用/禁用管理员
   */
  updateStatus(id: number, status: number): Promise<void> {
    return request.put(`/user/${id}/status/${status}`)
  },

  /**
   * 重置密码
   */
  resetPassword(id: number): Promise<void> {
    return request.put(`/user/${id}/reset-password`, undefined, {
      params: {
        newPassword: 'admin123'
      }
    })
  }
}