"use server";

import db from "@/lib/db";
import {
  CreateUserParams,
  InviteUserParams,
  UpdateUserParams,
  User,
  UserFromSupabase,
} from "@/src/models/users/users.model";
import { createClient } from "@supabase/supabase-js";

import { createClient as supabaseUser } from "@/utils/supabase/server";

// Initialize Supabase client with admin key

// Fetch all users
export async function fetchUsers(): Promise<User[]> {
  // const { data, error } = await supabase.auth.admin.listUsers();

  // if (error) {
  //   console.error("Error fetching users:", error);
  //   throw new Error(error.message);
  // }

  // return data.users.map((user) => ({
  //   ...user,
  // })) as User[];

  const users = await db.users.findMany({
    include: {
      profile: true,
    },
  });

  if (!users) {
    throw new Error("Users not found");
  }

  return users;
}

// get current user
export async function getCurrentUser(): Promise<User> {
  const supabase = await supabaseUser();

  const {
    data: { user },
    error,
  } = await supabase.auth.getUser();

  if (error) {
    console.error("Error fetching current user:", error);
    throw new Error(error.message);
  }

  const userDetail = await db.users.findUnique({
    where: {
      id: user?.id,
    },
    include: {
      profile: true,
    },
  });

  if (!userDetail) {
    throw new Error("User not found");
  }

  return userDetail;
}

// Create a new user
export async function createUser(
  params: CreateUserParams
): Promise<UserFromSupabase> {
  const supabase = createClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.SERVICE_ROLE_SECRET!
  );

  const { data, error } = await supabase.auth.admin.createUser({
    email: params.email,
    password: params.password,
    phone: params.phone,
    email_confirm: params.email_confirm,
  });

  if (error) {
    console.error("Error creating user:", error);
    throw new Error(error.message);
  }

  return {
    ...data.user,
  };
}

// Update an existing user
export async function updateUser(
  userId: string,
  params: UpdateUserParams
): Promise<UserFromSupabase> {
  const supabase = createClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.SERVICE_ROLE_SECRET!
  );

  const { data, error } = await supabase.auth.admin.updateUserById(userId, {
    email: params.email,
    phone: params.phone,
    password: params.password,
  });

  if (error) {
    console.error("Error updating user:", error);
    throw new Error(error.message);
  }

  return {
    ...data.user,
  };
}

// Delete a user
export async function deleteUser(userId: string): Promise<void> {
  const supabase = createClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.SERVICE_ROLE_SECRET!
  );

  const { error } = await supabase.auth.admin.deleteUser(userId);

  if (error) {
    console.error("Error deleting user:", error);
    throw new Error(error.message);
  }
}

// Send password recovery email
export async function sendPasswordRecovery(email: string): Promise<void> {
  const supabase = createClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.SERVICE_ROLE_SECRET!
  );

  const { error } = await supabase.auth.resetPasswordForEmail(email, {
    redirectTo: `${process.env.NEXT_PUBLIC_SITE_URL}/auth/reset-password`,
  });

  if (error) {
    console.error("Error sending password recovery:", error);
    throw new Error(error.message);
  }
}

// Send magic link
export async function sendMagicLink(email: string): Promise<void> {
  const supabase = createClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.SERVICE_ROLE_SECRET!
  );

  const { error } = await supabase.auth.signInWithOtp({
    email,
    options: {
      emailRedirectTo: `${process.env.NEXT_PUBLIC_SITE_URL}/auth/callback`,
    },
  });

  if (error) {
    console.error("Error sending magic link:", error);
    throw new Error(error.message);
  }
}

// Ban a user
export async function banUser(userId: string): Promise<UserFromSupabase> {
  const supabase = createClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.SERVICE_ROLE_SECRET!
  );

  // Ban for 100 years (effectively permanent)
  const banUntil = new Date();
  banUntil.setFullYear(banUntil.getFullYear() + 100);

  const { data, error } = await supabase.auth.admin.updateUserById(userId, {
    ban_duration: "100h",
  });

  if (error) {
    console.error("Error banning user:", error);
    throw new Error(error.message);
  }

  return {
    ...data.user,
  };
}

// Unban a user
export async function unbanUser(userId: string): Promise<UserFromSupabase> {
  const supabase = createClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.SERVICE_ROLE_SECRET!
  );

  const { data, error } = await supabase.auth.admin.updateUserById(userId, {
    ban_duration: "none",
  });

  if (error) {
    console.error("Error unbanning user:", error);
    throw new Error(error.message);
  }

  return {
    ...data.user,
  };
}

// Invite a user
export async function inviteUser(params: InviteUserParams): Promise<void> {
  const supabase = createClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.SERVICE_ROLE_SECRET!
  );

  const { error } = await supabase.auth.admin.inviteUserByEmail(params.email, {
    redirectTo: `${process.env.NEXT_PUBLIC_SITE_URL}/auth/callback`,
  });

  if (error) {
    console.error("Error inviting user:", error);
    throw new Error(error.message);
  }
}