SkateSpots/src/hooks/useSkateSpots.ts

import { useQuery } from '@tanstack/react-query';
import { SKATE_SPOT_KIND, parseSkateSpot, type SkateSpot } from '@/lib/types';
import { useSkateRelays } from '@/hooks/useSkateRelays';
import { useAdminModeration, filterAdminHidden } from '@/hooks/useAdminModeration';
import { cacheSpots, getAllCachedSpots, isOffline } from '@/lib/offlineCache';

// Spots change infrequently — cache for 5 minutes, keep for 30 minutes
const SPOTS_STALE_TIME = 5 * 60 * 1000;   // 5 min
const SPOTS_GC_TIME    = 30 * 60 * 1000;  // 30 min
const QUERY_TIMEOUT    = 15000;            // 15s — mobile cold-start needs more time

/**
 * Spots, newest first.
 *
 * `includeHidden` is for ADMIN TOOLING ONLY (the review queue): without it a spot
 * you just hid vanishes from the list, so there is no way to undo the verdict.
 * Normal callers must leave it off so hidden spots stay hidden.
 */
export function useSkateSpots(limit = 100, options: { includeHidden?: boolean } = {}) {
  const { includeHidden = false } = options;
  const { querySkateContent, getQueryKeySuffix } = useSkateRelays();
  const hidden = useAdminModeration();

  return useQuery({
    queryKey: ['skate-spots', limit, includeHidden, getQueryKeySuffix()],
    select: (spots: SkateSpot[]) =>
      includeHidden ? spots : filterAdminHidden(spots, SKATE_SPOT_KIND, hidden),
    queryFn: async () => {
      // If offline, return cached spots
      if (isOffline()) {
        const cachedSpots = await getAllCachedSpots();
        return cachedSpots.sort((a, b) => b.createdAt - a.createdAt).slice(0, limit);
      }

      const signal = AbortSignal.timeout(QUERY_TIMEOUT);

      const events = await querySkateContent(
        [
          {
            kinds: [SKATE_SPOT_KIND],
            '#t': ['skatespot'],
            limit,
          },
        ],
        { signal }
      );

      const spots: SkateSpot[] = [];
      const spotsWithEvents: Array<{ event: typeof events[0]; spot: SkateSpot }> = [];

      for (const event of events) {
        const spot = parseSkateSpot(event);
        if (spot) {
          spots.push(spot);
          spotsWithEvents.push({ event, spot });
        }
      }

      // Cache spots in the background for offline use
      if (spotsWithEvents.length > 0) {
        cacheSpots(spotsWithEvents).catch(() => {});
      }

      return spots.sort((a, b) => b.createdAt - a.createdAt);
    },
    staleTime: SPOTS_STALE_TIME,
    gcTime: SPOTS_GC_TIME,
    // Don't force a relay round-trip on every navigation — use cache if fresh
    refetchOnMount: true,
  });
}

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

  return useQuery({
    queryKey: ['skate-spot', identifier, pubkey, getQueryKeySuffix()],
    select: (spot: SkateSpot | null) =>
      spot && hidden.has({ coord: `${SKATE_SPOT_KIND}:${spot.pubkey}:${spot.identifier}`, id: spot.id })
        ? null
        : spot,
    queryFn: async () => {
      // If offline, try to get from cache first
      if (isOffline() && pubkey) {
        const { getCachedSpot } = await import('@/lib/offlineCache');
        const cached = await getCachedSpot(pubkey, identifier);
        if (cached) return cached;
      }

      const signal = AbortSignal.timeout(QUERY_TIMEOUT);

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

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

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

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

      const spot = parseSkateSpot(events[0]);

      // Cache the spot for offline use
      if (spot) {
        const { cacheSpot } = await import('@/lib/offlineCache');
        cacheSpot(events[0], spot).catch(() => {});
      }

      return spot;
    },
    enabled: !!identifier,
    staleTime: SPOTS_STALE_TIME,
    gcTime: SPOTS_GC_TIME,
    refetchOnMount: true,
  });
}

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

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

      const events = await querySkateContent(
        [
          {
            kinds: [SKATE_SPOT_KIND],
            authors: [pubkey],
            '#t': ['skatespot'],
            limit: 50,
          },
        ],
        { signal }
      );

      const spots: SkateSpot[] = [];
      for (const event of events) {
        const spot = parseSkateSpot(event);
        if (spot) spots.push(spot);
      }

      return spots.sort((a, b) => b.createdAt - a.createdAt);
    },
    enabled: !!pubkey,
    staleTime: SPOTS_STALE_TIME,
    gcTime: SPOTS_GC_TIME,
    refetchOnMount: true,
  });
}