IP Geolocation World Map

IP Geolocation Data Sources

// Production-ready multi-source geolocation service with confidence scoring
interface GeolocationResult {
  ip: string
  country: string
  countryCode: string
  region: string
  city: string
  postalCode?: string
  latitude?: number
  longitude?: number
  timezone?: string
  isp?: string
  organization?: string
  accuracy: 'country' | 'region' | 'city' | 'postal' | 'coordinates'
  confidence: number // 0-100
  provider: string
  cached: boolean
  timestamp: number
  metadata?: {
    isMobile?: boolean
    isVpn?: boolean
    isDatacenter?: boolean
    isCorporate?: boolean
  }
}

interface GeolocationProvider {
  name: string
  priority: number // Higher = more trusted
  cost: number // Cost per query
  rateLimit: number // Max requests per minute
  regions: string[] // Regions where provider excels
  getLocation(ip: string): Promise<GeolocationResult>
}

interface GeolocationConfig {
  providers: GeolocationProvider[]
  cache: {
    ttl: {
      country: number // seconds
      city: number
      coordinates: number
    }
    maxSize: number
  }
  fallback: {
    defaultCountry?: string
    defaultLanguage?: string
  }
  accuracy: {
    minConfidence: number // Minimum confidence to accept result
    maxProviders: number // Max providers to query
    timeout: number // Total timeout in ms
  }
}

interface ProviderPerformance {
  provider: string
  totalQueries: number
  successRate: number
  averageResponseTime: number
  accuracyScore: number // Based on ground truth data
  lastUpdated: number
}

class MultiSourceGeolocationService {
  private providers: Map<string, GeolocationProvider> = new Map()
  private performance: Map<string, ProviderPerformance> = new Map()
  private cache: Map<string, { result: GeolocationResult; expires: number }> = new Map()
  private config: GeolocationConfig

  constructor(config: GeolocationConfig) {
    this.config = config
    this.initializeProviders()
    this.startPerformanceMonitoring()
  }

  async getLocation(ip: string): Promise<GeolocationResult> {
    // Check cache first
    const cached = this.getCachedResult(ip)
    if (cached) {
      return { ...cached, cached: true }
    }

    try {
      // Query multiple providers with timeout
      const results = await this.queryProviders(ip)

      if (results.length === 0) {
        throw new Error('No geolocation data available')
      }

      // Fuse results and calculate confidence
      const fusedResult = this.fuseResults(results)
      fusedResult.cached = false
      fusedResult.timestamp = Date.now()

      // Cache result based on accuracy level
      this.cacheResult(ip, fusedResult)

      return fusedResult

    } catch (error) {
      console.error(`Geolocation failed for IP ${ip}:`, error)
      return this.getFallbackResult(ip)
    }
  }

  private async queryProviders(ip: string): Promise<GeolocationResult[]> {
    const results: GeolocationResult[] = []
    const promises: Promise<void>[] = []

    // Sort providers by priority and performance
    const sortedProviders = Array.from(this.providers.values())
      .sort((a, b) => {
        const perfA = this.performance.get(a.name)?.accuracyScore || 0
        const perfB = this.performance.get(b.name)?.accuracyScore || 0
        return (b.priority + perfB) - (a.priority + perfA)
      })
      .slice(0, this.config.accuracy.maxProviders)

    for (const provider of sortedProviders) {
      const promise = (async () => {
        try {
          const startTime = Date.now()
          const result = await provider.getLocation(ip)
          const responseTime = Date.now() - startTime

          this.updateProviderPerformance(provider.name, true, responseTime)
          results.push({ ...result, provider: provider.name })

        } catch (error) {
          console.error(`Provider ${provider.name} failed:`, error)
          this.updateProviderPerformance(provider.name, false, 0)
        }
      })()

      promises.push(promise)
    }

    // Wait for all providers or timeout
    await Promise.race([
      Promise.all(promises),
      new Promise(resolve => setTimeout(resolve, this.config.accuracy.timeout))
    ])

    return results
  }

  private fuseResults(results: GeolocationResult[]): GeolocationResult {
    if (results.length === 0) {
      throw new Error('No results to fuse')
    }

    if (results.length === 1) {
      return results[0]
    }

    // Group results by accuracy level
    const byAccuracy = this.groupByAccuracy(results)

    // Start with highest accuracy results
    let bestResult = this.selectBestResult(byAccuracy.coordinates || byAccuracy.postal || byAccuracy.city || byAccuracy.region || byAccuracy.country)

    // Enhance with consensus data
    bestResult = this.enhanceWithConsensus(bestResult, results)

    // Calculate final confidence
    bestResult.confidence = this.calculateConfidence(bestResult, results)

    // Determine final accuracy level
    bestResult.accuracy = this.determineAccuracyLevel(bestResult, results)

    return bestResult
  }

  private groupByAccuracy(results: GeolocationResult[]): Record<string, GeolocationResult[]> {
    return results.reduce((groups, result) => {
      const accuracy = result.accuracy
      if (!groups[accuracy]) groups[accuracy] = []
      groups[accuracy].push(result)
      return groups
    }, {} as Record<string, GeolocationResult[]>)
  }

  private selectBestResult(results: GeolocationResult[]): GeolocationResult {
    if (results.length === 0) throw new Error('No results available')

    // Sort by provider priority and performance
    return results.sort((a, b) => {
      const providerA = this.providers.get(a.provider)
      const providerB = this.providers.get(b.provider)
      const perfA = this.performance.get(a.provider)?.accuracyScore || 0
      const perfB = this.performance.get(b.provider)?.accuracyScore || 0

      const scoreA = (providerA?.priority || 0) + perfA
      const scoreB = (providerB?.priority || 0) + perfB

      return scoreB - scoreA
    })[0]
  }

  private enhanceWithConsensus(bestResult: GeolocationResult, allResults: GeolocationResult[]): GeolocationResult {
    const enhanced = { ...bestResult }

    // Country consensus (highest agreement)
    const countryVotes = this.getConsensus(allResults, 'country')
    if (countryVotes.length > 0) {
      enhanced.country = countryVotes[0].value
      enhanced.countryCode = countryVotes[0].code
    }

    // City consensus (if available)
    const cityVotes = this.getConsensus(allResults, 'city')
    if (cityVotes.length > 0) {
      enhanced.city = cityVotes[0].value
    }

    // ISP consensus
    const ispVotes = this.getConsensus(allResults, 'isp')
    if (ispVotes.length > 0) {
      enhanced.isp = ispVotes[0].value
    }

    return enhanced
  }

