import { useState, useEffect, useCallback } from 'react';

import { usePlaybasis } from '../PlaybasisProvider';
import type { Reward, RedemptionResult } from '../types';

interface UseRewardsReturn {
  rewards: Reward[];
  loading: boolean;
  error: Error | null;
  refresh: () => Promise<void>;
  redeem: (rewardId: string) => Promise<RedemptionResult>;
  redeeming: boolean;
}

export function useRewards(): UseRewardsReturn {
  const { client, playerId } = usePlaybasis();
  const [rewards, setRewards] = useState<Reward[]>([]);
  const [loading, setLoading] = useState(true);
  const [redeeming, setRedeeming] = useState(false);
  const [error, setError] = useState<Error | null>(null);

  const fetchRewards = useCallback(async () => {
    setLoading(true);
    setError(null);

    try {
      const allRewards = await client.getRewards();
      setRewards(allRewards);
    } catch (err) {
      setError(err instanceof Error ? err : new Error('Failed to fetch rewards'));
    } finally {
      setLoading(false);
    }
  }, [client]);

  useEffect(() => {
    fetchRewards();
  }, [fetchRewards]);

  const redeem = useCallback(
    async (rewardId: string): Promise<RedemptionResult> => {
      if (!playerId) {
        return { success: false, message: 'No player ID set' };
      }

      setRedeeming(true);
      try {
        const result = await client.redeemReward(playerId, rewardId);
        // Refresh rewards after redemption
        await fetchRewards();
        return result;
      } catch (err) {
        return {
          success: false,
          message: err instanceof Error ? err.message : 'Redemption failed',
        };
      } finally {
        setRedeeming(false);
      }
    },
    [client, playerId, fetchRewards],
  );

  return {
    rewards,
    loading,
    error,
    refresh: fetchRewards,
    redeem,
    redeeming,
  };
}

export default useRewards;