Data Methodology & Limitations

// Fetch data for bike type comparison
const fetchData = async () => {
  try {
    setRegularBikeLoading(true)
    setEBikeLoading(true)
    setRegularBikeError(null)
    setEBikeError(null)

    // Format date for API query (YYYY-MM-DD)
    const formatDateForQuery = (date) => {
      return date.toISOString().split("T")[0]
    }

    // Use the selected date range or default to 1 year ago
    let fromDate = dateRange?.from || subYears(new Date(), 1)
    let toDate = dateRange?.to || new Date()

    const dateFilter = `crash_date between '${formatDateForQuery(fromDate)}' and '${formatDateForQuery(toDate)}'`

    // Fetch all incidents for the date range
    const allIncidentsResponse = await fetch(
      `https://data.cityofnewyork.us/resource/h9gi-nx95.json?$where=${dateFilter}&$limit=50000`
    )

    if (!allIncidentsResponse.ok) {
      throw new Error(`Failed to fetch data: ${allIncidentsResponse.status} ${allIncidentsResponse.statusText}`)
    }

    const allIncidents = await allIncidentsResponse.json()
    console.log(`Fetched ${allIncidents.length} total incidents`)

    // Process and categorize the data
    const regularBikeIncidents = []
    const eBikeIncidents = []

    // Track vehicle types for analysis
    const vehicleTypeCounts = {}

    // Process each incident to categorize and count vehicle types
    allIncidents.forEach((incident) => {
      // Count vehicle types for analysis
      const vehicleType1 = incident.vehicle_type_code1 || "Unknown"
      const vehicleType2 = incident.vehicle_type_code2 || "Unknown"

      if (vehicleType1 !== "Unknown") {
        vehicleTypeCounts[vehicleType1] = (vehicleTypeCounts[vehicleType1] || 0) + 1
      }

      if (vehicleType2 !== "Unknown") {
        vehicleTypeCounts[vehicleType2] = (vehicleTypeCounts[vehicleType2] || 0) + 1
      }

      // Categorize based on vehicle type
      if (isEBikeIncident(incident)) {
        eBikeIncidents.push(incident)
      } else if (isRegularBikeIncident(incident)) {
        regularBikeIncidents.push(incident)
      }
    })

    console.log(
      `Categorized ${regularBikeIncidents.length} regular bike incidents and ${eBikeIncidents.length} e-bike incidents`
    )

    // Filter out entries without valid coordinates for both datasets
    const filterValidCoordinates = (data) => {
      return data.filter((item) => {
        if (!item.latitude || !item.longitude) return false

        const lat = Number.parseFloat(item.latitude)
        const lng = Number.parseFloat(item.longitude)

        return !isNaN(lat) && !isNaN(lng) && lat >= 40.4 && lat <= 41.0 && lng >= -74.3 && lng <= -73.6
      })
    }

    const validRegularBikeData = filterValidCoordinates(regularBikeIncidents)
    const validEBikeData = filterValidCoordinates(eBikeIncidents)

    setRegularBikeData(validRegularBikeData)
    setEBikeData(validEBikeData)
  } catch (err) {
    console.error("Error fetching data:", err)
    const errorMessage = err instanceof Error ? err.message : "An unknown error occurred"
    setRegularBikeError(errorMessage)
    setEBikeError(errorMessage)
    
    // Initialize with empty arrays on error
    setRegularBikeData([])
    setEBikeData([])
  } finally {
    setRegularBikeLoading(false)
    setEBikeLoading(false)
  }
}