import { useState, useEffect } from 'react';
import { useDubs } from '../provider';

export interface ClaimStatus {
  /** Whether the current wallet has claimed this game's prize */
  hasClaimed: boolean;
  /** Amount claimed (null if not claimed) */
  amountClaimed: number | null;
  /** Claim transaction signature (null if not claimed) */
  claimSignature: string | null;
  /** Whether the game has been resolved */
  isResolved: boolean;
  /** Loading state */
  loading: boolean;
  /** Error if fetch failed */
  error: Error | null;
  /** Re-fetch claim status */
  refetch: () => void;
}

/**
 * Check whether the current wallet has already claimed a prize for a game.
 *
 * Uses the game detail endpoint which includes per-bettor claim data.
 */
export function useHasClaimed(gameId: string | null): ClaimStatus {
  const { client, wallet } = useDubs();
  const [hasClaimed, setHasClaimed] = useState(false);
  const [amountClaimed, setAmountClaimed] = useState<number | null>(null);
  const [claimSignature, setClaimSignature] = useState<string | null>(null);
  const [isResolved, setIsResolved] = useState(false);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<Error | null>(null);
  const [trigger, setTrigger] = useState(0);

  const refetch = () => setTrigger(t => t + 1);

  useEffect(() => {
    if (!gameId || !wallet.publicKey) {
      setHasClaimed(false);
      setAmountClaimed(null);
      setClaimSignature(null);
      setIsResolved(false);
      return;
    }

    let cancelled = false;
    setLoading(true);
    setError(null);

    client
      .getGame(gameId)
      .then(game => {
        if (cancelled) return;
        setIsResolved(game.isResolved);

        const myWallet = wallet.publicKey!.toBase58();
        const myBet = game.bettors?.find(b => b.wallet === myWallet);

        if (myBet?.amountClaimed != null && myBet.amountClaimed > 0) {
          setHasClaimed(true);
          setAmountClaimed(myBet.amountClaimed);
          setClaimSignature(myBet.claimSignature ?? null);
        } else {
          setHasClaimed(false);
          setAmountClaimed(null);
          setClaimSignature(null);
        }
      })
      .catch(err => {
        if (!cancelled) {
          setError(err instanceof Error ? err : new Error(String(err)));
        }
      })
      .finally(() => {
        if (!cancelled) setLoading(false);
      });

    return () => {
      cancelled = true;
    };
  }, [gameId, wallet.publicKey, client, trigger]);

  return { hasClaimed, amountClaimed, claimSignature, isResolved, loading, error, refetch };
}