MongoDB Geospatial Queries and Location Data Management: Advanced Geographic Indexing and Spatial Analysis for Modern Applications

-- Traditional PostgreSQL geographic data handling - complex and limited functionality

-- Basic location storage with separate latitude/longitude columns
CREATE TABLE locations (
    location_id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    address TEXT,
    latitude DECIMAL(10, 8) NOT NULL,
    longitude DECIMAL(11, 8) NOT NULL,
    category VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

    -- Basic constraints for valid coordinates
    CONSTRAINT valid_latitude CHECK (latitude >= -90 AND latitude <= 90),
    CONSTRAINT valid_longitude CHECK (longitude >= -180 AND longitude <= 180)
);

-- Create basic index for coordinate lookups (limited efficiency)
CREATE INDEX idx_locations_lat_lng ON locations(latitude, longitude);

-- Simple proximity query using Haversine formula (inefficient for large datasets)
CREATE OR REPLACE FUNCTION calculate_distance(
    lat1 DECIMAL, lng1 DECIMAL,
    lat2 DECIMAL, lng2 DECIMAL
) RETURNS DECIMAL AS $$
DECLARE
    earth_radius DECIMAL := 6371; -- Earth radius in kilometers
    lat1_rad DECIMAL;
    lng1_rad DECIMAL;
    lat2_rad DECIMAL;
    lng2_rad DECIMAL;
    dlat DECIMAL;
    dlng DECIMAL;
    a DECIMAL;
    c DECIMAL;
BEGIN
    -- Convert degrees to radians
    lat1_rad := radians(lat1);
    lng1_rad := radians(lng1);
    lat2_rad := radians(lat2);
    lng2_rad := radians(lng2);

    -- Haversine formula
    dlat := lat2_rad - lat1_rad;
    dlng := lng2_rad - lng1_rad;

    a := sin(dlat/2) * sin(dlat/2) + 
         cos(lat1_rad) * cos(lat2_rad) * 
         sin(dlng/2) * sin(dlng/2);
    c := 2 * atan2(sqrt(a), sqrt(1-a));

    RETURN earth_radius * c;
END;
$$ LANGUAGE plpgsql;

-- Find nearby locations (slow for large datasets)
WITH nearby_locations AS (
    SELECT 
        l.*,
        calculate_distance(
            40.7128, -74.0060,  -- New York City coordinates
            l.latitude, l.longitude
        ) as distance_km
    FROM locations l
    WHERE 
        -- Basic bounding box filter (rectangular approximation)
        latitude BETWEEN 40.7128 - 0.1 AND 40.7128 + 0.1
        AND longitude BETWEEN -74.0060 - 0.1 AND -74.0060 + 0.1
)
SELECT 
    location_id,
    name,
    address,
    latitude,
    longitude,
    distance_km,

    -- Categories for results
    CASE 
        WHEN distance_km <= 1 THEN 'very_close'
        WHEN distance_km <= 5 THEN 'nearby'
        WHEN distance_km <= 10 THEN 'moderate_distance'
        ELSE 'far'
    END as proximity_category

FROM nearby_locations
WHERE distance_km <= 10  -- Within 10km
ORDER BY distance_km
LIMIT 50;

