'use client'

import useSWR from 'swr'
import { useCallback, useEffect, useState } from 'react'

const fetcher = (url: string) => fetch(url).then(r => {
  if (!r.ok) throw new Error('Failed to fetch')
  return r.json()
})

// Polling interval: 10 seconds
const POLLING_INTERVAL = 10000

interface UseLiveDataOptions {
  enabled?: boolean
  interval?: number
}

/**
 * Hook for live dashboard data with 10-second polling
 */
export function useLiveDashboard(options: UseLiveDataOptions = {}) {
  const { enabled = true, interval = POLLING_INTERVAL } = options
  const [lastUpdate, setLastUpdate] = useState<Date | null>(null)

  const { data, error, isLoading, mutate } = useSWR(
    enabled ? '/api/dashboard/live' : null,
    fetcher,
    {
      refreshInterval: enabled ? interval : 0,
      revalidateOnFocus: true,
      dedupingInterval: 5000, // Prevent duplicate requests within 5s
      onSuccess: () => setLastUpdate(new Date()),
    }
  )

  const refresh = useCallback(() => {
    mutate()
  }, [mutate])

  return {
    data,
    error,
    isLoading,
    lastUpdate,
    refresh,
    isPolling: enabled,
  }
}

/**
 * Hook for live character data with 10-second polling
 */
export function useLiveCharacter(characterId: string | null, options: UseLiveDataOptions = {}) {
  const { enabled = true, interval = POLLING_INTERVAL } = options
  const [lastUpdate, setLastUpdate] = useState<Date | null>(null)

  const shouldFetch = enabled && characterId

  const { data, error, isLoading, mutate } = useSWR(
    shouldFetch ? `/api/character/${characterId}/live` : null,
    fetcher,
    {
      refreshInterval: shouldFetch ? interval : 0,
      revalidateOnFocus: true,
      dedupingInterval: 5000,
      onSuccess: () => setLastUpdate(new Date()),
    }
  )

  const refresh = useCallback(() => {
    mutate()
  }, [mutate])

  return {
    data,
    error,
    isLoading,
    lastUpdate,
    refresh,
    isPolling: !!shouldFetch,
  }
}

/**
 * Hook to manage polling state across the app
 */
export function usePollingControl() {
  const [isPollingEnabled, setIsPollingEnabled] = useState(true)

  // Pause polling when tab is not visible
  useEffect(() => {
    const handleVisibilityChange = () => {
      setIsPollingEnabled(!document.hidden)
    }

    document.addEventListener('visibilitychange', handleVisibilityChange)
    return () => document.removeEventListener('visibilitychange', handleVisibilityChange)
  }, [])

  const pausePolling = useCallback(() => setIsPollingEnabled(false), [])
  const resumePolling = useCallback(() => setIsPollingEnabled(true), [])

  return {
    isPollingEnabled,
    pausePolling,
    resumePolling,
  }
}

/**
 * Time since last update (formatted)
 */
export function useTimeSinceUpdate(lastUpdate: Date | null): string {
  const [timeString, setTimeString] = useState('Gerade eben')

  useEffect(() => {
    if (!lastUpdate) return

    const updateTime = () => {
      const seconds = Math.floor((Date.now() - lastUpdate.getTime()) / 1000)
      
      if (seconds < 5) {
        setTimeString('Gerade eben')
      } else if (seconds < 60) {
        setTimeString(`Vor ${seconds}s`)
      } else {
        const minutes = Math.floor(seconds / 60)
        setTimeString(`Vor ${minutes}m`)
      }
    }

    updateTime()
    const interval = setInterval(updateTime, 1000)
    return () => clearInterval(interval)
  }, [lastUpdate])

  return timeString
}