  private getConsensus(results: GeolocationResult[], field: keyof GeolocationResult): Array<{ value: string; count: number; code?: string }> {
    const votes = new Map<string, { count: number; code?: string }>()

    results.forEach(result => {
      const value = result[field] as string
      if (value) {
        const existing = votes.get(value) || { count: 0 }
        existing.count++
        if (field === 'country' && result.countryCode) {
          existing.code = result.countryCode
        }
        votes.set(value, existing)
      }
    })

    return Array.from(votes.entries())
      .map(([value, data]) => ({ value, count: data.count, code: data.code }))
      .sort((a, b) => b.count - a.count)
      .filter(item => item.count > 1) // Only include if multiple providers agree
  }

  private calculateConfidence(bestResult: GeolocationResult, allResults: GeolocationResult[]): number {
    let confidence = 50 // Base confidence

    // Provider agreement boosts confidence
    const countryConsensus = this.getConsensus(allResults, 'country')
    const cityConsensus = this.getConsensus(allResults, 'city')

    if (countryConsensus.length > 0) {
      confidence += Math.min(30, countryConsensus[0].count * 10)
    }

    if (cityConsensus.length > 0) {
      confidence += Math.min(20, cityConsensus[0].count * 5)
    }

    // Provider performance affects confidence
    const providerPerf = this.performance.get(bestResult.provider)
    if (providerPerf) {
      confidence += Math.min(20, providerPerf.accuracyScore * 20)
    }

    // Coordinate accuracy provides highest confidence
    if (bestResult.latitude && bestResult.longitude) {
      confidence += 15
    }

    return Math.min(100, Math.max(0, confidence))
  }

  private determineAccuracyLevel(bestResult: GeolocationResult, allResults: GeolocationResult[]): GeolocationResult['accuracy'] {
    if (bestResult.latitude && bestResult.longitude) {
      return 'coordinates'
    }

    if (bestResult.postalCode) {
      return 'postal'
    }

    if (bestResult.city) {
      return 'city'
    }

    if (bestResult.region) {
      return 'region'
    }

    return 'country'
  }

  private getCachedResult(ip: string): GeolocationResult | null {
    const cached = this.cache.get(ip)
    if (cached && cached.expires > Date.now()) {
      return cached.result
    }

    if (cached) {
      this.cache.delete(ip) // Expired
    }

    return null
  }

  private cacheResult(ip: string, result: GeolocationResult): void {
    if (this.cache.size >= this.config.cache.maxSize) {
      // Remove oldest entries (simple LRU)
      const keysToDelete = Array.from(this.cache.keys()).slice(0, Math.floor(this.config.cache.maxSize * 0.1))
      keysToDelete.forEach(key => this.cache.delete(key))
    }

    const ttl = this.getTTLForAccuracy(result.accuracy)
    const expires = Date.now() + (ttl * 1000)

    this.cache.set(ip, { result, expires })
  }

  private getTTLForAccuracy(accuracy: GeolocationResult['accuracy']): number {
    switch (accuracy) {
      case 'coordinates': return this.config.cache.ttl.coordinates
      case 'postal': return this.config.cache.ttl.city
      case 'city': return this.config.cache.ttl.city
      case 'region': return this.config.cache.ttl.country
      case 'country': return this.config.cache.ttl.country
      default: return 3600 // 1 hour default
    }
  }

  private getFallbackResult(ip: string): GeolocationResult {
    return {
      ip,
      country: this.config.fallback.defaultCountry || 'Unknown',
      countryCode: this.config.fallback.defaultCountry ? 'XX' : undefined,
      region: 'Unknown',
      city: 'Unknown',
      accuracy: 'country',
      confidence: 10,
      provider: 'fallback',
      cached: false,
      timestamp: Date.now(),
      metadata: {
        isMobile: false,
        isVpn: false,
        isDatacenter: false,
        isCorporate: false
      }
    }
  }

  private updateProviderPerformance(providerName: string, success: boolean, responseTime: number): void {
    const existing = this.performance.get(providerName) || {
      provider: providerName,
      totalQueries: 0,
      successRate: 0,
      averageResponseTime: 0,
      accuracyScore: 0.5,
      lastUpdated: Date.now()
    }

    existing.totalQueries++
    existing.lastUpdated = Date.now()

    if (success) {
      // Update success rate with exponential moving average
      existing.successRate = existing.successRate * 0.9 + 0.1

      // Update average response time
      existing.averageResponseTime =
        (existing.averageResponseTime * (existing.totalQueries - 1) + responseTime) / existing.totalQueries
    } else {
      existing.successRate = existing.successRate * 0.9 // Decay on failure
    }

    this.performance.set(providerName, existing)
  }

  private initializeProviders(): void {
    // Example providers - in production, these would be real services
    const providers: GeolocationProvider[] = [
      {
        name: 'premium_provider',
        priority: 10,
        cost: 0.001,
        rateLimit: 1000,
        regions: ['US', 'EU', 'APAC'],
        getLocation: async (ip: string) => {
          // Simulate premium provider
          return {
            ip,
            country: 'United States',
            countryCode: 'US',
            region: 'California',
            city: 'San Francisco',
            latitude: 37.7749,
            longitude: -122.4194,
            timezone: 'America/Los_Angeles',
            isp: 'Example ISP',
            accuracy: 'coordinates',
            confidence: 95,
            provider: 'premium_provider',
            cached: false,
            timestamp: Date.now()
          }
        }
      },
      {
        name: 'budget_provider',
        priority: 5,
        cost: 0.0001,
        rateLimit: 5000,
        regions: ['global'],
        getLocation: async (ip: string) => {
          // Simulate budget provider with lower accuracy
          return {
            ip,
            country: 'United States',
            countryCode: 'US',
            region: 'California',
            city: 'Los Angeles', // Less accurate city
            accuracy: 'city',
            confidence: 75,
            provider: 'budget_provider',
            cached: false,
            timestamp: Date.now()
          }
        }
      }
    ]

    providers.forEach(provider => {
      this.providers.set(provider.name, provider)
    })
  }

  private startPerformanceMonitoring(): void {
    // Update performance metrics every 5 minutes
    setInterval(() => {
      this.updateAccuracyScores()
    }, 5 * 60 * 1000)
  }

  private async updateAccuracyScores(): Promise<void> {
    // In production, this would use ground truth data to validate accuracy
    // For now, we'll simulate based on provider characteristics
    for (const [providerName, provider] of this.providers) {
      const perf = this.performance.get(providerName)
      if (perf && perf.totalQueries > 100) {
        // Simulate accuracy improvement with more data
        perf.accuracyScore = Math.min(1.0, 0.5 + (perf.successRate * 0.4) + (provider.priority * 0.1))
        this.performance.set(providerName, perf)
      }
    }
  }

  getPerformanceStats(): Record<string, ProviderPerformance> {
    return Object.fromEntries(this.performance.entries())
  }

  getCacheStats(): { size: number; hitRate?: number } {
    return { size: this.cache.size }
  }

  clearCache(): void {
    this.cache.clear()
  }
}

