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

export interface RolePermission {
  menuId: number
  menuName: string
}

export interface RolePermissionPage {
  menuId: number
  pageName: string
  permissions: RolePermission[]
}

export interface RolePermissionModule {
  menuId: number
  moduleName: string
  pages: RolePermissionPage[]
}

export interface CreateRoleInput {
  roleName: string
  roleKey: 'common'
  roleSort: 1
  status: '0'
  menuIds: number[]
  remark: string
}

export interface UpdateRoleInput {
  roleId: number
  roleName: string
  roleKey: 'common'
  roleSort: 1
  status: '0'
  menuIds: number[]
  remark: string
}

export interface RoleListParams {
  pageNum: number
  pageSize: number
  roleName?: string
}

export interface RoleListItem {
  id: number
  name: string
  accountCount: number
  createdAt: string
  remark: string
  builtIn: boolean
}

interface RoleDto {
  roleId: number
  roleName: string | null
  roleKey: string | null
  createTime: string | null
  remark: string | null
  userCount?: number | null
  accountCount?: number | null
}

interface RoleListResponse extends ApiResponse {
  total: number
  rows: RoleDto[]
}

interface RoleDetailDto {
  roleId: number
  roleName: string | null
  remark: string | null
  menuIds: number[] | null
}

interface RoleDetailResponse extends ApiResponse {
  data: RoleDetailDto
}

export interface RoleDetail {
  id: number
  name: string
  remark: string
  menuIds: number[]
}

export interface RoleListResult {
  total: number
  rows: RoleListItem[]
}

interface PermissionListResponse extends ApiResponse {
  data: RolePermissionModule[]
}

export async function getRolePermissionList(): Promise<RolePermissionModule[]> {
  const result = await request<PermissionListResponse>('/system/menu/permissionList')
  return Array.isArray(result.data) ? result.data : []
}

export async function getRoleList(params: RoleListParams): Promise<RoleListResult> {
  const searchParams = new URLSearchParams()
  Object.entries(params).forEach(([key, value]) => {
    if (value !== undefined && value !== '') searchParams.set(key, String(value))
  })
  const result = await request<RoleListResponse>(`/system/role/list?${searchParams.toString()}`)
  return {
    total: Number(result.total) || 0,
    rows: (result.rows || []).map(item => ({
      id: item.roleId,
      name: item.roleName || '-',
      accountCount: Number(item.userCount ?? item.accountCount) || 0,
      createdAt: item.createTime || '',
      remark: item.remark || '',
      builtIn: item.roleKey === 'admin',
    })),
  }
}

export async function getRole(roleId: number): Promise<RoleDetail> {
  const result = await request<RoleDetailResponse>(`/system/role/${roleId}`)
  return {
    id: result.data.roleId,
    name: result.data.roleName || '',
    remark: result.data.remark || '',
    menuIds: Array.isArray(result.data.menuIds) ? result.data.menuIds.map(Number) : [],
  }
}

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

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

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