"use client"

import { useState, useEffect, useCallback } from 'react'
import { useAuth } from './use-auth'

export interface SubscriptionStatus {
  isActive: boolean
  status: 'active' | 'inactive' | 'cancelled' | 'past_due' | 'trialing' | 'trial'
  environment: 'sandbox' | 'production'
  currentPeriodStart?: Date
  currentPeriodEnd?: Date
  cancelAtPeriodEnd: boolean
  grandfatheredFacilities: string[]
  grandfatheredFacilitiesDetails?: Array<{
    _id: string
    name: string
    slug: string
    location: {
      city: string
      state: string
    }
  }>
  canManageFacilities: boolean
}

export function useSubscription() {
  const { user, isAuthenticated } = useAuth()
  const [subscriptionStatus, setSubscriptionStatus] = useState<SubscriptionStatus | null>(null)
  const [isLoading, setIsLoading] = useState(true)
  const [error, setError] = useState<string | null>(null)

  const fetchSubscriptionStatus = useCallback(async () => {
    if (!isAuthenticated || !user || user.role !== 'facility_owner') {
      setSubscriptionStatus(null)
      setIsLoading(false)
      return
    }

    try {
      setIsLoading(true)
      setError(null)

      const token = localStorage.getItem('geezer_guide_token')
      const response = await fetch('/api/subscription/status', {
        headers: {
          'Authorization': `Bearer ${token}`,
        },
      })

      const data = await response.json()

      if (data.success) {
        setSubscriptionStatus(data.data)
      } else {
        setError(data.message || 'Failed to fetch subscription status')
      }
    } catch (err: any) {
      console.error('Error fetching subscription status:', err)
      setError('Failed to fetch subscription status')
    } finally {
      setIsLoading(false)
    }
  }, [isAuthenticated, user])

  useEffect(() => {
    fetchSubscriptionStatus()
  }, [fetchSubscriptionStatus])

  const isSubscribed = subscriptionStatus?.isActive || false
  const canClaim = subscriptionStatus?.isActive || false
  const canEdit = (facilityId?: string) => {
    if (!subscriptionStatus) return false
    if (subscriptionStatus.isActive) return true
    if (facilityId && subscriptionStatus.grandfatheredFacilities.includes(facilityId)) return true
    return false
  }

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

  return {
    subscriptionStatus,
    isLoading,
    error,
    isSubscribed,
    canClaim,
    canEdit,
    refresh,
    // Convenience properties
    isActive: subscriptionStatus?.isActive || false,
    status: subscriptionStatus?.status || 'inactive',
    environment: subscriptionStatus?.environment || 'production',
    currentPeriodStart: subscriptionStatus?.currentPeriodStart,
    currentPeriodEnd: subscriptionStatus?.currentPeriodEnd,
    cancelAtPeriodEnd: subscriptionStatus?.cancelAtPeriodEnd || false,
    grandfatheredFacilities: subscriptionStatus?.grandfatheredFacilities || [],
    grandfatheredFacilitiesDetails: subscriptionStatus?.grandfatheredFacilitiesDetails || [],
  }
}