SkateSpots/src/hooks/useTours.ts

import { useQuery } from '@tanstack/react-query';
import { SKATE_TOUR_KIND, parseSkateTour, isFeaturedActive, type SkateTour } from '@/lib/types';
import { useSkateRelays } from '@/hooks/useSkateRelays';
import { useAdminModeration, filterAdminHidden } from '@/hooks/useAdminModeration';

/** Sort featured (Pro) tours first, then newest. */
function sortTours(a: SkateTour, b: SkateTour): number {
  const af = isFeaturedActive(a.featuredUntil) ? 1 : 0;
  const bf = isFeaturedActive(b.featuredUntil) ? 1 : 0;
  if (af !== bf) return bf - af;
  return b.createdAt - a.createdAt;
}

const STALE_TIME = 5 * 60 * 1000;  // 5 min
const GC_TIME    = 30 * 60 * 1000; // 30 min
const TIMEOUT    = 8000;

export function useTours(limit = 100, options: { includeHidden?: boolean } = {}) {
  const { includeHidden = false } = options;
  const { querySkateContent, getQueryKeySuffix } = useSkateRelays();
  const hidden = useAdminModeration();

  return useQuery({
    queryKey: ['skate-tours', limit, getQueryKeySuffix()],
    // `includeHidden`: admin tooling only (review queue + undo).
    select: (tours: SkateTour[]) =>
      includeHidden ? tours : filterAdminHidden(tours, SKATE_TOUR_KIND, hidden),
    queryFn: async () => {
      const signal = AbortSignal.timeout(TIMEOUT);

      const events = await querySkateContent(
        [
          {
            kinds: [SKATE_TOUR_KIND],
            '#t': ['skate-tour'],
            limit,
          },
        ],
        { signal, requireAny: true }
      );

      const tours: SkateTour[] = [];
      for (const event of events) {
        const tour = parseSkateTour(event);
        if (tour) tours.push(tour);
      }

      return tours.sort(sortTours);
    },
    staleTime: STALE_TIME,
    gcTime: GC_TIME,
    refetchOnMount: true,
  });
}

export function useTour(identifier: string, pubkey?: string) {
  const { querySkateContent, getQueryKeySuffix } = useSkateRelays();
  const hidden = useAdminModeration();

  return useQuery({
    queryKey: ['skate-tour', identifier, pubkey, getQueryKeySuffix()],
    select: (tour: SkateTour | null) =>
      tour && hidden.has({ coord: `${SKATE_TOUR_KIND}:${tour.pubkey}:${tour.identifier}`, id: tour.id })
        ? null
        : tour,
    queryFn: async () => {
      const signal = AbortSignal.timeout(TIMEOUT);

      const filter: {
        kinds: number[];
        '#d': string[];
        authors?: string[];
        limit: number;
      } = {
        kinds: [SKATE_TOUR_KIND],
        '#d': [identifier],
        limit: 1,
      };

      if (pubkey) {
        filter.authors = [pubkey];
      }

      const events = await querySkateContent([filter], { signal });

      if (events.length === 0) return null;

      return parseSkateTour(events[0]);
    },
    enabled: !!identifier,
    staleTime: STALE_TIME,
    gcTime: GC_TIME,
    refetchOnMount: true,
  });
}

export function useUserTours(pubkey: string) {
  const { querySkateContent, getQueryKeySuffix } = useSkateRelays();

  return useQuery({
    queryKey: ['user-skate-tours', pubkey, getQueryKeySuffix()],
    queryFn: async () => {
      const signal = AbortSignal.timeout(TIMEOUT);

      const events = await querySkateContent(
        [
          {
            kinds: [SKATE_TOUR_KIND],
            authors: [pubkey],
            '#t': ['skate-tour'],
            limit: 50,
          },
        ],
        { signal }
      );

      const tours: SkateTour[] = [];
      for (const event of events) {
        const tour = parseSkateTour(event);
        if (tour) tours.push(tour);
      }

      return tours.sort((a, b) => b.createdAt - a.createdAt);
    },
    enabled: !!pubkey,
    staleTime: STALE_TIME,
    gcTime: GC_TIME,
    refetchOnMount: true,
  });
}