"use client";

import { useQuery } from "@tanstack/react-query";
import { getSupabaseBrowserClient } from "@/lib/supabase/client";

export interface UserGroup {
  id: string;
  name: string;
  created_by: string;
  creator_name: string;
  movie_count: number;
}

async function fetchUserGroups(): Promise<UserGroup[]> {
  const supabase = getSupabaseBrowserClient();

  const {
    data: { user },
  } = await supabase.auth.getUser();
  if (!user) return [];

  const { data: memberships, error: memberError } = await supabase
    .from("group_members")
    .select("group_id")
    .eq("user_id", user.id);

  if (memberError) throw memberError;
  if (!memberships || memberships.length === 0) return [];

  const groupIds = memberships.map((m) => m.group_id);

  const [{ data: groups, error: groupError }, counts] = await Promise.all([
    supabase.from("groups").select("id, name, created_by").in("id", groupIds),
    Promise.all(
      groupIds.map(async (groupId) => {
        const { count } = await supabase
          .from("movies")
          .select("*", { count: "exact", head: true })
          .eq("group_id", groupId);
        return { groupId, count: count ?? 0 };
      }),
    ),
  ]);

  if (groupError) throw groupError;
  if (!groups) return [];

  const creatorIds = [...new Set(groups.map((g) => g.created_by))];
  const { data: creators } = await supabase
    .from("users")
    .select("id, display_name")
    .in("id", creatorIds);

  const creatorMap = new Map(creators?.map((c) => [c.id, c.display_name]) ?? []);
  const countMap = new Map(counts.map((c) => [c.groupId, c.count]));

  return groups.map((group) => ({
    id: group.id,
    name: group.name,
    created_by: group.created_by,
    creator_name: creatorMap.get(group.created_by) ?? "Unknown",
    movie_count: countMap.get(group.id) ?? 0,
  }));
}

export function useUserGroups() {
  return useQuery({
    queryKey: ["user-groups"],
    queryFn: fetchUserGroups,
    staleTime: 30 * 1000,
    refetchInterval: 30 * 1000,
  });
}