// Usage example
const geolocationConfig: GeolocationConfig = {
  providers: [], // Would be populated with real providers
  cache: {
    ttl: {
      country: 7 * 24 * 3600,     // 7 days
      city: 24 * 3600,           // 1 day
      coordinates: 6 * 3600      // 6 hours
    },
    maxSize: 100000
  },
  fallback: {
    defaultCountry: 'US',
    defaultLanguage: 'en'
  },
  accuracy: {
    minConfidence: 50,
    maxProviders: 3,
    timeout: 3000
  }
}

const geolocationService = new MultiSourceGeolocationService(geolocationConfig)

// Express.js middleware for geolocation
const geolocationMiddleware = async (req: any, res: any, next: any) => {
  try {
    const clientIP = req.ip || req.connection.remoteAddress || req.socket.remoteAddress

    if (clientIP && !clientIP.includes('127.0.0.1') && !clientIP.includes('::1')) {
      const location = await geolocationService.getLocation(clientIP)

      // Add location data to request object
      req.geolocation = location

      // Set response headers for client-side use
      res.set({
        'X-Geo-Country': location.countryCode,
        'X-Geo-City': location.city,
        'X-Geo-Region': location.region,
        'X-Geo-Confidence': location.confidence.toString()
      })
    }
  } catch (error) {
    console.error('Geolocation middleware error:', error)
    req.geolocation = null
  }

  next()
}

// Usage in Express app
app.use('/api', geolocationMiddleware)

// API endpoint with geolocation data
app.get('/api/user-location', (req, res) => {
  if (req.geolocation) {
    res.json({
      location: req.geolocation,
      message: 'Location detected successfully'
    })
  } else {
    res.status(404).json({
      error: 'Location not available',
      message: 'Unable to determine your location'
    })
  }
})

// Health check with performance stats
app.get('/health/geolocation', (req, res) => {
  res.json({
    status: 'healthy',
    providers: geolocationService.getPerformanceStats(),
    cache: geolocationService.getCacheStats(),
    timestamp: new Date().toISOString()
  })
})

console.log('Multi-source geolocation service initialized')

// Machine learning-powered anomaly detection for geolocation accuracy
interface GeolocationAnomaly {
  ip: string
  anomalyType: 'impossible_travel' | 'suspicious_location' | 'provider_disagreement' | 'unusual_behavior'
  severity: 'low' | 'medium' | 'high' | 'critical'
  confidence: number
  description: string
  expectedLocation?: GeolocationResult
  actualLocation?: GeolocationResult
  riskScore: number
  recommendations: string[]
}

interface LocationHistory {
  ip: string
  locations: Array<{
    result: GeolocationResult
    timestamp: number
    userAgent?: string
    sessionId?: string
  }>
  firstSeen: number
  lastSeen: number
  travelSpeed?: number // km/h between locations
}

class GeolocationAnomalyDetector {
  private locationHistory: Map<string, LocationHistory> = new Map()
  private anomalyThresholds = {
    impossibleTravel: 1000, // km/h
    locationChange: 500,    // km from expected
    confidenceDrop: 30,     // points
    providerDisagreement: 2  // number of providers disagreeing
  }

  async analyzeLocation(ip: string, newLocation: GeolocationResult): Promise<GeolocationAnomaly[]> {
    const anomalies: GeolocationAnomaly[] = []

    // Get location history
    const history = this.locationHistory.get(ip) || {
      ip,
      locations: [],
      firstSeen: Date.now(),
      lastSeen: Date.now()
    }

    // Check for impossible travel
    const impossibleTravelAnomaly = this.detectImpossibleTravel(history, newLocation)
    if (impossibleTravelAnomaly) {
      anomalies.push(impossibleTravelAnomaly)
    }

    // Check for suspicious location changes
    const suspiciousLocationAnomaly = this.detectSuspiciousLocation(history, newLocation)
    if (suspiciousLocationAnomaly) {
      anomalies.push(suspiciousLocationAnomaly)
    }

    // Check for provider disagreements
    const providerDisagreementAnomaly = await this.detectProviderDisagreement(ip, newLocation)
    if (providerDisagreementAnomaly) {
      anomalies.push(providerDisagreementAnomaly)
    }

    // Update history
    history.locations.push({
      result: newLocation,
      timestamp: Date.now()
    })
    history.lastSeen = Date.now()

    // Keep only last 100 locations per IP
    if (history.locations.length > 100) {
      history.locations = history.locations.slice(-100)
    }

    this.locationHistory.set(ip, history)

    return anomalies
  }

  private detectImpossibleTravel(history: LocationHistory, newLocation: GeolocationResult): GeolocationAnomaly | null {
    if (history.locations.length < 2) return null

    const lastLocation = history.locations[history.locations.length - 1]
    const timeDiff = (Date.now() - lastLocation.timestamp) / (1000 * 3600) // hours

    if (timeDiff < 0.1) return null // Too recent, skip calculation

    const distance = this.calculateDistance(
      lastLocation.result.latitude || 0,
      lastLocation.result.longitude || 0,
      newLocation.latitude || 0,
      newLocation.longitude || 0
    )

    const travelSpeed = distance / timeDiff // km/h

    if (travelSpeed > this.anomalyThresholds.impossibleTravel) {
      return {
        ip: history.ip,
        anomalyType: 'impossible_travel',
        severity: travelSpeed > 2000 ? 'critical' : 'high',
        confidence: Math.min(100, (travelSpeed / 1000) * 100),
        description: `Impossible travel detected: ${Math.round(travelSpeed)} km/h between locations`,
        expectedLocation: lastLocation.result,
        actualLocation: newLocation,
        riskScore: Math.min(100, travelSpeed / 10),
        recommendations: [
          'Flag as potential VPN or proxy usage',
          'Require additional authentication',
          'Monitor for suspicious activity'
        ]
      }
    }

    return null
  }

  private detectSuspiciousLocation(history: LocationHistory, newLocation: GeolocationResult): GeolocationAnomaly | null {
    if (history.locations.length < 3) return null

    // Calculate expected location based on pattern
    const recentLocations = history.locations.slice(-3)
    const avgLat = recentLocations.reduce((sum, loc) => sum + (loc.result.latitude || 0), 0) / recentLocations.length
    const avgLng = recentLocations.reduce((sum, loc) => sum + (loc.result.longitude || 0), 0) / recentLocations.length

    const distanceFromExpected = this.calculateDistance(
      avgLat,
      avgLng,
      newLocation.latitude || 0,
      newLocation.longitude || 0
    )

    if (distanceFromExpected > this.anomalyThresholds.locationChange) {
      return {
        ip: history.ip,
        anomalyType: 'suspicious_location',
        severity: distanceFromExpected > 1000 ? 'high' : 'medium',
        confidence: Math.min(100, (distanceFromExpected / 500) * 100),
        description: `Location ${Math.round(distanceFromExpected)}km from expected pattern`,
        expectedLocation: {
          ...newLocation,
          latitude: avgLat,
          longitude: avgLng,
          city: 'Expected area'
        },
        actualLocation: newLocation,
        riskScore: Math.min(100, distanceFromExpected / 10),
        recommendations: [
          'Verify user identity',
          'Check for account takeover',
          'Monitor transaction patterns'
        ]
      }
    }

    return null
  }