-- Geofencing implementation (complex and inefficient)
CREATE TABLE geofences (
    geofence_id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    center_latitude DECIMAL(10, 8) NOT NULL,
    center_longitude DECIMAL(11, 8) NOT NULL,
    radius_meters INTEGER NOT NULL,
    fence_type VARCHAR(50) DEFAULT 'circular',
    active BOOLEAN DEFAULT true,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Check if location is within geofence (expensive operation)
CREATE OR REPLACE FUNCTION point_in_geofence(
    point_lat DECIMAL, point_lng DECIMAL,
    fence_id INTEGER
) RETURNS BOOLEAN AS $$
DECLARE
    fence_record geofences%ROWTYPE;
    distance_m DECIMAL;
BEGIN
    SELECT * INTO fence_record 
    FROM geofences 
    WHERE geofence_id = fence_id AND active = true;

    IF NOT FOUND THEN
        RETURN false;
    END IF;

    -- Calculate distance in meters
    distance_m := calculate_distance(
        point_lat, point_lng,
        fence_record.center_latitude, fence_record.center_longitude
    ) * 1000;

    RETURN distance_m <= fence_record.radius_meters;
END;
$$ LANGUAGE plpgsql;

-- Area-based queries (extremely limited without proper GIS support)
WITH service_areas AS (
    SELECT 
        sa.area_id,
        sa.area_name,
        -- Simple rectangular area definition (very limited)
        sa.min_latitude,
        sa.max_latitude,
        sa.min_longitude,
        sa.max_longitude,
        sa.service_type
    FROM service_areas sa
    WHERE sa.active = true
),
area_coverage AS (
    SELECT 
        sa.*,
        COUNT(l.location_id) as locations_in_area,
        AVG(l.latitude) as avg_latitude,
        AVG(l.longitude) as avg_longitude
    FROM service_areas sa
    LEFT JOIN locations l ON (
        l.latitude BETWEEN sa.min_latitude AND sa.max_latitude
        AND l.longitude BETWEEN sa.min_longitude AND sa.max_longitude
    )
    GROUP BY sa.area_id, sa.area_name, sa.min_latitude, sa.max_latitude, 
             sa.min_longitude, sa.max_longitude, sa.service_type
)
SELECT 
    area_id,
    area_name,
    service_type,
    locations_in_area,

    -- Calculate approximate area (very rough rectangle calculation)
    (max_latitude - min_latitude) * (max_longitude - min_longitude) * 111000 as approx_area_sqm,

    -- Service density calculation
    CASE 
        WHEN locations_in_area > 0 THEN 
            locations_in_area::DECIMAL / 
            ((max_latitude - min_latitude) * (max_longitude - min_longitude) * 111000)
        ELSE 0
    END as service_density_per_sqkm

FROM area_coverage
ORDER BY locations_in_area DESC;

-- Route planning (extremely basic and inefficient)
WITH route_waypoints AS (
    SELECT 
        ROW_NUMBER() OVER (ORDER BY waypoint_order) as sequence,
        latitude,
        longitude,
        location_name
    FROM route_points
    WHERE route_id = :route_id
    ORDER BY waypoint_order
),
route_segments AS (
    SELECT 
        rw1.sequence as from_seq,
        rw1.location_name as from_location,
        rw1.latitude as from_lat,
        rw1.longitude as from_lng,
        rw2.sequence as to_seq,
        rw2.location_name as to_location,
        rw2.latitude as to_lat,
        rw2.longitude as to_lng,

        -- Calculate segment distance
        calculate_distance(
            rw1.latitude, rw1.longitude,
            rw2.latitude, rw2.longitude
        ) as segment_distance_km

    FROM route_waypoints rw1
    JOIN route_waypoints rw2 ON rw2.sequence = rw1.sequence + 1
)
SELECT 
    from_location,
    to_location,
    segment_distance_km,

    -- Running total distance
    SUM(segment_distance_km) OVER (
        ORDER BY from_seq 
        ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    ) as cumulative_distance_km,

    -- Estimated time (very basic calculation)
    segment_distance_km * 60 / 50 as estimated_minutes  -- Assume 50 km/h average

FROM route_segments
ORDER BY from_seq;

-- Problems with traditional geographic approaches:
-- 1. No native spatial indexing - queries are slow on large datasets
-- 2. Limited geometric operations - only basic distance calculations
-- 3. No support for complex shapes or polygons
-- 4. Inefficient bounding box calculations
-- 5. No proper coordinate system support
-- 6. Manual implementation of spatial algorithms
-- 7. Limited geospatial query operators
-- 8. Poor performance for proximity searches
-- 9. No native support for geographic data types
-- 10. Complex implementation for basic geospatial functionality

// MongoDB Advanced Geospatial Data Management
const { MongoClient } = require('mongodb');

const client = new MongoClient('mongodb://localhost:27017');
const db = client.db('geospatial_applications');

// Comprehensive MongoDB Geospatial Manager
class AdvancedGeospatialManager {
  constructor(db, config = {}) {
    this.db = db;
    this.collections = {
      locations: db.collection('locations'),
      geofences: db.collection('geofences'),
      routes: db.collection('routes'),
      serviceAreas: db.collection('service_areas'),
      trackingData: db.collection('tracking_data'),
      spatialAnalytics: db.collection('spatial_analytics')
    };

    // Advanced geospatial configuration
    this.config = {
      // Coordinate system settings
      coordinateSystem: config.coordinateSystem || 'WGS84',
      defaultSRID: config.defaultSRID || 4326,

      // Index optimization settings
      enable2dSphereIndexes: config.enable2dSphereIndexes !== false,
      enableGeoHashIndexes: config.enableGeoHashIndexes || false,
      indexPrecision: config.indexPrecision || 26,

      // Query optimization settings
      defaultDistanceUnit: config.defaultDistanceUnit || 'meters',
      maxProximityDistance: config.maxProximityDistance || 50000, // 50km
      defaultResultLimit: config.defaultResultLimit || 100,

      // Performance settings
      enableSpatialCaching: config.enableSpatialCaching || false,
      cacheExpirySeconds: config.cacheExpirySeconds || 300,
      enableParallelQueries: config.enableParallelQueries || false
    };

    this.initializeGeospatialSystem();
  }

  async initializeGeospatialSystem() {
    console.log('Initializing advanced geospatial system...');

    try {
      // Create optimized geospatial indexes
      await this.setupGeospatialIndexes();

      // Initialize spatial analysis capabilities
      await this.setupSpatialAnalytics();

      // Setup geospatial data validation
      await this.setupGeospatialValidation();

      console.log('Advanced geospatial system initialized successfully');

    } catch (error) {
      console.error('Error initializing geospatial system:', error);
      throw error;
    }
  }

  async setupGeospatialIndexes() {
    console.log('Setting up optimized geospatial indexes...');

    try {
      // Locations collection - 2dsphere index for spherical geometry
      await this.collections.locations.createIndex(
        { location: '2dsphere' },
        { 
          name: 'location_2dsphere_idx',
          background: true,
          '2dsphereIndexVersion': 3
        }
      );

      // Compound index for location + category queries
      await this.collections.locations.createIndex(
        { location: '2dsphere', category: 1, active: 1 },
        { 
          name: 'location_category_active_idx',
          background: true 
        }
      );

      // Geofences collection - optimized for area queries
      await this.collections.geofences.createIndex(
        { geometry: '2dsphere' },
        { 
          name: 'geofence_geometry_idx',
          background: true 
        }
      );

      // Tracking data - time-series with geospatial
      await this.collections.trackingData.createIndex(
        { location: '2dsphere', timestamp: -1, user_id: 1 },
        { 
          name: 'tracking_location_time_user_idx',
          background: true 
        }
      );

      // Service areas - polygon-based spatial index
      await this.collections.serviceAreas.createIndex(
        { coverage_area: '2dsphere', service_type: 1, active: 1 },
        { 
          name: 'service_area_coverage_idx',
          background: true 
        }
      );

      console.log('Geospatial indexes created successfully');

    } catch (error) {
      console.error('Error creating geospatial indexes:', error);
      throw error;
    }
  }

  async findNearbyLocations(centerPoint, radiusMeters, options = {}) {
    console.log(`Finding locations within ${radiusMeters}m of point [${centerPoint.coordinates}]...`);

    try {
      const query = {
        location: {
          $near: {
            $geometry: centerPoint,
            $maxDistance: radiusMeters
          }
        }
      };

      // Add additional filters
      if (options.category) {
        query.category = options.category;
      }

      if (options.active !== undefined) {
        query.active = options.active;
      }

      if (options.excludeIds) {
        query._id = { $nin: options.excludeIds };
      }

      // Execute proximity query with optimization
      const nearbyLocations = await this.collections.locations
        .find(query)
        .limit(options.limit || this.config.defaultResultLimit)
        .toArray();

      // Calculate precise distances and additional metadata
      const enrichedResults = nearbyLocations.map(location => {
        const distance = this.calculateDistance(centerPoint, location.location);

        return {
          ...location,
          distance: {
            meters: Math.round(distance),
            kilometers: Math.round(distance / 1000 * 100) / 100,
            miles: Math.round(distance * 0.000621371 * 100) / 100
          },
          proximityCategory: this.categorizeDistance(distance),
          bearing: this.calculateBearing(centerPoint, location.location)
        };
      });

      // Sort by distance (MongoDB $near already does this, but ensure precision)
      enrichedResults.sort((a, b) => a.distance.meters - b.distance.meters);

      return {
        success: true,
        centerPoint: centerPoint,
        searchRadius: radiusMeters,
        totalResults: enrichedResults.length,
        locations: enrichedResults,
        searchMetadata: {
          queryOptions: options,
          executionTime: Date.now(),
          coordinateSystem: this.config.coordinateSystem
        }
      };

    } catch (error) {
      console.error('Error finding nearby locations:', error);
      return {
        success: false,
        error: error.message,
        centerPoint: centerPoint,
        searchRadius: radiusMeters
      };
    }
  }

  async implementAdvancedGeofencing(geofenceData, monitoringOptions = {}) {
    console.log('Implementing advanced geofencing system...');

    try {
      // Create comprehensive geofence document
      const geofenceDocument = {
        _id: this.generateGeofenceId(),
        name: geofenceData.name,
        description: geofenceData.description,

        // Geofence geometry (supports various shapes)
        geometry: this.normalizeGeometry(geofenceData.geometry),

        // Geofence properties
        properties: {
          type: geofenceData.type || 'monitoring',
          priority: geofenceData.priority || 'normal',
          active: geofenceData.active !== false,

          // Trigger conditions
          triggerEvents: geofenceData.triggerEvents || ['enter', 'exit'],
          dwellTime: geofenceData.dwellTime || 0, // Minimum time in seconds

          // Notification settings
          notifications: {
            enabled: monitoringOptions.enableNotifications || false,
            webhookUrl: monitoringOptions.webhookUrl,
            emailRecipients: monitoringOptions.emailRecipients || []
          },

          // Analytics settings
          analytics: {
            trackDwellTime: monitoringOptions.trackDwellTime || false,
            trackEntryExitPatterns: monitoringOptions.trackEntryExitPatterns || false,
            aggregateStatistics: monitoringOptions.aggregateStatistics || false
          }
        },

        // Metadata
        createdAt: new Date(),
        updatedAt: new Date(),
        createdBy: geofenceData.createdBy,

        // Performance optimization hints
        indexingHints: {
          expectedQueryVolume: monitoringOptions.expectedQueryVolume || 'medium',
          primaryUseCase: monitoringOptions.primaryUseCase || 'point_in_polygon'
        }
      };

      // Insert geofence with validation
      const insertResult = await this.collections.geofences.insertOne(geofenceDocument);

      if (!insertResult.acknowledged) {
        throw new Error('Failed to create geofence');
      }

      console.log(`Geofence created successfully: ${geofenceDocument.name}`);

      return {
        success: true,
        geofenceId: geofenceDocument._id,
        geometry: geofenceDocument.geometry,
        properties: geofenceDocument.properties
      };

    } catch (error) {
      console.error('Error implementing geofencing:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  async checkGeofenceViolations(pointLocation, userContext = {}) {
    console.log('Checking geofence violations for location...');

    try {
      // Find all active geofences that contain the point
      const geofenceQuery = {
        'properties.active': true,
        geometry: {
          $geoIntersects: {
            $geometry: pointLocation
          }
        }
      };

      const violatedGeofences = await this.collections.geofences
        .find(geofenceQuery)
        .toArray();

      const violations = [];

      for (const geofence of violatedGeofences) {
        // Check if this is a new entry or continued presence
        const previousStatus = await this.getPreviousGeofenceStatus(
          userContext.userId, 
          geofence._id
        );

        const violationData = {
          geofenceId: geofence._id,
          geofenceName: geofence.name,
          violationType: this.determineViolationType(previousStatus, geofence),
          timestamp: new Date(),
          location: pointLocation,
          userContext: userContext,

          // Geofence-specific data
          geofenceType: geofence.properties.type,
          priority: geofence.properties.priority,
          triggerEvents: geofence.properties.triggerEvents,

          // Additional context
          dwellTimeRequired: geofence.properties.dwellTime,
          currentDwellTime: this.calculateCurrentDwellTime(userContext.userId, geofence._id)
        };

        violations.push(violationData);

        // Update geofence status tracking
        await this.updateGeofenceStatus(userContext.userId, geofence._id, violationData);

        // Trigger notifications if configured
        if (geofence.properties.notifications.enabled) {
          await this.triggerGeofenceNotification(geofence, violationData);
        }

        // Record analytics if enabled
        if (geofence.properties.analytics.trackEntryExitPatterns) {
          await this.recordGeofenceAnalytics(geofence, violationData);
        }
      }

      // Check for geofence exits (locations user was in but no longer in)
      const exitViolations = await this.checkGeofenceExits(
        userContext.userId, 
        violatedGeofences.map(g => g._id),
        pointLocation
      );

      violations.push(...exitViolations);

      return {
        success: true,
        location: pointLocation,
        totalViolations: violations.length,
        violations: violations,
        userContext: userContext
      };

    } catch (error) {
      console.error('Error checking geofence violations:', error);
      return {
        success: false,
        error: error.message,
        location: pointLocation
      };
    }
  }

  async performSpatialAnalysis(analysisType, parameters) {
    console.log(`Performing spatial analysis: ${analysisType}...`);

    try {
      let analysisResult = {};

      switch (analysisType) {
        case 'density_heatmap':
          analysisResult = await this.generateDensityHeatmap(parameters);
          break;

        case 'service_coverage':
          analysisResult = await this.analyzeServiceCoverage(parameters);
          break;

        case 'route_optimization':
          analysisResult = await this.optimizeRoutes(parameters);
          break;

        case 'clustering_analysis':
          analysisResult = await this.performClusteringAnalysis(parameters);
          break;

        case 'accessibility_analysis':
          analysisResult = await this.analyzeAccessibility(parameters);
          break;

        default:
          throw new Error(`Unsupported analysis type: ${analysisType}`);
      }

      // Store analysis results for future reference
      const analysisRecord = {
        analysisType: analysisType,
        parameters: parameters,
        results: analysisResult,
        executedAt: new Date(),
        executionTime: Date.now() - parameters.startTime
      };

      await this.collections.spatialAnalytics.insertOne(analysisRecord);

      return {
        success: true,
        analysisType: analysisType,
        ...analysisResult
      };

    } catch (error) {
      console.error(`Error performing spatial analysis (${analysisType}):`, error);
      return {
        success: false,
        analysisType: analysisType,
        error: error.message
      };
    }
  }

  async generateDensityHeatmap(parameters) {
    console.log('Generating location density heatmap...');

    const { bounds, gridSize, category } = parameters;

    // Create grid cells for heatmap
    const gridCells = this.createSpatialGrid(bounds, gridSize);
    const heatmapData = [];

    for (const cell of gridCells) {
      // Count locations in each grid cell
      const cellQuery = {
        location: {
          $geoWithin: {
            $geometry: cell.geometry
          }
        }
      };

      if (category) {
        cellQuery.category = category;
      }

      const locationCount = await this.collections.locations.countDocuments(cellQuery);

      if (locationCount > 0) {
        heatmapData.push({
          cellId: cell.id,
          geometry: cell.geometry,
          center: cell.center,
          locationCount: locationCount,
          density: locationCount / cell.area // locations per square meter
        });
      }
    }

    // Calculate density statistics
    const densities = heatmapData.map(cell => cell.density);
    const maxDensity = Math.max(...densities);
    const avgDensity = densities.reduce((sum, d) => sum + d, 0) / densities.length;

    // Normalize density values for heatmap visualization
    const normalizedHeatmap = heatmapData.map(cell => ({
      ...cell,
      normalizedDensity: cell.density / maxDensity,
      intensityLevel: this.categorizeDensity(cell.density, maxDensity, avgDensity)
    }));

    return {
      heatmapData: normalizedHeatmap,
      statistics: {
        totalCells: gridCells.length,
        activeCells: heatmapData.length,
        maxDensity: maxDensity,
        averageDensity: avgDensity,
        totalLocations: heatmapData.reduce((sum, cell) => sum + cell.locationCount, 0)
      },
      metadata: {
        bounds: bounds,
        gridSize: gridSize,
        category: category,
        generatedAt: new Date()
      }
    };
  }

  async analyzeServiceCoverage(parameters) {
    console.log('Analyzing service coverage areas...');

    const { serviceType, analysisArea, coverageRadius } = parameters;

    // Get all service locations of the specified type
    const serviceLocations = await this.collections.locations
      .find({
        category: serviceType,
        active: true,
        location: {
          $geoWithin: {
            $geometry: analysisArea
          }
        }
      })
      .toArray();

    // Create coverage areas around each service location
    const coverageAreas = serviceLocations.map(location => ({
      serviceLocation: location,
      coverageArea: {
        type: 'Polygon',
        coordinates: [this.createCircleCoordinates(location.location, coverageRadius)]
      },
      radius: coverageRadius
    }));

    // Calculate union of all coverage areas
    const totalCoverage = await this.calculateCoverageUnion(coverageAreas);

    // Calculate coverage metrics
    const analysisAreaSize = this.calculatePolygonArea(analysisArea);
    const coveredAreaSize = this.calculatePolygonArea(totalCoverage);
    const coveragePercentage = (coveredAreaSize / analysisAreaSize) * 100;

    // Find coverage gaps
    const coverageGaps = await this.findCoverageGaps(analysisArea, totalCoverage);

    // Identify optimal locations for new services
    const optimalNewLocations = await this.findOptimalServiceLocations(
      coverageGaps, 
      serviceLocations, 
      coverageRadius
    );

    return {
      serviceType: serviceType,
      analysisArea: analysisArea,
      serviceLocations: serviceLocations,
      coverageAreas: coverageAreas,
      totalCoverage: totalCoverage,

      // Coverage metrics
      metrics: {
        totalServiceLocations: serviceLocations.length,
        analysisAreaSqKm: Math.round(analysisAreaSize / 1000000 * 100) / 100,
        coveredAreaSqKm: Math.round(coveredAreaSize / 1000000 * 100) / 100,
        coveragePercentage: Math.round(coveragePercentage * 100) / 100,
        gapCount: coverageGaps.length
      },

      // Recommendations
      recommendations: {
        coverageGaps: coverageGaps,
        optimalNewLocations: optimalNewLocations,
        serviceEfficiency: this.calculateServiceEfficiency(serviceLocations, totalCoverage)
      }
    };
  }

  async optimizeRoutes(parameters) {
    console.log('Optimizing routes for multiple stops...');

    const { startPoint, waypoints, endPoint, optimizationCriteria } = parameters;

    // Prepare all points for route optimization
    const allPoints = [startPoint, ...waypoints];
    if (endPoint && !this.pointsEqual(startPoint, endPoint)) {
      allPoints.push(endPoint);
    }

    // Calculate distance matrix between all points
    const distanceMatrix = await this.calculateDistanceMatrix(allPoints);

    // Apply route optimization algorithm based on criteria
    let optimizedRoute = {};

    switch (optimizationCriteria) {
      case 'shortest_distance':
        optimizedRoute = await this.optimizeForShortestDistance(allPoints, distanceMatrix);
        break;

      case 'fastest_time':
        optimizedRoute = await this.optimizeForFastestTime(allPoints, distanceMatrix);
        break;

      case 'balanced':
        optimizedRoute = await this.optimizeBalanced(allPoints, distanceMatrix);
        break;

      default:
        optimizedRoute = await this.optimizeForShortestDistance(allPoints, distanceMatrix);
    }

    // Calculate route statistics
    const routeStatistics = this.calculateRouteStatistics(optimizedRoute, distanceMatrix);

    // Generate turn-by-turn directions
    const directions = await this.generateRouteDirections(optimizedRoute.orderedPoints);

    return {
      originalPoints: {
        start: startPoint,
        waypoints: waypoints,
        end: endPoint
      },
      optimizedRoute: optimizedRoute,
      routeStatistics: routeStatistics,
      directions: directions,
      optimizationCriteria: optimizationCriteria,

      // Performance comparison
      improvement: {
        distanceReduction: routeStatistics.totalDistance < parameters.originalDistance 
          ? parameters.originalDistance - routeStatistics.totalDistance 
          : 0,
        timeReduction: routeStatistics.estimatedTime < parameters.originalTime 
          ? parameters.originalTime - routeStatistics.estimatedTime 
          : 0
      }
    };
  }

  // Utility methods for geospatial calculations

  calculateDistance(point1, point2) {
    // Use MongoDB's geospatial calculation or implement Haversine formula
    const R = 6371000; // Earth's radius in meters
    const lat1Rad = this.toRadians(point1.coordinates[1]);
    const lat2Rad = this.toRadians(point2.coordinates[1]);
    const deltaLatRad = this.toRadians(point2.coordinates[1] - point1.coordinates[1]);
    const deltaLngRad = this.toRadians(point2.coordinates[0] - point1.coordinates[0]);

    const a = Math.sin(deltaLatRad/2) * Math.sin(deltaLatRad/2) +
              Math.cos(lat1Rad) * Math.cos(lat2Rad) *
              Math.sin(deltaLngRad/2) * Math.sin(deltaLngRad/2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));

    return R * c;
  }

  calculateBearing(point1, point2) {
    const lat1Rad = this.toRadians(point1.coordinates[1]);
    const lat2Rad = this.toRadians(point2.coordinates[1]);
    const deltaLngRad = this.toRadians(point2.coordinates[0] - point1.coordinates[0]);

    const y = Math.sin(deltaLngRad) * Math.cos(lat2Rad);
    const x = Math.cos(lat1Rad) * Math.sin(lat2Rad) - 
              Math.sin(lat1Rad) * Math.cos(lat2Rad) * Math.cos(deltaLngRad);

    const bearingRad = Math.atan2(y, x);
    return (this.toDegrees(bearingRad) + 360) % 360;
  }

  categorizeDistance(distanceMeters) {
    if (distanceMeters <= 100) return 'very_close';
    if (distanceMeters <= 500) return 'walking_distance';
    if (distanceMeters <= 2000) return 'nearby';
    if (distanceMeters <= 10000) return 'moderate_distance';
    return 'far';
  }

  normalizeGeometry(geometry) {
    // Ensure geometry follows GeoJSON specification
    if (!geometry || !geometry.type || !geometry.coordinates) {
      throw new Error('Invalid geometry format');
    }

    // Validate coordinate ranges
    this.validateCoordinates(geometry);

    return geometry;
  }

  validateCoordinates(geometry) {
    const validatePoint = (coords) => {
      if (!Array.isArray(coords) || coords.length < 2) {
        throw new Error('Invalid coordinate format');
      }

      const [lng, lat] = coords;
      if (lng < -180 || lng > 180 || lat < -90 || lat > 90) {
        throw new Error(`Invalid coordinates: [${lng}, ${lat}]`);
      }
    };

    switch (geometry.type) {
      case 'Point':
        validatePoint(geometry.coordinates);
        break;

      case 'LineString':
      case 'MultiPoint':
        geometry.coordinates.forEach(validatePoint);
        break;

      case 'Polygon':
      case 'MultiLineString':
        geometry.coordinates.forEach(ring => ring.forEach(validatePoint));
        break;

      case 'MultiPolygon':
        geometry.coordinates.forEach(polygon => 
          polygon.forEach(ring => ring.forEach(validatePoint))
        );
        break;
    }
  }

  createSpatialGrid(bounds, gridSize) {
    const grid = [];
    const { southwest, northeast } = bounds;

    const latStep = (northeast.coordinates[1] - southwest.coordinates[1]) / gridSize;
    const lngStep = (northeast.coordinates[0] - southwest.coordinates[0]) / gridSize;

    for (let i = 0; i < gridSize; i++) {
      for (let j = 0; j < gridSize; j++) {
        const sw = [
          southwest.coordinates[0] + (j * lngStep),
          southwest.coordinates[1] + (i * latStep)
        ];
        const ne = [
          southwest.coordinates[0] + ((j + 1) * lngStep),
          southwest.coordinates[1] + ((i + 1) * latStep)
        ];

        const cellGeometry = {
          type: 'Polygon',
          coordinates: [[
            sw,
            [ne[0], sw[1]],
            ne,
            [sw[0], ne[1]],
            sw
          ]]
        };

        grid.push({
          id: `cell_${i}_${j}`,
          geometry: cellGeometry,
          center: {
            type: 'Point',
            coordinates: [(sw[0] + ne[0]) / 2, (sw[1] + ne[1]) / 2]
          },
          area: this.calculatePolygonArea(cellGeometry)
        });
      }
    }

    return grid;
  }

  createCircleCoordinates(center, radiusMeters, points = 32) {
    const coords = [];
    const earthRadius = 6371000; // Earth radius in meters

    for (let i = 0; i < points; i++) {
      const angle = (i * 2 * Math.PI) / points;
      const lat = this.toRadians(center.coordinates[1]);
      const lng = this.toRadians(center.coordinates[0]);

      const newLat = Math.asin(
        Math.sin(lat) * Math.cos(radiusMeters / earthRadius) +
        Math.cos(lat) * Math.sin(radiusMeters / earthRadius) * Math.cos(angle)
      );

      const newLng = lng + Math.atan2(
        Math.sin(angle) * Math.sin(radiusMeters / earthRadius) * Math.cos(lat),
        Math.cos(radiusMeters / earthRadius) - Math.sin(lat) * Math.sin(newLat)
      );

      coords.push([this.toDegrees(newLng), this.toDegrees(newLat)]);
    }

    // Close the polygon
    coords.push(coords[0]);
    return coords;
  }

  calculatePolygonArea(polygon) {
    // Simplified area calculation for demonstration
    // In production, use proper spherical geometry calculations
    if (polygon.type !== 'Polygon') return 0;

    const coords = polygon.coordinates[0];
    let area = 0;

    for (let i = 0; i < coords.length - 1; i++) {
      area += coords[i][0] * coords[i + 1][1] - coords[i + 1][0] * coords[i][1];
    }

    return Math.abs(area / 2) * 111000 * 111000; // Rough conversion to square meters
  }

  toRadians(degrees) {
    return degrees * (Math.PI / 180);
  }

  toDegrees(radians) {
    return radians * (180 / Math.PI);
  }

  generateGeofenceId() {
    return `geofence_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  // Additional methods would include implementations for:
  // - setupSpatialAnalytics()
  // - setupGeospatialValidation()
  // - getPreviousGeofenceStatus()
  // - determineViolationType()
  // - updateGeofenceStatus()
  // - triggerGeofenceNotification()
  // - recordGeofenceAnalytics()
  // - checkGeofenceExits()
  // - calculateCoverageUnion()
  // - findCoverageGaps()
  // - findOptimalServiceLocations()
  // - calculateServiceEfficiency()
  // - calculateDistanceMatrix()
  // - optimizeForShortestDistance()
  // - optimizeForFastestTime()
  // - optimizeBalanced()
  // - calculateRouteStatistics()
  // - generateRouteDirections()
  // - performClusteringAnalysis()
  // - analyzeAccessibility()
  // - categorizeDensity()
  // - pointsEqual()
}

// Benefits of MongoDB Advanced Geospatial Operations:
// - Native 2dsphere indexing for efficient spherical geometry queries
// - Comprehensive geospatial operators for proximity, intersection, and containment
// - Support for complex geometric shapes and polygon operations
// - Optimized spatial indexing with configurable precision
// - Built-in coordinate system support and transformations
// - Advanced geofencing with real-time violation detection
// - Spatial aggregation and analytics capabilities
// - Route optimization and path planning functionality
// - High-performance location-based queries at scale
// - Integration with external mapping and routing services

module.exports = {
  AdvancedGeospatialManager
};

// Advanced location-based service discovery
class LocationBasedServiceDiscovery extends AdvancedGeospatialManager {
  constructor(db, serviceConfig) {
    super(db, serviceConfig);

    this.serviceConfig = {
      ...serviceConfig,
      enableServiceRanking: true,
      enableCapacityAwareness: true,
      enableRealTimeUpdates: true,
      enableServiceQuality: true
    };

    this.setupServiceDiscovery();
  }

  async findOptimalServices(userLocation, serviceRequest) {
    console.log('Finding optimal services based on location and requirements...');

    const { serviceType, maxDistance, requirements, preferences } = serviceRequest;

    try {
      // Multi-criteria service discovery
      const serviceDiscoveryPipeline = [
        // Geographic proximity filter
        {
          $geoNear: {
            near: userLocation,
            distanceField: 'distance',
            maxDistance: maxDistance,
            spherical: true,
            query: {
              serviceType: serviceType,
              active: true,

              // Service availability filter
              'availability.currentlyAvailable': true,
              'availability.capacity': { $gt: 0 }
            }
          }
        },

        // Requirements matching
        {
          $match: this.buildRequirementsFilter(requirements)
        },

        // Service quality and rating filtering
        {
          $addFields: {
            qualityScore: {
              $multiply: [
                '$ratings.averageRating',
                { $divide: ['$ratings.totalReviews', 100] }
              ]
            },

            // Proximity score (closer = higher score)
            proximityScore: {
              $subtract: [
                maxDistance,
                '$distance'
              ]
            },

            // Availability score
            availabilityScore: {
              $divide: [
                '$availability.capacity',
                '$availability.maxCapacity'
              ]
            }
          }
        },

        // Calculate composite service score
        {
          $addFields: {
            compositeScore: {
              $add: [
                { $multiply: ['$qualityScore', 0.3] },
                { $multiply: ['$proximityScore', 0.4] },
                { $multiply: ['$availabilityScore', 0.3] }
              ]
            }
          }
        },

        // Apply preference-based boosting
        {
          $addFields: {
            finalScore: this.applyPreferenceBoosts('$compositeScore', preferences)
          }
        },

        // Sort by final score and limit results
        { $sort: { finalScore: -1, distance: 1 } },
        { $limit: 20 }
      ];

      const optimalServices = await this.collections.locations
        .aggregate(serviceDiscoveryPipeline)
        .toArray();

      // Enrich results with additional context
      const enrichedServices = await Promise.all(
        optimalServices.map(async service => ({
          ...service,

          // Estimated arrival time
          estimatedArrivalTime: await this.calculateEstimatedArrival(
            userLocation, 
            service.location
          ),

          // Real-time availability
          realTimeAvailability: await this.getRealTimeAvailability(service._id),

          // Service-specific recommendations
          recommendations: await this.generateServiceRecommendations(
            service, 
            userLocation, 
            preferences
          ),

          // Booking options
          bookingOptions: await this.getBookingOptions(service._id)
        }))
      );

      return {
        success: true,
        userLocation: userLocation,
        serviceRequest: serviceRequest,
        totalResults: enrichedServices.length,
        services: enrichedServices,

        // Discovery metadata
        discoveryMetadata: {
          searchRadius: maxDistance,
          averageDistance: this.calculateAverageDistance(enrichedServices),
          qualityDistribution: this.analyzeQualityDistribution(enrichedServices),
          availabilityRate: this.calculateAvailabilityRate(enrichedServices)
        }
      };

    } catch (error) {
      console.error('Error in service discovery:', error);
      return {
        success: false,
        error: error.message,
        userLocation: userLocation,
        serviceRequest: serviceRequest
      };
    }
  }

  async implementDynamicServiceZones(serviceArea, demandData) {
    console.log('Implementing dynamic service zones based on demand patterns...');

    try {
      // Analyze demand patterns
      const demandAnalysis = await this.analyzeDemandPatterns(demandData);

      // Create dynamic zones based on demand density
      const dynamicZones = await this.createDemandBasedZones(
        serviceArea, 
        demandAnalysis
      );

      // Optimize service allocation across zones
      const serviceAllocation = await this.optimizeServiceAllocation(
        dynamicZones, 
        demandAnalysis
      );

      // Update service areas and routing
      const updateResults = await this.updateServiceAreas(serviceAllocation);

      return {
        success: true,
        serviceArea: serviceArea,
        dynamicZones: dynamicZones,
        serviceAllocation: serviceAllocation,
        updateResults: updateResults,

        // Performance metrics
        metrics: {
          totalZones: dynamicZones.length,
          averageResponseTime: serviceAllocation.averageResponseTime,
          coverageEfficiency: serviceAllocation.coverageEfficiency,
          demandSatisfaction: serviceAllocation.demandSatisfaction
        }
      };

    } catch (error) {
      console.error('Error implementing dynamic service zones:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }
}