import type { User, LoginHistory } from "./types"
import { mockResponse, type PaginatedResponse, type PaginationParams } from "./client"

// 模拟用户数据
const mockUsers: User[] = [
  {
    id: "1",
    name: "管理员",
    email: "admin@example.com",
    role: "超级管理员",
    status: "活跃",
    registeredAt: "2023-01-01",
    lastLogin: "今天 08:45",
    phone: "13800138000",
    address: "北京市海淀区中关村",
    permissions: [
      "仪表盘查看",
      "用户管理",
      "角色权限管理",
      "AI模型管理",
      "服装管理",
      "道具管理",
      "歌曲管理",
      "系统设置",
    ],
    loginHistory: [
      { date: "2023-05-15 08:45", ip: "192.168.1.1", device: "Chrome / Windows" },
      { date: "2023-05-14 15:30", ip: "192.168.1.1", device: "Chrome / Windows" },
      { date: "2023-05-13 09:20", ip: "192.168.1.1", device: "Chrome / Windows" },
    ],
  },
  {
    id: "2",
    name: "张三",
    email: "zhangsan@example.com",
    role: "内容管理员",
    status: "活跃",
    registeredAt: "2023-03-15",
    lastLogin: "昨天 16:30",
    phone: "13900139000",
    permissions: ["仪表盘查看", "服装管理", "道具管理", "歌曲管理"],
    loginHistory: [
      { date: "2023-05-14 16:30", ip: "192.168.1.2", device: "Safari / macOS" },
      { date: "2023-05-13 14:20", ip: "192.168.1.2", device: "Safari / macOS" },
    ],
  },
  {
    id: "3",
    name: "李四",
    email: "lisi@example.com",
    role: "AI模型管理员",
    status: "活跃",
    registeredAt: "2023-05-20",
    lastLogin: "3天前",
    permissions: ["仪表盘查看", "AI模型管理"],
    loginHistory: [{ date: "2023-05-12 10:15", ip: "192.168.1.3", device: "Firefox / Ubuntu" }],
  },
  {
    id: "4",
    name: "王五",
    email: "wangwu@example.com",
    role: "卡牌管理员",
    status: "活跃",
    registeredAt: "2023-07-10",
    lastLogin: "1周前",
    permissions: ["仪表盘查看", "服装管理", "道具管理", "家居装饰管理"],
  },
  {
    id: "5",
    name: "赵六",
    email: "zhaoliu@example.com",
    role: "查看者",
    status: "未激活",
    registeredAt: "2023-09-05",
    permissions: ["仪表盘查看"],
  },
]

// 获取用户列表
export const getUsers = async (params?: PaginationParams): Promise<PaginatedResponse<User>> => {
  let filteredUsers = [...mockUsers]

  // 搜索过滤
  if (params?.search) {
    const search = params.search.toLowerCase()
    filteredUsers = filteredUsers.filter(
      (user) =>
        user.name.toLowerCase().includes(search) ||
        user.email.toLowerCase().includes(search) ||
        user.role.toLowerCase().includes(search),
    )
  }

  // 排序
  if (params?.sortBy) {
    filteredUsers.sort((a: any, b: any) => {
      const aValue = a[params.sortBy!]
      const bValue = b[params.sortBy!]

      if (typeof aValue === "string" && typeof bValue === "string") {
        return params.sortOrder === "desc" ? bValue.localeCompare(aValue) : aValue.localeCompare(bValue)
      }

      return params.sortOrder === "desc" ? bValue - aValue : aValue - bValue
    })
  }

  // 分页
  const page = params?.page || 1
  const pageSize = params?.pageSize || 10
  const startIndex = (page - 1) * pageSize
  const paginatedUsers = filteredUsers.slice(startIndex, startIndex + pageSize)

  return mockResponse({
    items: paginatedUsers,
    total: filteredUsers.length,
    page,
    pageSize,
    totalPages: Math.ceil(filteredUsers.length / pageSize),
  })
}

// 获取单个用户
export const getUser = async (id: string): Promise<User> => {
  const user = mockUsers.find((user) => user.id === id)

  if (!user) {
    return mockResponse({} as User, "用户不存在")
  }

  return mockResponse(user)
}

// 创建用户
export const createUser = async (userData: Partial<User>): Promise<User> => {
  // 检查邮箱是否已存在
  if (mockUsers.some((user) => user.email === userData.email)) {
    return mockResponse({} as User, "该邮箱已被注册")
  }

  const newUser: User = {
    id: String(mockUsers.length + 1),
    name: userData.name || "",
    email: userData.email || "",
    role: userData.role || "查看者",
    status: userData.status || "未激活",
    registeredAt: new Date().toISOString().split("T")[0],
    phone: userData.phone,
    address: userData.address,
    permissions: [],
    loginHistory: [],
  }

  mockUsers.push(newUser)

  return mockResponse(newUser)
}

// 更新用户
export const updateUser = async (id: string, userData: Partial<User>): Promise<User> => {
  const userIndex = mockUsers.findIndex((user) => user.id === id)

  if (userIndex === -1) {
    return mockResponse({} as User, "用户不存在")
  }

  // 检查邮箱是否已被其他用户使用
  if (userData.email && userData.email !== mockUsers[userIndex].email) {
    const emailExists = mockUsers.some((user) => user.email === userData.email && user.id !== id)
    if (emailExists) {
      return mockResponse({} as User, "该邮箱已被其他用户使用")
    }
  }

  const updatedUser = {
    ...mockUsers[userIndex],
    ...userData,
  }

  mockUsers[userIndex] = updatedUser

  return mockResponse(updatedUser)
}

// 删除用户
export const deleteUser = async (id: string): Promise<boolean> => {
  const userIndex = mockUsers.findIndex((user) => user.id === id)

  if (userIndex === -1) {
    return mockResponse(false, "用户不存在")
  }

  // 超级管理员不能删除
  if (mockUsers[userIndex].role === "超级管理员") {
    return mockResponse(false, "不能删除超级管理员")
  }

  mockUsers.splice(userIndex, 1)

  return mockResponse(true)
}

// 获取用户登录历史
export const getUserLoginHistory = async (id: string): Promise<LoginHistory[]> => {
  const user = mockUsers.find((user) => user.id === id)

  if (!user) {
    return mockResponse([], "用户不存在")
  }

  return mockResponse(user.loginHistory || [])
}

// 更改用户状态
export const changeUserStatus = async (id: string, status: User["status"]): Promise<User> => {
  const userIndex = mockUsers.findIndex((user) => user.id === id)

  if (userIndex === -1) {
    return mockResponse({} as User, "用户不存在")
  }

  mockUsers[userIndex].status = status

  return mockResponse(mockUsers[userIndex])
}