  private async detectProviderDisagreement(ip: string, location: GeolocationResult): Promise<GeolocationAnomaly | null> {
    // In production, this would query multiple providers
    // For demo, we'll simulate disagreement

    const simulatedDisagreements = Math.random()
    if (simulatedDisagreements < 0.1) { // 10% chance of disagreement
      return {
        ip,
        anomalyType: 'provider_disagreement',
        severity: 'medium',
        confidence: 70,
        description: 'Multiple geolocation providers disagree on location',
        actualLocation: location,
        riskScore: 60,
        recommendations: [
          'Use consensus location',
          'Lower confidence score',
          'Consider manual review for high-value transactions'
        ]
      }
    }

    return null
  }

  private calculateDistance(lat1: number, lng1: number, lat2: number, lng2: number): number {
    const R = 6371 // Earth's radius in km
    const dLat = this.toRadians(lat2 - lat1)
    const dLng = this.toRadians(lng2 - lng1)

    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
              Math.cos(this.toRadians(lat1)) * Math.cos(this.toRadians(lat2)) *
              Math.sin(dLng / 2) * Math.sin(dLng / 2)

    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
    return R * c
  }

  private toRadians(degrees: number): number {
    return degrees * (Math.PI / 180)
  }

  getAnomaliesForIP(ip: string): GeolocationAnomaly[] {
    // Return recent anomalies for this IP
    // In production, this would query a database
    return []
  }

  getLocationHistory(ip: string): LocationHistory | null {
    return this.locationHistory.get(ip) || null
  }

  // Clean up old history data
  cleanupOldData(maxAge: number = 24 * 60 * 60 * 1000): void {
    const cutoff = Date.now() - maxAge

    for (const [ip, history] of this.locationHistory.entries()) {
      // Remove old locations
      history.locations = history.locations.filter(loc => loc.timestamp > cutoff)

      // Remove IP if no recent locations
      if (history.locations.length === 0) {
        this.locationHistory.delete(ip)
      }
    }
  }
}

// Integration with geolocation service
class EnhancedGeolocationService extends MultiSourceGeolocationService {
  private anomalyDetector: GeolocationAnomalyDetector

  constructor(config: GeolocationConfig) {
    super(config)
    this.anomalyDetector = new GeolocationAnomalyDetector()
  }

  async getLocationWithAnalysis(ip: string): Promise<{
    location: GeolocationResult
    anomalies: GeolocationAnomaly[]
    riskAssessment: 'low' | 'medium' | 'high' | 'critical'
  }> {
    const location = await super.getLocation(ip)
    const anomalies = await this.anomalyDetector.analyzeLocation(ip, location)

    // Calculate overall risk
    const maxRiskScore = Math.max(...anomalies.map(a => a.riskScore), 0)
    let riskAssessment: 'low' | 'medium' | 'high' | 'critical'

    if (maxRiskScore >= 80) riskAssessment = 'critical'
    else if (maxRiskScore >= 60) riskAssessment = 'high'
    else if (maxRiskScore >= 40) riskAssessment = 'medium'
    else riskAssessment = 'low'

    // Adjust location confidence based on anomalies
    if (anomalies.length > 0) {
      location.confidence = Math.max(0, location.confidence - (anomalies.length * 10))
    }

    return {
      location,
      anomalies,
      riskAssessment
    }
  }
}

// Usage in fraud detection system
app.post('/api/analyze-location', async (req, res) => {
  try {
    const { ip, userId } = req.body

    if (!ip) {
      return res.status(400).json({ error: 'IP address required' })
    }

    const analysis = await geolocationService.getLocationWithAnalysis(ip)

    // Log high-risk anomalies
    const criticalAnomalies = analysis.anomalies.filter(a => a.severity === 'critical')
    if (criticalAnomalies.length > 0) {
      console.warn(`🚨 Critical geolocation anomalies for IP ${ip}:`, criticalAnomalies)
    }

    res.json({
      location: analysis.location,
      riskAssessment: analysis.riskAssessment,
      anomalies: analysis.anomalies,
      recommendations: analysis.anomalies.flatMap(a => a.recommendations)
    })

  } catch (error) {
    console.error('Location analysis error:', error)
    res.status(500).json({ error: 'Analysis failed' })
  }
})

// Periodic cleanup of old location data
setInterval(() => {
  geolocationService.clearCache()
  // Note: cleanupOldData would need to be exposed or handled differently
}, 60 * 60 * 1000) // Every hour

console.log('Enhanced geolocation service with anomaly detection initialized')

// Comprehensive system for handling mobile networks, VPNs, and corporate infrastructure
interface NetworkClassification {
  type: 'residential' | 'mobile' | 'corporate' | 'hosting' | 'vpn' | 'proxy' | 'unknown'
  confidence: number
  provider?: string
  carrier?: string
  country?: string
  riskLevel: 'low' | 'medium' | 'high'
}

interface LocationContext {
  ip: string
  networkType: NetworkClassification
  behavioralProfile: {
    sessionDuration: number
    pageViews: number
    timeOfDay: string
    dayOfWeek: string
    deviceType: string
  }
  historicalPatterns: {
    locations: GeolocationResult[]
    travelHistory: Array<{ from: string; to: string; timestamp: number }>
    loginPattern: string[]
  }
}

class AdvancedSpecialCasesHandler {
  private networkDatabase: Map<string, NetworkClassification> = new Map()
  private behavioralProfiles: Map<string, any> = new Map()

  constructor() {
    this.initializeNetworkDatabase()
    this.startBehavioralAnalysis()
  }

  async classifyNetwork(ip: string): Promise<NetworkClassification> {
    // Check cache first
    const cached = this.networkDatabase.get(ip)
    if (cached) return cached

    // Perform comprehensive network analysis
    const classification = await this.performNetworkClassification(ip)

    // Cache result for 24 hours
    this.networkDatabase.set(ip, classification)

    return classification
  }

