Let Users Speak Naturally — and Let AI Handle the Filters

import { z } from 'zod'

// Define your filter schema
const PropertySearchFilters = z.object({
  bedrooms: z.number().optional().describe('Number of bedrooms'),
  bathrooms: z.number().optional().describe('Number of bathrooms'),
  minPrice: z.number().optional().describe('Minimum price in dollars'),
  maxPrice: z.number().optional().describe('Maximum price in dollars'),
  location: z.string().optional().describe('Location or neighborhood'),
  propertyType: z.enum(['apartment', 'house', 'condo', 'townhouse']).optional(),
  amenities: z.array(z.string()).optional().describe('Required amenities'),
  petFriendly: z.boolean().optional().describe('Pet-friendly property'),
  parking: z.boolean().optional().describe('Parking available'),
})

type PropertyFilters = z.infer<typeof PropertySearchFilters>

import { generateObject } from 'ai'

export async function parseSearchQuery(query: string) {
  const { object } = await generateObject({
    model: 'openai/gpt-4o-mini',
    schema: PropertySearchFilters,
    prompt: `Extract search filters from this natural language query: "${query}"
    
    Guidelines:
    - Extract all relevant filter values
    - Convert price mentions to numbers (e.g., "$2000" -> 2000)
    - Identify location names
    - Detect amenities mentioned (parking, pool, gym, etc.)
    - Infer property type if mentioned
    - Set boolean flags for pet-friendly, parking, etc.
    
    If a filter is not mentioned, omit it from the response.`,
  })

  return object
}

'use client'

import { useState } from 'react'
import { Search } from 'lucide-react'

export function SmartSearchBar() {
  const [query, setQuery] = useState('')
  const [filters, setFilters] = useState(null)
  const [loading, setLoading] = useState(false)

  const handleSearch = async () => {
    setLoading(true)
    try {
      const response = await fetch('/api/parse-search', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ query }),
      })
      
      const data = await response.json()
      setFilters(data.filters)
      
      // Now use these filters to search your database
      await searchProperties(data.filters)
    } catch (error) {
      console.error('Search failed:', error)
    } finally {
      setLoading(false)
    }
  }

  return (
    <div className="space-y-4">
      <div className="flex gap-2">
        <input
          type="text"
          value={query}
          onChange={(e) => setQuery(e.target.value)}
          placeholder="Try: 2 bedroom apartment under $2000 near downtown"
          className="flex-1 px-4 py-2 border rounded-lg"
          onKeyDown={(e) => e.key === 'Enter' && handleSearch()}
        />
        <button
          onClick={handleSearch}
          disabled={loading}
          className="px-6 py-2 bg-primary text-white rounded-lg"
        >
          <Search className="w-5 h-5" />
        </button>
      </div>
      
      {filters && (
        <div className="flex flex-wrap gap-2">
          {Object.entries(filters).map(([key, value]) => (
            <span key={key} className="px-3 py-1 bg-primary/20 rounded-full text-sm">
              {key}: {JSON.stringify(value)}
            </span>
          ))}
        </div>
      )}
    </div>
  )
}

// app/api/parse-search/route.ts
import { NextResponse } from 'next/server'
import { parseSearchQuery } from '@/lib/search-parser'

export async function POST(request: Request) {
  try {
    const { query } = await request.json()
    
    if (!query) {
      return NextResponse.json(
        { error: 'Query is required' },
        { status: 400 }
      )
    }

    const filters = await parseSearchQuery(query)
    
    return NextResponse.json({ filters })
  } catch (error) {
    console.error('Parse error:', error)
    return NextResponse.json(
      { error: 'Failed to parse query' },
      { status: 500 }
    )
  }
}

// The AI can understand variations:
"appartment" → "apartment"
"2br" → "2 bedrooms"
"pet ok" → "pet friendly"
"dwntwn" → "downtown"
"w/ parking" → "with parking"

const { object } = await generateObject({
  model: 'openai/gpt-4o-mini',
  schema: PropertySearchFilters,
  prompt: `Extract filters from: "${query}"
  
  User context:
  - Previously searched for: ${previousSearches.join(', ')}
  - Preferred locations: ${preferredLocations.join(', ')}
  - Budget range: ${budgetRange}
  
  Use this context to better understand the query.`,
})