'use client'

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

export interface SearchFilters {
  query?: string
  city?: string
  state?: string
  zipCode?: string
  county?: string
  stateRegion?: string
  hhscSubOffice?: string
  administrator?: string
  licenseNumber?: string
  careTypes?: string[]
  serviceTypes?: string[]
  minPrice?: number
  maxPrice?: number
  minCapacity?: number
  maxCapacity?: number
  alzheimerCertified?: boolean
  facilityLicensed?: boolean
  facilityCertified?: boolean
  hasPhone?: boolean
  hasEmail?: boolean
  hasFax?: boolean
  radius?: number
  sortBy?: string
  page?: number
  limit?: number
}

export interface FacilitySearchResult {
  id: string
  name: string
  type: string
  serviceType?: string
  location: string
  city?: string
  state?: string
  zipCode?: string
  county?: string
  stateRegion?: string
  hhscSubOffice?: string
  distance: string | null
  rating: number
  reviewCount: number
  capacity: number
  licensedOnlyBeds?: number
  medicaidOnlyBeds?: number
  medicareOnlyBeds?: number
  medicaidMedicareBeds?: number
  icfiidBeds?: number
  alzheimerCapacity?: number
  licenseNumber?: string
  licenseType?: string
  effectiveDate?: string
  expirationDate?: string
  initialLicenseDate?: string
  medicareProviderNumber?: string
  medicaidProviderNumber?: string
  alzheimerCertificateNo?: string
  phone: string
  email?: string
  fax?: string
  providerEmail?: string
  website?: string
  administrator?: string
  image: string
  amenities: string[]
  verified: boolean
  featured: boolean
  alzheimerCertified: boolean
  facilityCertified: boolean
  claimStatus: string
  facilityId?: string
  coordinates: {
    lat: number | null
    lng: number | null
  }
  isFavorite?: boolean
  favoritesCount?: number
}

export interface SearchResponse {
  facilities: FacilitySearchResult[]
  pagination: {
    page: number
    limit: number
    total: number
    pages: number
  }
  filters: any
}

export function useFacilitySearch() {
  const [data, setData] = useState<SearchResponse | null>(null)
  const [loading, setLoading] = useState(false)
  const [error, setError] = useState<string | null>(null)
  const [userLocation, setUserLocation] = useState<{ lat: number; lng: number } | null>(null)
  const [locationPermission, setLocationPermission] = useState<'prompt' | 'granted' | 'denied'>('prompt')

  // Request user location
  const requestLocation = useCallback(() => {
    if ('geolocation' in navigator) {
      setLocationPermission('prompt')
      navigator.geolocation.getCurrentPosition(
        (position) => {
          setUserLocation({
            lat: position.coords.latitude,
            lng: position.coords.longitude
          })
          setLocationPermission('granted')
        },
        (error) => {
          console.error('Geolocation error:', error)
          setLocationPermission('denied')
          setUserLocation(null)
        }
      )
    }
  }, [])

  // Search facilities
  const searchFacilities = useCallback(async (filters: SearchFilters = {}, coordinates?: { lat: number; lng: number }) => {
    setLoading(true)
    setError(null)

    try {
      const searchParams = new URLSearchParams()
      
      // Add coordinates if available
      const coords = coordinates || userLocation
      if (coords) {
        searchParams.set('lat', coords.lat.toString())
        searchParams.set('lng', coords.lng.toString())
      }

      // Add all filters
      if (filters.query) searchParams.set('q', filters.query)
      if (filters.city) searchParams.set('city', filters.city)
      if (filters.state) searchParams.set('state', filters.state)
      if (filters.zipCode) searchParams.set('zip', filters.zipCode)
      if (filters.county) searchParams.set('county', filters.county)
      if (filters.stateRegion) searchParams.set('stateRegion', filters.stateRegion)
      if (filters.hhscSubOffice) searchParams.set('hhscSubOffice', filters.hhscSubOffice)
      if (filters.administrator) searchParams.set('administrator', filters.administrator)
      if (filters.licenseNumber) searchParams.set('licenseNumber', filters.licenseNumber)
      if (filters.careTypes?.length) searchParams.set('careTypes', filters.careTypes.join(','))
      if (filters.serviceTypes?.length) searchParams.set('serviceTypes', filters.serviceTypes.join(','))
      if (filters.minPrice) searchParams.set('minPrice', filters.minPrice.toString())
      if (filters.maxPrice) searchParams.set('maxPrice', filters.maxPrice.toString())
      if (filters.minCapacity) searchParams.set('minCapacity', filters.minCapacity.toString())
      if (filters.maxCapacity) searchParams.set('maxCapacity', filters.maxCapacity.toString())
      if (filters.alzheimerCertified) searchParams.set('alzheimer', 'true')
      if (filters.facilityLicensed) searchParams.set('licensed', 'true')
      if (filters.facilityCertified) searchParams.set('certified', 'true')
      if (filters.hasPhone) searchParams.set('hasPhone', 'true')
      if (filters.hasEmail) searchParams.set('hasEmail', 'true')
      if (filters.hasFax) searchParams.set('hasFax', 'true')
      if (filters.radius) searchParams.set('radius', filters.radius.toString())
      if (filters.sortBy) searchParams.set('sortBy', filters.sortBy)
      if (filters.page) searchParams.set('page', filters.page.toString())
      if (filters.limit) searchParams.set('limit', filters.limit.toString())

      const apiUrl = `/api/facilities/search?${searchParams.toString()}`
      console.log('🔍 Search API URL:', apiUrl)
      
      const response = await fetch(apiUrl)
      
      if (!response.ok) {
        throw new Error('Failed to search facilities')
      }

      const result = await response.json()
      
      if (result.success) {
        setData(result.data)
      } else {
        throw new Error(result.message || 'Search failed')
      }
    } catch (err: any) {
      console.error('Search error:', err)
      setError(err.message || 'Failed to search facilities')
      setData(null)
    } finally {
      setLoading(false)
    }
  }, [userLocation])

  // Get nearby facilities
  const getNearbyFacilities = useCallback(async (radius: number = 25, limit: number = 10) => {
    setLoading(true)
    setError(null)

    try {
      const searchParams = new URLSearchParams()
      searchParams.set('radius', radius.toString())
      searchParams.set('limit', limit.toString())
      
      if (userLocation) {
        searchParams.set('lat', userLocation.lat.toString())
        searchParams.set('lng', userLocation.lng.toString())
      }

      const response = await fetch(`/api/facilities/nearby?${searchParams.toString()}`)
      
      if (!response.ok) {
        throw new Error('Failed to get nearby facilities')
      }

      const result = await response.json()
      
      if (result.success) {
        setData(result.data)
      } else {
        throw new Error(result.message || 'Failed to get nearby facilities')
      }
    } catch (err: any) {
      console.error('Nearby facilities error:', err)
      setError(err.message || 'Failed to get nearby facilities')
      setData(null)
    } finally {
      setLoading(false)
    }
  }, [userLocation])

  return {
    data,
    loading,
    error,
    userLocation,
    locationPermission,
    requestLocation,
    searchFacilities,
    getNearbyFacilities
  }
}