export function userHandlers(_io, socket) {
  socket.on("user:read", readUser)
  socket.on("user:list", listUsers)
  socket.on("user:delete", deleteUser)
  socket.on("user:create", createUser)
  socket.on("user:update", updateUser)

  async function readUser(id, callback) {
    await userHandler({
      callback,
      id,

      query: ({ id }) =>
        prisma.user.findUnique({
          omit: { banned: true, banReason: true, banExpires: true },
          where: { id }
        })
    })
  }

  async function listUsers(callback) {
    await userHandler({
      callback,

      query: () =>
        prisma.user.findMany({
          omit: { banned: true, banReason: true, banExpires: true },
          orderBy: [{ createdAt: "asc" }]
        })
    })
  }

  async function deleteUser(id, callback) {
    await userHandler({
      callback,
      permissions: ["delete"],
      id,
      mutator: (rawResult) => _pick(rawResult, ["id"]),
      query: ({ id }) => prisma.user.delete({ where: { id } })
    })
  }

  async function createUser(data, callback) {
    await userHandler({
      callback,
      permissions: ["create"],
      data,
      validator: createUserSchema.parse,

      query: ({ data }) =>
        serverAuth().api.createUser({
          body: {
            ..._omit(data, "username"),
            data: { username: data.username }
          }
        })
    })
  }

  async function updateUser(id, data, callback) {
    await userHandler({
      callback,
      permissions: ["update"],
      id,
      data,
      validator: updateUserSchema.parse,
      query: ({ id, data }) => prisma.user.update({ where: { id }, data })
    })
  }

  async function userHandler(options) {
    const defaultOptions = {
      user: socket.data?.user,
      resource: "user",
      idValidator: userSchema.shape.id.parse
    }

    const typenameMutator = injectTypename("user")
    let mutator

    if (_has(options, "mutator")) {
      mutator = _flow([options.mutator, typenameMutator])
      _unset(options, "mutator")
    } else {
      mutator = typenameMutator
    }

    return await executeQuery({ ...defaultOptions, ...options, mutator })
  }
}