  async enhanceLocationWithContext(
    location: GeolocationResult,
    context: LocationContext
  ): Promise<{
    enhancedLocation: GeolocationResult
    accuracyBoost: number
    specialHandling: string[]
    recommendations: string[]
  }> {
    const result = {
      enhancedLocation: { ...location },
      accuracyBoost: 0,
      specialHandling: [] as string[],
      recommendations: [] as string[]
    }

    // Apply network-specific enhancements
    const networkEnhancement = await this.applyNetworkEnhancement(location, context.networkType)
    result.enhancedLocation = { ...result.enhancedLocation, ...networkEnhancement.location }
    result.accuracyBoost += networkEnhancement.accuracyBoost
    result.specialHandling.push(...networkEnhancement.specialHandling)

    // Apply behavioral enhancements
    const behavioralEnhancement = await this.applyBehavioralEnhancement(location, context.behavioralProfile)
    result.enhancedLocation = { ...result.enhancedLocation, ...behavioralEnhancement.location }
    result.accuracyBoost += behavioralEnhancement.accuracyBoost
    result.specialHandling.push(...behavioralEnhancement.specialHandling)

    // Apply historical pattern enhancements
    const historicalEnhancement = await this.applyHistoricalEnhancement(location, context.historicalPatterns)
    result.enhancedLocation = { ...result.enhancedLocation, ...historicalEnhancement.location }
    result.accuracyBoost += historicalEnhancement.accuracyBoost
    result.specialHandling.push(...historicalEnhancement.specialHandling)

    // Generate recommendations
    result.recommendations = this.generateContextualRecommendations(result.enhancedLocation, context)

    return result
  }

  private async performNetworkClassification(ip: string): Promise<NetworkClassification> {
    const classification: NetworkClassification = {
      type: 'unknown',
      confidence: 50,
      riskLevel: 'medium'
    }

    // Check against known IP ranges
    const rangeClassification = await this.checkIPRanges(ip)
    if (rangeClassification) {
      classification.type = rangeClassification.type
      classification.confidence = rangeClassification.confidence
      classification.provider = rangeClassification.provider
      classification.country = rangeClassification.country
    }

    // Perform autonomous system analysis
    const asAnalysis = await this.analyzeAutonomousSystem(ip)
    if (asAnalysis.confidence > classification.confidence) {
      classification.type = asAnalysis.type
      classification.confidence = asAnalysis.confidence
      classification.provider = asAnalysis.provider
    }

    // Analyze connection patterns
    const connectionAnalysis = await this.analyzeConnectionPatterns(ip)
    if (connectionAnalysis.confidence > classification.confidence) {
      classification.type = connectionAnalysis.type
      classification.confidence = connectionAnalysis.confidence
    }

    // Determine risk level
    classification.riskLevel = this.calculateRiskLevel(classification)

    return classification
  }

  private async checkIPRanges(ip: string): Promise<NetworkClassification | null> {
    // In production, this would query IP range databases
    // For demo, simulate based on IP patterns

    if (ip.startsWith('10.') || ip.startsWith('192.168.') || ip.startsWith('172.')) {
      return {
        type: 'corporate',
        confidence: 90,
        provider: 'Internal Network',
        riskLevel: 'low'
      }
    }

    if (ip.includes('mobile') || ip.includes('cell')) {
      return {
        type: 'mobile',
        confidence: 85,
        carrier: 'Mobile Carrier',
        riskLevel: 'medium'
      }
    }

    if (ip.includes('vpn') || ip.includes('proxy')) {
      return {
        type: 'vpn',
        confidence: 80,
        provider: 'VPN Provider',
        riskLevel: 'high'
      }
    }

    return null
  }

  private async analyzeAutonomousSystem(ip: string): Promise<NetworkClassification> {
    // In production, query WHOIS or BGP data
    // For demo, simulate AS analysis

    const mockASData: Record<string, any> = {
      '8.8.8.8': { type: 'hosting', provider: 'Google', confidence: 95 },
      '1.1.1.1': { type: 'hosting', provider: 'Cloudflare', confidence: 95 },
      '208.67.222.222': { type: 'hosting', provider: 'OpenDNS', confidence: 90 }
    }

    return mockASData[ip] || {
      type: 'residential',
      provider: 'ISP',
      confidence: 70,
      riskLevel: 'low'
    }
  }

  private async analyzeConnectionPatterns(ip: string): Promise<NetworkClassification> {
    // Analyze HTTP headers, TLS fingerprinting, etc.
    // For demo, simulate connection pattern analysis

    if (ip.includes('datacenter') || ip.includes('aws') || ip.includes('azure')) {
      return {
        type: 'hosting',
        confidence: 85,
        provider: 'Cloud Provider',
        riskLevel: 'medium'
      }
    }

    return {
      type: 'residential',
      confidence: 75,
      provider: 'ISP',
      riskLevel: 'low'
    }
  }

  private calculateRiskLevel(classification: NetworkClassification): 'low' | 'medium' | 'high' {
    const riskScores: Record<string, number> = {
      'residential': 1,
      'mobile': 2,
      'corporate': 1,
      'hosting': 3,
      'vpn': 3,
      'proxy': 3,
      'unknown': 2
    }

    const score = riskScores[classification.type] || 2

    if (score <= 1) return 'low'
    if (score <= 2) return 'medium'
    return 'high'
  }

  private async applyNetworkEnhancement(
    location: GeolocationResult,
    networkType: NetworkClassification
  ): Promise<{
    location: Partial<GeolocationResult>
    accuracyBoost: number
    specialHandling: string[]
  }> {
    const enhancement = {
      location: {} as Partial<GeolocationResult>,
      accuracyBoost: 0,
      specialHandling: [] as string[]
    }

    switch (networkType.type) {
      case 'mobile':
        // Mobile networks may show carrier infrastructure location
        enhancement.specialHandling.push('Mobile network detected - location may represent carrier infrastructure')
        enhancement.accuracyBoost = -10
        enhancement.location.metadata = {
          ...location.metadata,
          isMobile: true,
          carrier: networkType.carrier
        }
        break

      case 'corporate':
        // Corporate networks often show headquarters location
        enhancement.specialHandling.push('Corporate network detected - location may represent company headquarters')
        enhancement.accuracyBoost = -15
        enhancement.location.metadata = {
          ...location.metadata,
          isCorporate: true
        }
        break

      case 'vpn':
        // VPNs intentionally obscure location
        enhancement.specialHandling.push('VPN detected - location may be intentionally obscured')
        enhancement.accuracyBoost = -30
        enhancement.location.metadata = {
          ...location.metadata,
          isVpn: true
        }
        break

      case 'hosting':
        // Hosting providers may show datacenter location
        enhancement.specialHandling.push('Hosting provider detected - location represents datacenter')
        enhancement.accuracyBoost = -25
        enhancement.location.metadata = {
          ...location.metadata,
          isDatacenter: true
        }
        break

      case 'residential':
        // Residential connections are generally most accurate
        enhancement.accuracyBoost = 5
        enhancement.specialHandling.push('Residential connection - high confidence location')
        break
    }

    return enhancement
  }

