import { FastifyInstance } from "fastify";
import { requirePermission } from "../../middleware/auth";
import { logAudit } from "../../services/audit";
import { success, error, parseId } from "../../utils/response";
import { parsePagination, buildPaginationMeta } from "../../utils/pagination";
import { parseBody } from "../../schemas/common";
import { CreateUserSchema, UpdateUserSchema } from "../../schemas/users.schema";
import {
  listUsers,
  getUser,
  createUser,
  updateUser,
  deleteUser,
} from "../../services/users.service";

export default async function usersRoutes(
  fastify: FastifyInstance,
): Promise<void> {
  // GET /api/admin/users
  fastify.get(
    "/",
    { preHandler: requirePermission("users.view") },
    async (request, reply) => {
      const params = parsePagination(request.query as Record<string, unknown>);
      const result = await listUsers(params);

      return reply.send({
        success: true,
        data: result.users,
        pagination: buildPaginationMeta(
          result.total,
          result.page,
          result.limit,
        ),
      });
    },
  );

  // GET /api/admin/users/:id
  fastify.get<{ Params: { id: string } }>(
    "/:id",
    { preHandler: requirePermission("users.view") },
    async (request, reply) => {
      const id = parseId(request.params.id, reply);
      if (id === null) return;

      const user = await getUser(id);
      if (!user) return error(reply, "Uživatel nenalezen", 404);
      return success(reply, user);
    },
  );

  // POST /api/admin/users
  fastify.post(
    "/",
    { preHandler: requirePermission("users.create") },
    async (request, reply) => {
      const parsed = parseBody(CreateUserSchema, request.body);
      if ("error" in parsed) return error(reply, parsed.error, 400);
      const body = parsed.data;

      const result = await createUser({
        username: body.username,
        email: body.email,
        password: body.password,
        first_name: body.first_name,
        last_name: body.last_name,
        role_id: body.role_id,
        is_active: body.is_active,
      });

      if ("error" in result) return error(reply, result.error!, result.status!);

      await logAudit({
        request,
        authData: request.authData,
        action: "create",
        entityType: "user",
        entityId: result.user.id,
        description: `Vytvořen uživatel ${result.user.username}`,
      });

      return success(
        reply,
        { id: result.user.id },
        201,
        "Uživatel byl vytvořen",
      );
    },
  );

  // PUT /api/admin/users/:id
  fastify.put<{ Params: { id: string } }>(
    "/:id",
    { preHandler: requirePermission("users.edit") },
    async (request, reply) => {
      const id = parseId(request.params.id, reply);
      if (id === null) return;
      const parsed = parseBody(UpdateUserSchema, request.body);
      if ("error" in parsed) return error(reply, parsed.error, 400);

      const userData = {
        ...parsed.data,
        role_id:
          parsed.data.role_id != null
            ? Number(parsed.data.role_id)
            : (parsed.data.role_id as number | null | undefined),
      };
      const result = await updateUser(id, userData);
      if ("error" in result) return error(reply, result.error!, result.status!);

      await logAudit({
        request,
        authData: request.authData,
        action: "update",
        entityType: "user",
        entityId: id,
        description: `Upraven uživatel ${result.username}`,
      });

      return success(reply, { id }, 200, "Uživatel byl uložen");
    },
  );

  // DELETE /api/admin/users/:id
  fastify.delete<{ Params: { id: string } }>(
    "/:id",
    { preHandler: requirePermission("users.delete") },
    async (request, reply) => {
      const id = parseId(request.params.id, reply);
      if (id === null) return;

      const result = await deleteUser(id, request.authData?.userId);
      if ("error" in result) return error(reply, result.error!, result.status!);

      await logAudit({
        request,
        authData: request.authData,
        action: "delete",
        entityType: "user",
        entityId: id,
        description: `Smazán uživatel ${result.username}`,
      });

      return success(reply, null, 200, "Uživatel smazán");
    },
  );
}