import { request, type ApiResponse } from './request'

interface UserDto {
  userId: number
  userName: string | null
  nickName: string | null
  phonenumber?: string | null
  roleId?: number | null
  createTime?: string | null
  status: string | null
}

interface UserListResponse extends ApiResponse {
  total: number
  rows: UserDto[]
}

export interface UserOption {
  id: number
  name: string
  userName: string
}

export interface RoleOption {
  roleId: number
  roleName: string
}

interface RoleOptionDto {
  roleId: number
  roleName: string | null
}

interface RoleOptionResponse extends ApiResponse {
  data: RoleOptionDto[]
}

export interface CreateUserInput {
  nickName: string
  userName: string
  phonenumber: string
  password: string
  status: '0' | '1'
  roleIds: number[]
}

export interface UpdateUserInput extends Omit<CreateUserInput, 'password'> {
  userId: number
  password?: string
}

export interface UserListParams {
  pageNum: number
  pageSize: number
  nickName?: string
  phonenumber?: string
  roleId?: number
  status?: string
}

export interface UserListItem {
  id: number
  name: string
  username: string
  phone: string
  roleId: number
  status: '启用' | '禁用'
  createdAt: string
}

export interface UserListResult {
  total: number
  rows: UserListItem[]
}

export async function getEnabledUserOptions(): Promise<UserOption[]> {
  const searchParams = new URLSearchParams({
    pageNum: '1',
    pageSize: '1000',
    status: '0',
  })
  const result = await request<UserListResponse>(`/system/user/list?${searchParams.toString()}`)
  return (result.rows || [])
    .filter(item => item.status === '0')
    .map(item => ({
      id: item.userId,
      name: item.nickName?.trim() || item.userName?.trim() || `用户${item.userId}`,
      userName: item.userName?.trim() || '',
    }))
}

export async function getUserList(params: UserListParams): Promise<UserListResult> {
  const searchParams = new URLSearchParams()
  Object.entries(params).forEach(([key, value]) => {
    if (value !== undefined && value !== '') searchParams.set(key, String(value))
  })
  const result = await request<UserListResponse>(`/system/user/list?${searchParams.toString()}`)
  return {
    total: Number(result.total) || 0,
    rows: (result.rows || []).map(item => ({
      id: item.userId,
      name: item.nickName || '-',
      username: item.userName || '-',
      phone: item.phonenumber || '',
      roleId: Number(item.roleId) || 0,
      status: item.status === '0' ? '启用' : '禁用',
      createdAt: item.createTime || '',
    })),
  }
}

export async function getRoleOptions(): Promise<RoleOption[]> {
  const result = await request<RoleOptionResponse>('/system/role/optionselect')
  return (result.data || []).map(item => ({
    roleId: item.roleId,
    roleName: item.roleName || `角色${item.roleId}`,
  }))
}

export function createUser(input: CreateUserInput): Promise<ApiResponse> {
  return request<ApiResponse>('/system/user', {
    method: 'POST',
    body: JSON.stringify(input),
  })
}

export function updateUser(input: UpdateUserInput): Promise<ApiResponse> {
  return request<ApiResponse>('/system/user', {
    method: 'PUT',
    body: JSON.stringify(input),
  })
}

export function changeUserStatus(userId: number, status: '0' | '1'): Promise<ApiResponse> {
  return request<ApiResponse>('/system/user/changeStatus', {
    method: 'PUT',
    body: JSON.stringify({ userId, status }),
  })
}

export function resetUserPassword(userId: number, password: string): Promise<ApiResponse> {
  return request<ApiResponse>('/system/user/resetPwd', {
    method: 'PUT',
    body: JSON.stringify({ userId, password }),
  })
}

export async function deleteUsers(userIds: number[]): Promise<void> {
  await request<ApiResponse>(`/system/user/${userIds.join(',')}`, {
    method: 'DELETE',
  })
}