  private async applyBehavioralEnhancement(
    location: GeolocationResult,
    behavioralProfile: any
  ): Promise<{
    location: Partial<GeolocationResult>
    accuracyBoost: number
    specialHandling: string[]
  }> {
    const enhancement = {
      location: {} as Partial<GeolocationResult>,
      accuracyBoost: 0,
      specialHandling: [] as string[]
    }

    // Time-based analysis
    if (behavioralProfile.timeOfDay === 'business_hours' && behavioralProfile.dayOfWeek !== 'weekend') {
      if (location.city?.includes('Business District')) {
        enhancement.accuracyBoost = 5
        enhancement.specialHandling.push('Business hours behavior correlates with business location')
      }
    }

    // Device type analysis
    if (behavioralProfile.deviceType === 'mobile' && location.accuracy === 'coordinates') {
      enhancement.accuracyBoost = 10
      enhancement.specialHandling.push('Mobile device with coordinate accuracy suggests GPS usage')
    }

    // Session pattern analysis
    if (behavioralProfile.sessionDuration > 3600 && behavioralProfile.pageViews > 10) {
      enhancement.accuracyBoost = 5
      enhancement.specialHandling.push('Extended session suggests legitimate user behavior')
    }

    return enhancement
  }

  private async applyHistoricalEnhancement(
    location: GeolocationResult,
    historicalPatterns: any
  ): Promise<{
    location: Partial<GeolocationResult>
    accuracyBoost: number
    specialHandling: string[]
  }> {
    const enhancement = {
      location: {} as Partial<GeolocationResult>,
      accuracyBoost: 0,
      specialHandling: [] as string[]
    }

    if (historicalPatterns.locations.length > 5) {
      // Check location consistency
      const recentLocations = historicalPatterns.locations.slice(-5)
      const consistentLocations = recentLocations.filter(loc =>
        loc.country === location.country && loc.city === location.city
      )

      if (consistentLocations.length >= 3) {
        enhancement.accuracyBoost = 10
        enhancement.specialHandling.push('Consistent location history increases confidence')
      }

      // Check for travel patterns
      if (historicalPatterns.travelHistory.length > 0) {
        const recentTravel = historicalPatterns.travelHistory[historicalPatterns.travelHistory.length - 1]
        const timeSinceTravel = Date.now() - recentTravel.timestamp

        if (timeSinceTravel < 24 * 60 * 60 * 1000) { // Within 24 hours
          enhancement.specialHandling.push('Recent travel detected - location may be transitional')
          enhancement.accuracyBoost = -5
        }
      }
    }

    return enhancement
  }

  private generateContextualRecommendations(
    location: GeolocationResult,
    context: LocationContext
  ): string[] {
    const recommendations: string[] = []

    // Network-specific recommendations
    switch (context.networkType.type) {
      case 'mobile':
        recommendations.push('Consider mobile-specific content optimization')
        recommendations.push('Enable location services for better mobile accuracy')
        break

      case 'vpn':
        recommendations.push('VPN usage detected - consider security implications')
        recommendations.push('Offer VPN-friendly content or require verification')
        break

      case 'corporate':
        recommendations.push('Corporate network - may represent business location')
        recommendations.push('Consider B2B content and enterprise features')
        break
    }

    // Accuracy-based recommendations
    if (location.confidence < 50) {
      recommendations.push('Low confidence location - consider user verification')
      recommendations.push('Provide location override option for users')
    }

    if (location.accuracy === 'country') {
      recommendations.push('Country-level accuracy - avoid city-specific content')
      recommendations.push('Use regional fallbacks for content delivery')
    }

    return recommendations
  }

  private initializeNetworkDatabase(): void {
    // Load known IP ranges and network classifications
    // In production, this would load from comprehensive databases

    const knownRanges = [
      { range: '10.0.0.0/8', type: 'corporate' },
      { range: '192.168.0.0/16', type: 'corporate' },
      { range: '172.16.0.0/12', type: 'corporate' },
      { range: '8.8.0.0/16', type: 'hosting', provider: 'Google' }
    ]

    // For demo, just log initialization
    console.log(`Initialized network database with ${knownRanges.length} known ranges`)
  }

  private startBehavioralAnalysis(): void {
    // Start collecting and analyzing user behavioral patterns
    console.log('Started behavioral analysis for location context')
  }
}

// Integration with geolocation service
const specialCasesHandler = new AdvancedSpecialCasesHandler()

