import {
  router,
  publicProcedure,
  isAdminMiddleware,
  isSigninMiddleware,
} from "../trpc";
import { z } from "zod";
import { statusEnumSchema } from "@/database/schema";
import { userFacadeService } from "../user/application/facade";
import { userInvitation, userSchema } from "@/lib/schemas/userSchema";
import { v4 as uuidv4 } from "uuid";
import { userToolSchema } from "@/lib/schemas/toolSchema";
import { toolServiceFacade } from "../tool/application/facade";
import { taskServiceFacade } from "../task/application/facade";

export const userRouter = router({
  getUsers: publicProcedure.use(isAdminMiddleware).query(async ({ ctx }) => {
    const userId = { value: ctx.user.userId };
    return await userFacadeService.getAllUsers(userId);
  }),
  getUserById: publicProcedure
    .input(
      z.object({
        userId: z.string(),
        range: z
          .string()
          .transform((value) => (value === "all" ? undefined : value))
          .optional(),
        status: statusEnumSchema.optional(),
      })
    )
    .query(async ({ input, ctx }) => {
      const userId = { value: input.userId };
      const data =
        (await userFacadeService.getUserWithTaskById(userId, input)) || {};
      console.log("data user", data);
      return data;
    }),
  findOrCreateUser: publicProcedure.input(userSchema).mutation(async ({input}) => {
    return await userFacadeService.findOrCreateUser(input as any);
  }),
  sendInvitation: publicProcedure
    .use(isAdminMiddleware)
    .input(userInvitation)
    .mutation(async ({ input, ctx }) => {
      try {
        return await userFacadeService.sendInvitation(input as any );
      } catch (error: any) {
        throw error;
      }
    }),
  updateUser: publicProcedure
    .use(isAdminMiddleware)
    .input(
      userSchema.partial().extend({
        id: z.string({ message: "usuario no valido" }),
      })
    )
    .mutation(async ({ input, ctx }) => {
      return await userFacadeService.updateUserClerk(input as any);
    }),
  getUserActiveTasks: publicProcedure
    .use(isSigninMiddleware)
    .input(
      z.object({
        status: z
          .enum(["pendientes", "expiradas", "completada"])
          .optional()
          .default("pendientes"),
        q: z.string().optional().default(""),
        limit: z.number().default(10),
        onlyUserTask: z.boolean().optional(),
        onlyRecentModifiedTask: z.boolean().optional(),
      })
    )
    .query(async ({ input, ctx }) => {
      return await taskServiceFacade.getAllTasks({
        status: "completada",
        range: "thisyear",
      });
    }),
  getUserRecentCompleatedTasks: publicProcedure
    .use(isAdminMiddleware)
    .input(
      z
        .object({
          range: z.string().optional().default("thisyear"),
        })
        .optional()
    )
    .query(async ({ input, ctx }) => {
      return await taskServiceFacade.getUserCompleatedTasks({
        range: input?.range,
      });
    }),
  updateAssignedUserTools: publicProcedure
    .use(isAdminMiddleware)
    .input(userToolSchema)
    .mutation(async ({ input, ctx }) => {
      return await toolServiceFacade.updateAssignUserTools(input.tools);
    }),
  deleteAsssignedUserTools: publicProcedure
    .use(isAdminMiddleware)
    .input(
      z.object({
        tools: z.array(
          z.object({
            toolId: z.string().uuid(),
            userId: z.string(),
            toolName: z.string(),
          })
        ),
      })
    )
    .mutation(async ({ input, ctx }) => {
      const { tools } = input;
      return await toolServiceFacade.deleteUserTools(tools);
    }),
  getUserWeeklyActivity: publicProcedure
    .use(isSigninMiddleware)
    .query(async ({ input, ctx }) => {
      const userId = { value: ctx?.user?.userId };
      return await taskServiceFacade.getUserWeeklyActivity(userId);
    }),
  getUserMonthActivity: publicProcedure
    .use(isSigninMiddleware)
    .query(async ({ ctx }) => {
      const userId = { value: ctx?.user?.userId };
      return (await taskServiceFacade.getUserMonthActivity(userId)) || [];
    }),
  banUser: publicProcedure
    .use(isAdminMiddleware)
    .input(
      z.object({
        userId: z.string().min(1, { message: "User id invalid" }),
      })
    )
    .mutation(async ({ input, ctx }) => {
      return await userFacadeService.banUser({ value: input.userId });
    }),
  unbanUser: publicProcedure
    .use(isAdminMiddleware)
    .input(
      z.object({
        userId: z.string().min(1, { message: "User id invalid" }),
      })
    )
    .mutation(async ({ input, ctx }) => {
      return await userFacadeService.unbanUser({ value: input.userId });
    }),
  deleteUser: publicProcedure
    .use(isAdminMiddleware)
    .input(
      z.object({
        userId: z.string().min(1, { message: "User id invalid" }),
      })
    )
    .mutation(async ({ input, ctx }) => {
      return await userFacadeService.deleteUserClerk({ value: input.userId });
    }),
});