import { useEffect, useRef, useState } from "react";
import type { SightingType, SightingWidgetType } from "../types/types";

async function fetchSighting(
  url: string,
  ref: number
): Promise<SightingWidgetType> {
  const res = await fetch(`${url}${ref}`);
  if (!res.ok) throw new Error(String(res.status));
  return await res.json();
}

export function useSightingFeed(url: string) {
  const [sightings, setSightings] = useState<SightingWidgetType[]>([]);
  const [selectedRef, setSelectedRef] = useState<number | null>(null);
  const [mostRecent, setMostRecent] = useState<SightingWidgetType | null>(null);
  const [selectedSighting, setSelectedSighting] = useState<SightingType | null>(
    null
  );

  const currentRef = useRef<number>(-1);
  const pollingTimeout = useRef<ReturnType<typeof setTimeout> | null>(null);
  const lastValidTimestamp = useRef<number>(Date.now());

  useEffect(() => {
    const poll = async () => {
      try {
        const data = await fetchSighting(url, currentRef.current);

        const now = Date.now();

        if (data.ref === -1) {
          if (now - lastValidTimestamp.current > 60000) {
            console.warn("No valid sighting in over a minute. Restarting...");
            currentRef.current = -1;
            lastValidTimestamp.current = now;
          }

          pollingTimeout.current = setTimeout(poll, 400);
        } else {
          currentRef.current = data.ref;
          lastValidTimestamp.current = now;

          setSightings((prev) => {
            const updated = [data, ...prev].slice(0, 7);
            return updated;
          });

          setMostRecent(data);
          setSelectedRef(data.ref);

          pollingTimeout.current = setTimeout(poll, 100);
        }
      } catch (err) {
        console.error("Polling error:", err);
        pollingTimeout.current = setTimeout(poll, 100);
      }
    };

    poll();

    return () => {
      if (pollingTimeout.current) clearTimeout(pollingTimeout.current);
    };
  }, [url]);

  // const selected = sightings.find(s => s?.ref === selectedRef) ?? mostRecent;

  return {
    sightings,
    selectedRef,
    setSelectedRef,
    mostRecent,
    setSelectedSighting,
    selectedSighting,
    // effectiveSelected: selected,
  };
}