// Enhanced location analysis endpoint
app.post('/api/analyze-location-context', async (req, res) => {
  try {
    const { ip, userAgent, sessionId, userId } = req.body

    if (!ip) {
      return res.status(400).json({ error: 'IP address required' })
    }

    // Get basic location
    const basicLocation = await geolocationService.getLocation(ip)

    // Classify network type
    const networkType = await specialCasesHandler.classifyNetwork(ip)

    // Build context
    const context: LocationContext = {
      ip,
      networkType,
      behavioralProfile: {
        sessionDuration: 0, // Would be calculated from session data
        pageViews: 1,
        timeOfDay: new Date().getHours() < 18 ? 'business_hours' : 'evening',
        dayOfWeek: new Date().getDay() < 6 ? 'weekday' : 'weekend',
        deviceType: userAgent?.includes('Mobile') ? 'mobile' : 'desktop'
      },
      historicalPatterns: {
        locations: [basicLocation],
        travelHistory: [],
        loginPattern: []
      }
    }

    // Enhance location with context
    const enhancedAnalysis = await specialCasesHandler.enhanceLocationWithContext(basicLocation, context)

    res.json({
      originalLocation: basicLocation,
      enhancedLocation: enhancedAnalysis.enhancedLocation,
      networkClassification: networkType,
      accuracyBoost: enhancedAnalysis.accuracyBoost,
      specialHandling: enhancedAnalysis.specialHandling,
      recommendations: enhancedAnalysis.recommendations,
      context,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Location context analysis error:', error)
    res.status(500).json({ error: 'Context analysis failed' })
  }
})

// Network classification endpoint
app.get('/api/network-classification/:ip', async (req, res) => {
  try {
    const { ip } = req.params

    if (!ip) {
      return res.status(400).json({ error: 'IP address required' })
    }

    const classification = await specialCasesHandler.classifyNetwork(ip)

    res.json({
      ip,
      classification,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Network classification error:', error)
    res.status(500).json({ error: 'Classification failed' })
  }
})

console.log('Advanced special cases handler initialized')

// Production-ready intelligent caching system for geolocation data
interface CacheEntry {
  location: GeolocationResult
  metadata: {
    sourceProvider: string[]
    queryCount: number
    lastAccessed: number
    accessPattern: 'sequential' | 'random' | 'bursty'
    accuracy: GeolocationResult['accuracy']
  }
  expires: number
}

interface CacheAnalytics {
  totalRequests: number
  cacheHits: number
  cacheMisses: number
  hitRate: number
  averageResponseTime: number
  mostPopularIPs: Array<{ ip: string; requests: number }>
  accuracyDistribution: Record<string, number>
}

class IntelligentGeolocationCache {
  private cache: Map<string, CacheEntry> = new Map()
  private analytics: CacheAnalytics = {
    totalRequests: 0,
    cacheHits: 0,
    cacheMisses: 0,
    hitRate: 0,
    averageResponseTime: 0,
    mostPopularIPs: [],
    accuracyDistribution: {}
  }
  private maxSize: number
  private accessLog: Array<{ ip: string; timestamp: number; hit: boolean }> = []

  constructor(maxSize: number = 100000) {
    this.maxSize = maxSize
    this.startAnalyticsReporting()
  }

  async get(ip: string): Promise<GeolocationResult | null> {
    const startTime = Date.now()
    this.analytics.totalRequests++

    const entry = this.cache.get(ip)
    if (entry && entry.expires > Date.now()) {
      // Cache hit
      this.analytics.cacheHits++
      entry.metadata.lastAccessed = Date.now()
      entry.metadata.queryCount++

      this.logAccess(ip, true)
      this.updateAnalytics(Date.now() - startTime)

      return { ...entry.location, cached: true }
    }

    // Cache miss or expired
    if (entry) {
      this.cache.delete(ip) // Remove expired entry
    }

    this.analytics.cacheMisses++
    this.logAccess(ip, false)
    this.updateAnalytics(Date.now() - startTime)

    return null
  }

  async set(ip: string, location: GeolocationResult, sourceProviders: string[]): Promise<void> {
    // Implement intelligent cache sizing
    if (this.cache.size >= this.maxSize) {
      await this.evictLeastValuableEntries()
    }

    // Calculate TTL based on accuracy and usage patterns
    const ttl = this.calculateOptimalTTL(location, sourceProviders)

    const entry: CacheEntry = {
      location: { ...location, cached: true },
      metadata: {
        sourceProvider: sourceProviders,
        queryCount: 1,
        lastAccessed: Date.now(),
        accessPattern: 'random',
        accuracy: location.accuracy
      },
      expires: Date.now() + ttl
    }

    this.cache.set(ip, entry)

    // Update accuracy distribution
    this.analytics.accuracyDistribution[location.accuracy] =
      (this.analytics.accuracyDistribution[location.accuracy] || 0) + 1
  }

  private calculateOptimalTTL(location: GeolocationResult, providers: string[]): number {
    // Base TTL by accuracy level
    const baseTTL: Record<GeolocationResult['accuracy'], number> = {
      'country': 7 * 24 * 60 * 60 * 1000,      // 7 days
      'region': 3 * 24 * 60 * 60 * 1000,       // 3 days
      'city': 24 * 60 * 60 * 1000,             // 1 day
      'postal': 12 * 60 * 60 * 1000,           // 12 hours
      'coordinates': 6 * 60 * 60 * 1000        // 6 hours
    }

    let ttl = baseTTL[location.accuracy] || 24 * 60 * 60 * 1000

    // Adjust based on provider reliability
    const reliableProviders = ['premium_provider', 'enterprise_provider']
    if (providers.some(p => reliableProviders.includes(p))) {
      ttl *= 1.2 // 20% longer for reliable providers
    }

    // Adjust based on confidence
    if (location.confidence > 90) {
      ttl *= 1.1 // 10% longer for high confidence
    } else if (location.confidence < 60) {
      ttl *= 0.8 // 20% shorter for low confidence
    }

    // Network-specific adjustments
    if (location.metadata?.isMobile) {
      ttl *= 0.7 // 30% shorter for mobile (more dynamic)
    }

    if (location.metadata?.isVpn) {
      ttl *= 0.5 // 50% shorter for VPN (less predictable)
    }

    return Math.max(60 * 60 * 1000, ttl) // Minimum 1 hour
  }

  private async evictLeastValuableEntries(): Promise<void> {
    const entries = Array.from(this.cache.entries())

    // Sort by value score (combines recency, frequency, and accuracy)
    const sortedEntries = entries.sort(([, a], [, b]) => {
      const scoreA = this.calculateEntryValue(a)
      const scoreB = this.calculateEntryValue(b)
      return scoreA - scoreB
    })

    // Remove lowest 10% of entries
    const toRemove = Math.floor(entries.length * 0.1)
    for (let i = 0; i < toRemove; i++) {
      this.cache.delete(sortedEntries[i][0])
    }
  }

  private calculateEntryValue(entry: CacheEntry): number {
    const now = Date.now()
    const hoursSinceAccess = (now - entry.metadata.lastAccessed) / (1000 * 60 * 60)

    // Recency score (newer = higher value)
    const recencyScore = Math.max(0, 100 - (hoursSinceAccess * 10))

    // Frequency score (more queries = higher value)
    const frequencyScore = Math.min(100, entry.metadata.queryCount * 5)

    // Accuracy score (higher accuracy = higher value)
    const accuracyScores: Record<GeolocationResult['accuracy'], number> = {
      'coordinates': 100,
      'postal': 80,
      'city': 60,
      'region': 40,
      'country': 20
    }
    const accuracyScore = accuracyScores[entry.metadata.accuracy] || 10

    // Provider reliability bonus
    const providerBonus = entry.metadata.sourceProvider.includes('premium_provider') ? 20 : 0

    return recencyScore + frequencyScore + accuracyScore + providerBonus
  }

  private logAccess(ip: string, hit: boolean): void {
    this.accessLog.push({ ip, timestamp: Date.now(), hit })

    // Keep only last 10000 entries
    if (this.accessLog.length > 10000) {
      this.accessLog = this.accessLog.slice(-10000)
    }
  }

  private updateAnalytics(responseTime: number): void {
    // Update average response time with exponential moving average
    const alpha = 0.1 // Learning rate
    this.analytics.averageResponseTime =
      this.analytics.averageResponseTime * (1 - alpha) + responseTime * alpha

    // Update hit rate
    this.analytics.hitRate =
      this.analytics.cacheHits / (this.analytics.cacheHits + this.analytics.cacheMisses) * 100
  }

  private startAnalyticsReporting(): void {
    // Report analytics every 5 minutes
    setInterval(() => {
      this.generateAnalyticsReport()
    }, 5 * 60 * 1000)
  }

  private generateAnalyticsReport(): void {
    // Calculate most popular IPs
    const ipCounts = new Map<string, number>()
    this.accessLog.slice(-1000).forEach(log => {
      ipCounts.set(log.ip, (ipCounts.get(log.ip) || 0) + 1)
    })

    this.analytics.mostPopularIPs = Array.from(ipCounts.entries())
      .sort(([, a], [, b]) => b - a)
      .slice(0, 10)
      .map(([ip, requests]) => ({ ip, requests }))

    console.log('Cache Analytics:', {
      hitRate: `${this.analytics.hitRate.toFixed(2)}%`,
      avgResponseTime: `${this.analytics.averageResponseTime.toFixed(2)}ms`,
      cacheSize: this.cache.size,
      mostPopularIPs: this.analytics.mostPopularIPs.slice(0, 3)
    })
  }

  // Batch operations for high-throughput scenarios
  async getBatch(ips: string[]): Promise<Map<string, GeolocationResult | null>> {
    const results = new Map<string, GeolocationResult | null>()

    // Process in parallel with rate limiting
    const batchSize = 100
    for (let i = 0; i < ips.length; i += batchSize) {
      const batch = ips.slice(i, i + batchSize)

      const batchPromises = batch.map(async (ip) => {
        const result = await this.get(ip)
        return { ip, result }
      })

      const batchResults = await Promise.all(batchPromises)

      batchResults.forEach(({ ip, result }) => {
        results.set(ip, result)
      })

      // Small delay between batches to avoid overwhelming
      if (i + batchSize < ips.length) {
        await new Promise(resolve => setTimeout(resolve, 10))
      }
    }

    return results
  }

  // Cache warming for predicted popular IPs
  async warmCache(popularIPs: string[]): Promise<void> {
    const warmingPromises = popularIPs.map(async (ip) => {
      try {
        const location = await geolocationService.getLocation(ip)
        await this.set(ip, location, ['cache_warming'])
      } catch (error) {
        console.error(`Failed to warm cache for IP ${ip}:`, error)
      }
    })

    await Promise.allSettled(warmingPromises)
    console.log(`Warmed cache for ${popularIPs.length} popular IPs`)
  }

  getAnalytics(): CacheAnalytics {
    return { ...this.analytics }
  }

  clear(): void {
    this.cache.clear()
    this.accessLog = []
    this.analytics = {
      totalRequests: 0,
      cacheHits: 0,
      cacheMisses: 0,
      hitRate: 0,
      averageResponseTime: 0,
      mostPopularIPs: [],
      accuracyDistribution: {}
    }
  }

  // Export cache data for analysis
  exportCacheData(): { entries: any[], analytics: CacheAnalytics } {
    return {
      entries: Array.from(this.cache.entries()).map(([ip, entry]) => ({
        ip,
        location: entry.location,
        metadata: entry.metadata,
        expires: new Date(entry.expires).toISOString()
      })),
      analytics: this.analytics
    }
  }
}

// Integration with geolocation service
class OptimizedGeolocationService extends MultiSourceGeolocationService {
  private intelligentCache: IntelligentGeolocationCache

  constructor(config: GeolocationConfig) {
    super(config)
    this.intelligentCache = new IntelligentGeolocationCache(config.cache.maxSize)
  }

  async getLocation(ip: string): Promise<GeolocationResult> {
    // Check intelligent cache first
    const cachedResult = await this.intelligentCache.get(ip)
    if (cachedResult) {
      return cachedResult
    }

    // Get fresh location data
    const freshResult = await super.getLocation(ip)

    // Cache the result
    await this.intelligentCache.set(ip, freshResult, [freshResult.provider])

    return freshResult
  }

  // Get cache analytics
  getCacheAnalytics(): CacheAnalytics {
    return this.intelligentCache.getAnalytics()
  }

  // Warm cache with popular IPs
  async warmPopularCache(): Promise<void> {
    // In production, this would analyze access logs to identify popular IPs
    const popularIPs = [
      '8.8.8.8', '8.8.4.4', '1.1.1.1', '208.67.222.222'
    ]

    await this.intelligentCache.warmCache(popularIPs)
  }

  // Batch location lookup
  async getLocationsBatch(ips: string[]): Promise<Map<string, GeolocationResult>> {
    const results = await this.intelligentCache.getBatch(ips)

    // Get fresh data for cache misses
    const freshIPs = Array.from(results.entries())
      .filter(([, result]) => result === null)
      .map(([ip]) => ip)

    if (freshIPs.length > 0) {
      const freshPromises = freshIPs.map(async (ip) => {
        try {
          const location = await super.getLocation(ip)
          await this.intelligentCache.set(ip, location, [location.provider])
          return { ip, location }
        } catch (error) {
          console.error(`Batch lookup failed for IP ${ip}:`, error)
          return { ip, location: null }
        }
      })

      const freshResults = await Promise.all(freshPromises)

      freshResults.forEach(({ ip, location }) => {
        if (location) {
          results.set(ip, location)
        }
      })
    }

    // Filter out null results
    const validResults = new Map<string, GeolocationResult>()
    for (const [ip, result] of results.entries()) {
      if (result) {
        validResults.set(ip, result)
      }
    }

    return validResults
  }
}

// Initialize optimized service
const optimizedGeolocationService = new OptimizedGeolocationService(geolocationConfig)

// Enhanced API endpoints with caching analytics
app.get('/api/geolocation/:ip', async (req, res) => {
  try {
    const { ip } = req.params

    if (!ip) {
      return res.status(400).json({ error: 'IP address required' })
    }

    const location = await optimizedGeolocationService.getLocation(ip)

    res.json({
      location,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Geolocation lookup error:', error)
    res.status(500).json({ error: 'Geolocation lookup failed' })
  }
})

// Batch geolocation endpoint
app.post('/api/geolocation/batch', async (req, res) => {
  try {
    const { ips } = req.body

    if (!Array.isArray(ips)) {
      return res.status(400).json({ error: 'IPs array required' })
    }

    const results = await optimizedGeolocationService.getLocationsBatch(ips)

    res.json({
      results: Object.fromEntries(results.entries()),
      count: results.size,
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Batch geolocation error:', error)
    res.status(500).json({ error: 'Batch geolocation failed' })
  }
})

// Cache analytics endpoint
app.get('/api/geolocation/cache-analytics', (req, res) => {
  const analytics = optimizedGeolocationService.getCacheAnalytics()

  res.json({
    analytics,
    timestamp: new Date().toISOString()
  })
})

// Cache warming endpoint
app.post('/api/geolocation/warm-cache', async (req, res) => {
  try {
    await optimizedGeolocationService.warmPopularCache()

    res.json({
      message: 'Cache warming completed',
      timestamp: new Date().toISOString()
    })

  } catch (error) {
    console.error('Cache warming error:', error)
    res.status(500).json({ error: 'Cache warming failed' })
  }
})

// Periodic cache optimization
setInterval(() => {
  // Export cache data for analysis
  const cacheData = optimizedGeolocationService.getCacheAnalytics()

  // In production, this could trigger cache optimization algorithms
  if (cacheData.hitRate < 70) {
    console.log('Low cache hit rate detected - consider cache optimization')
  }

}, 60 * 60 * 1000) // Every hour

console.log('Intelligent caching system initialized')

Geolocation Accuracy Techniques

Special Network Cases

Geolocation Performance Dashboard