MongoDB Geospatial Queries and Location-Based Services: SQL-Style Spatial Operations for Modern Applications

-- Traditional PostgreSQL/PostGIS approach - complex setup and limited performance
-- Location-based application with spatial data

CREATE EXTENSION IF NOT EXISTS postgis;

-- Store locations with geometry data
CREATE TABLE locations (
    location_id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    category VARCHAR(100),
    address TEXT,
    city VARCHAR(100),
    state VARCHAR(50),
    country VARCHAR(100),

    -- PostGIS geometry column (complex setup required)
    coordinates GEOMETRY(POINT, 4326), -- WGS84 coordinate system

    -- Additional spatial data
    service_area GEOMETRY(POLYGON, 4326), -- Service coverage area
    delivery_zones GEOMETRY(MULTIPOLYGON, 4326), -- Multiple delivery zones

    -- Business data
    rating DECIMAL(3,2),
    total_reviews INTEGER DEFAULT 0,
    is_active BOOLEAN DEFAULT true,
    hours_of_operation JSONB,

    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Create spatial indexes (requires PostGIS extension)
CREATE INDEX idx_locations_coordinates ON locations USING GIST (coordinates);
CREATE INDEX idx_locations_service_area ON locations USING GIST (service_area);

-- Store user locations and activities
CREATE TABLE user_locations (
    user_location_id SERIAL PRIMARY KEY,
    user_id INTEGER NOT NULL REFERENCES users(user_id),
    coordinates GEOMETRY(POINT, 4326),
    accuracy_meters DECIMAL(8,2),
    recorded_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    activity_type VARCHAR(50), -- 'check-in', 'delivery', 'movement'
    device_info JSONB
);

CREATE INDEX idx_user_locations_coordinates ON user_locations USING GIST (coordinates);
CREATE INDEX idx_user_locations_user_time ON user_locations (user_id, recorded_at);

-- Complex proximity search query
WITH nearby_locations AS (
    SELECT 
        l.location_id,
        l.name,
        l.category,
        l.rating,

        -- Distance calculation in meters
        ST_Distance(
            l.coordinates,
            ST_SetSRID(ST_MakePoint(-122.4194, 37.7749), 4326) -- San Francisco coordinates
        ) as distance_meters,

        -- Check if point is within service area
        ST_Contains(
            l.service_area,
            ST_SetSRID(ST_MakePoint(-122.4194, 37.7749), 4326)
        ) as is_in_service_area,

        -- Convert coordinates back to lat/lng for application
        ST_Y(l.coordinates) as latitude,
        ST_X(l.coordinates) as longitude

    FROM locations l
    WHERE 
        l.is_active = true
        AND ST_DWithin(
            l.coordinates,
            ST_SetSRID(ST_MakePoint(-122.4194, 37.7749), 4326),
            5000 -- 5km radius in meters
        )
),
location_analytics AS (
    -- Add user activity data for locations
    SELECT 
        nl.*,
        COUNT(DISTINCT ul.user_id) as unique_visitors_last_30_days,
        COUNT(ul.user_location_id) as total_activities_last_30_days,
        AVG(ul.accuracy_meters) as avg_location_accuracy
    FROM nearby_locations nl
    LEFT JOIN user_locations ul ON ST_DWithin(
        ST_SetSRID(ST_MakePoint(nl.longitude, nl.latitude), 4326),
        ul.coordinates,
        100 -- Within 100 meters of location
    )
    AND ul.recorded_at >= CURRENT_DATE - INTERVAL '30 days'
    GROUP BY nl.location_id, nl.name, nl.category, nl.rating, 
             nl.distance_meters, nl.is_in_service_area, 
             nl.latitude, nl.longitude
)
SELECT 
    location_id,
    name,
    category,
    rating,
    ROUND(distance_meters::numeric, 0) as distance_meters,
    is_in_service_area,
    latitude,
    longitude,
    unique_visitors_last_30_days,
    total_activities_last_30_days,
    ROUND(avg_location_accuracy::numeric, 1) as avg_accuracy_meters,

    -- Relevance scoring based on distance, rating, and activity
    (
        (1000 - LEAST(distance_meters, 1000)) / 1000 * 0.4 + -- Distance factor (40%)
        (rating / 5.0) * 0.3 + -- Rating factor (30%)
        (LEAST(unique_visitors_last_30_days, 50) / 50.0) * 0.3 -- Activity factor (30%)
    ) as relevance_score

FROM location_analytics
ORDER BY relevance_score DESC, distance_meters ASC
LIMIT 20;

-- Problems with traditional spatial approach:
-- 1. Complex PostGIS extension setup and maintenance
-- 2. Requires specialized spatial database knowledge
-- 3. Limited coordinate system support without additional configuration
-- 4. Performance degrades with large datasets and complex queries
-- 5. Difficult integration with application object models
-- 6. Complex geometry data types and manipulation functions
-- 7. Limited aggregation capabilities for spatial analytics
-- 8. Challenging horizontal scaling for global applications
-- 9. Memory-intensive spatial operations
-- 10. Complex backup and restore procedures for spatial data

-- MySQL spatial limitations (even more restrictive):
CREATE TABLE locations_mysql (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255),
    -- MySQL spatial support limited and less capable
    coordinates POINT NOT NULL,
    SPATIAL INDEX(coordinates)
);

-- Basic proximity query in MySQL (limited functionality)
SELECT 
    id, name,
    ST_Distance_Sphere(
        coordinates, 
        POINT(-122.4194, 37.7749)
    ) as distance_meters
FROM locations_mysql
WHERE ST_Distance_Sphere(
    coordinates, 
    POINT(-122.4194, 37.7749)
) < 5000
ORDER BY distance_meters
LIMIT 10;

-- MySQL limitations:
-- - Limited spatial functions compared to PostGIS
-- - Poor performance with large spatial datasets
-- - No advanced spatial analytics capabilities
-- - Limited coordinate system support
-- - Basic geometry types only
-- - No spatial aggregation functions
-- - Difficult to implement complex spatial business logic

// MongoDB native geospatial support - powerful and intuitive
const { MongoClient } = require('mongodb');

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

// MongoDB geospatial document structure - native and flexible
const createLocationServiceDataModel = async () => {
  // Create locations collection with rich geospatial data
  const locations = db.collection('locations');

  // Example location document with geospatial data
  const locationDocument = {
    _id: new ObjectId(),

    // Basic business information
    name: "Blue Bottle Coffee - Ferry Building",
    category: "cafe",
    subcategory: "specialty_coffee",
    chain: "Blue Bottle Coffee",

    // Address information
    address: {
      street: "1 Ferry Building",
      unit: "Shop 7",
      city: "San Francisco",
      state: "CA",
      country: "USA",
      postalCode: "94111",
      formattedAddress: "1 Ferry Building, Shop 7, San Francisco, CA 94111"
    },

    // Primary location - GeoJSON Point format
    location: {
      type: "Point",
      coordinates: [-122.3937, 37.7955] // [longitude, latitude] - NOTE: MongoDB uses [lng, lat]
    },

    // Service area - GeoJSON Polygon format
    serviceArea: {
      type: "Polygon",
      coordinates: [[
        [-122.4050, 37.7850], // Southwest corner
        [-122.3850, 37.7850], // Southeast corner  
        [-122.3850, 37.8050], // Northeast corner
        [-122.4050, 37.8050], // Northwest corner
        [-122.4050, 37.7850]  // Close polygon
      ]]
    },

    // Multiple delivery zones - GeoJSON MultiPolygon
    deliveryZones: {
      type: "MultiPolygon", 
      coordinates: [
        [[ // First delivery zone
          [-122.4000, 37.7900],
          [-122.3900, 37.7900],
          [-122.3900, 37.8000],
          [-122.4000, 37.8000],
          [-122.4000, 37.7900]
        ]],
        [[ // Second delivery zone
          [-122.4100, 37.7800],
          [-122.3950, 37.7800],
          [-122.3950, 37.7900],
          [-122.4100, 37.7900],
          [-122.4100, 37.7800]
        ]]
      ]
    },

    // Business information
    business: {
      rating: 4.6,
      totalReviews: 1247,
      priceRange: "$$",
      phoneNumber: "+1-415-555-0123",
      website: "https://bluebottlecoffee.com",
      isActive: true,
      isChain: true,

      // Hours of operation with geospatial considerations
      hours: {
        monday: { open: "06:00", close: "19:00", timezone: "America/Los_Angeles" },
        tuesday: { open: "06:00", close: "19:00", timezone: "America/Los_Angeles" },
        wednesday: { open: "06:00", close: "19:00", timezone: "America/Los_Angeles" },
        thursday: { open: "06:00", close: "19:00", timezone: "America/Los_Angeles" },
        friday: { open: "06:00", close: "20:00", timezone: "America/Los_Angeles" },
        saturday: { open: "07:00", close: "20:00", timezone: "America/Los_Angeles" },
        sunday: { open: "07:00", close: "19:00", timezone: "America/Los_Angeles" }
      },

      // Services and amenities
      amenities: ["wifi", "outdoor_seating", "takeout", "delivery", "mobile_payment"],
      specialties: ["single_origin", "cold_brew", "espresso", "pour_over"]
    },

    // Geospatial metadata
    geoMetadata: {
      coordinateSystem: "WGS84",
      accuracyMeters: 5,
      elevationMeters: 15,
      dataSource: "GPS_verified",
      lastVerified: new Date("2024-09-01"),

      // Nearby landmarks for context
      nearbyLandmarks: [
        {
          name: "Ferry Building Marketplace",
          distance: 50,
          bearing: "north"
        },
        {
          name: "Embarcadero BART Station", 
          distance: 200,
          bearing: "west"
        }
      ]
    },

    // Analytics and performance data
    analytics: {
      monthlyVisitors: 12500,
      averageVisitDuration: 25, // minutes
      peakHours: ["08:00-09:00", "12:00-13:00", "15:00-16:00"],
      popularDays: ["monday", "tuesday", "wednesday", "friday"],

      // Location-specific metrics
      locationMetrics: {
        averageWalkingTime: 3.5, // minutes from nearest transit
        parkingAvailability: "limited",
        accessibilityRating: 4.2,
        noiseLevel: "moderate",
        crowdLevel: "busy"
      }
    },

    // SEO and discovery
    searchTerms: [
      "coffee shop ferry building", 
      "blue bottle san francisco",
      "specialty coffee embarcadero",
      "third wave coffee downtown sf"
    ],

    tags: ["coffee", "cafe", "specialty", "artisan", "downtown", "waterfront"],

    createdAt: new Date("2024-01-15"),
    updatedAt: new Date("2024-09-14")
  };

  // Insert the location document
  await locations.insertOne(locationDocument);

  // Create geospatial index - 2dsphere for spherical geometry (Earth)
  await locations.createIndex({ location: "2dsphere" });
  await locations.createIndex({ serviceArea: "2dsphere" });
  await locations.createIndex({ deliveryZones: "2dsphere" });

  // Additional indexes for common queries
  await locations.createIndex({ category: 1, "business.rating": -1 });
  await locations.createIndex({ "business.isActive": 1, "location": "2dsphere" });
  await locations.createIndex({ tags: 1, "location": "2dsphere" });

  console.log("Location document and indexes created successfully");
  return locations;
};

// Advanced geospatial queries and operations
const performGeospatialOperations = async () => {
  const locations = db.collection('locations');

  // 1. Proximity Search - Find nearby locations
  console.log("=== Proximity Search ===");
  const userLocation = [-122.4194, 37.7749]; // San Francisco coordinates [lng, lat]

  const nearbyLocations = await locations.find({
    location: {
      $near: {
        $geometry: {
          type: "Point",
          coordinates: userLocation
        },
        $maxDistance: 5000, // 5km in meters
        $minDistance: 0
      }
    },
    "business.isActive": true
  }).limit(10).toArray();

  console.log(`Found ${nearbyLocations.length} locations within 5km`);

  // 2. Geo Within - Find locations within a specific area
  console.log("\n=== Geo Within Search ===");
  const searchPolygon = {
    type: "Polygon", 
    coordinates: [[
      [-122.4270, 37.7609], // Southwest corner
      [-122.3968, 37.7609], // Southeast corner
      [-122.3968, 37.7908], // Northeast corner  
      [-122.4270, 37.7908], // Northwest corner
      [-122.4270, 37.7609]  // Close polygon
    ]]
  };

  const locationsInArea = await locations.find({
    location: {
      $geoWithin: {
        $geometry: searchPolygon
      }
    },
    category: "restaurant"
  }).toArray();

  console.log(`Found ${locationsInArea.length} restaurants in specified area`);

  // 3. Geospatial Aggregation - Complex analytics
  console.log("\n=== Geospatial Analytics ===");
  const geospatialAnalytics = await locations.aggregate([
    // Match active locations
    {
      $match: {
        "business.isActive": true,
        location: {
          $geoWithin: {
            $centerSphere: [userLocation, 10 / 3963.2] // 10 miles radius
          }
        }
      }
    },

    // Calculate distance from user location
    {
      $addFields: {
        distanceFromUser: {
          $divide: [
            {
              $sqrt: {
                $add: [
                  {
                    $pow: [
                      { $subtract: [{ $arrayElemAt: ["$location.coordinates", 0] }, userLocation[0]] },
                      2
                    ]
                  },
                  {
                    $pow: [
                      { $subtract: [{ $arrayElemAt: ["$location.coordinates", 1] }, userLocation[1]] },
                      2
                    ]
                  }
                ]
              }
            },
            0.000009 // Approximate degrees to meters conversion
          ]
        }
      }
    },

    // Group by category and analyze
    {
      $group: {
        _id: "$category",
        totalLocations: { $sum: 1 },
        averageRating: { $avg: "$business.rating" },
        averageDistance: { $avg: "$distanceFromUser" },
        closestLocation: {
          $min: {
            name: "$name",
            distance: "$distanceFromUser",
            coordinates: "$location.coordinates"
          }
        },

        // Collect all locations in category
        locations: {
          $push: {
            name: "$name",
            rating: "$business.rating",
            distance: "$distanceFromUser",
            coordinates: "$location.coordinates"
          }
        },

        // Rating distribution
        highRatedCount: {
          $sum: { $cond: [{ $gte: ["$business.rating", 4.5] }, 1, 0] }
        },
        mediumRatedCount: {
          $sum: { $cond: [{ $and: [{ $gte: ["$business.rating", 3.5] }, { $lt: ["$business.rating", 4.5] }] }, 1, 0] }
        },
        lowRatedCount: {
          $sum: { $cond: [{ $lt: ["$business.rating", 3.5] }, 1, 0] }
        }
      }
    },

    // Calculate additional metrics
    {
      $addFields: {
        categoryDensity: { $divide: ["$totalLocations", 314] }, // per square km (10 mile radius ≈ 314 sq km)
        highRatedPercentage: { $multiply: [{ $divide: ["$highRatedCount", "$totalLocations"] }, 100] },
        averageDistanceKm: { $multiply: ["$averageDistance", 111] } // Rough conversion to km
      }
    },

    // Sort by total locations and rating
    {
      $sort: {
        totalLocations: -1,
        averageRating: -1
      }
    },

    // Format output
    {
      $project: {
        category: "$_id",
        totalLocations: 1,
        averageRating: { $round: ["$averageRating", 2] },
        averageDistanceKm: { $round: ["$averageDistanceKm", 2] },
        categoryDensity: { $round: ["$categoryDensity", 2] },
        highRatedPercentage: { $round: ["$highRatedPercentage", 1] },
        closestLocation: 1,
        ratingDistribution: {
          high: "$highRatedCount",
          medium: "$mediumRatedCount", 
          low: "$lowRatedCount"
        }
      }
    }
  ]).toArray();

  console.log("Geospatial Analytics Results:");
  console.log(JSON.stringify(geospatialAnalytics, null, 2));

  // 4. Route optimization - Find optimal path through multiple locations
  console.log("\n=== Route Optimization ===");
  const waypointLocations = [
    [-122.4194, 37.7749], // Start: San Francisco
    [-122.4094, 37.7849], // Waypoint 1
    [-122.3994, 37.7949], // Waypoint 2
    [-122.4194, 37.7749]  // End: Back to start
  ];

  // Find locations near each waypoint
  const routeAnalysis = await Promise.all(
    waypointLocations.map(async (waypoint, index) => {
      const nearbyOnRoute = await locations.find({
        location: {
          $near: {
            $geometry: {
              type: "Point",
              coordinates: waypoint
            },
            $maxDistance: 500 // 500m radius
          }
        },
        "business.isActive": true
      }).limit(5).toArray();

      return {
        waypointIndex: index,
        coordinates: waypoint,
        nearbyLocations: nearbyOnRoute.map(loc => ({
          name: loc.name,
          category: loc.category,
          rating: loc.business.rating,
          coordinates: loc.location.coordinates
        }))
      };
    })
  );

  console.log("Route Analysis:");
  console.log(JSON.stringify(routeAnalysis, null, 2));

  return {
    nearbyLocations: nearbyLocations.length,
    locationsInArea: locationsInArea.length,
    analyticsResults: geospatialAnalytics.length,
    routeWaypoints: routeAnalysis.length
  };
};

// Real-time location tracking and geofencing
const setupLocationTracking = async () => {
  const userLocations = db.collection('user_locations');
  const geofences = db.collection('geofences');

  // Create user location tracking document
  const userLocationDocument = {
    _id: new ObjectId(),
    userId: new ObjectId("64a1b2c3d4e5f6789012347a"),

    // Current location
    currentLocation: {
      type: "Point",
      coordinates: [-122.4194, 37.7749]
    },

    // Location metadata
    locationMetadata: {
      accuracy: 10, // meters
      altitude: 15, // meters above sea level
      heading: 45, // degrees from north
      speed: 1.5, // meters per second
      timestamp: new Date(),
      source: "GPS", // GPS, WiFi, Cellular, Manual
      batteryLevel: 85,

      // Device context
      device: {
        platform: "iOS",
        version: "17.1",
        model: "iPhone 15 Pro",
        appVersion: "2.1.0"
      }
    },

    // Location history (recent positions)
    locationHistory: [
      {
        location: {
          type: "Point", 
          coordinates: [-122.4204, 37.7739]
        },
        timestamp: new Date(Date.now() - 300000), // 5 minutes ago
        accuracy: 15,
        source: "GPS"
      },
      {
        location: {
          type: "Point",
          coordinates: [-122.4214, 37.7729] 
        },
        timestamp: new Date(Date.now() - 600000), // 10 minutes ago
        accuracy: 12,
        source: "GPS"
      }
    ],

    // Privacy and permissions
    privacy: {
      shareLocation: true,
      accuracyLevel: "precise", // precise, approximate, city
      shareWithFriends: true,
      shareWithBusiness: false,
      trackingEnabled: true
    },

    // Activity context
    activity: {
      type: "walking", // walking, driving, cycling, stationary
      confidence: 0.85,
      detectedTransition: null,
      lastActivity: "stationary"
    },

    createdAt: new Date(),
    updatedAt: new Date()
  };

  // Create indexes for location tracking
  await userLocations.createIndex({ currentLocation: "2dsphere" });
  await userLocations.createIndex({ userId: 1, "locationMetadata.timestamp": -1 });
  await userLocations.createIndex({ "locationHistory.location": "2dsphere" });

  await userLocations.insertOne(userLocationDocument);

  // Create geofence system
  const geofenceDocument = {
    _id: new ObjectId(),
    name: "Downtown Coffee Shop Promo Zone",
    description: "Special promotions for coffee shops in downtown area",

    // Geofence area
    area: {
      type: "Polygon",
      coordinates: [[
        [-122.4200, 37.7700],
        [-122.4100, 37.7700], 
        [-122.4100, 37.7800],
        [-122.4200, 37.7800],
        [-122.4200, 37.7700]
      ]]
    },

    // Geofence configuration
    config: {
      type: "promotional", // promotional, security, analytics, notification
      radius: null, // For circular geofences
      isActive: true,

      // Trigger conditions
      triggers: {
        onEnter: true,
        onExit: true,
        onDwell: true,
        dwellTimeMinutes: 5,

        // Rate limiting
        minTimeBetweenTriggers: 300, // seconds
        maxTriggersPerDay: 10
      },

      // Actions to take
      actions: {
        notification: {
          enabled: true,
          title: "Coffee Deals Nearby!",
          message: "Check out special offers at local coffee shops",
          deepLink: "app://offers/coffee"
        },
        analytics: {
          trackEntry: true,
          trackExit: true,
          trackDwellTime: true
        },
        webhook: {
          enabled: false,
          url: "https://api.example.com/geofence-trigger",
          method: "POST"
        }
      }
    },

    // Analytics
    analytics: {
      totalEnters: 1456,
      totalExits: 1423,
      avgDwellTimeMinutes: 12.5,
      uniqueUsers: 342,

      // Time-based patterns
      hourlyActivity: {
        "08": 45, "09": 78, "10": 23, "11": 34,
        "12": 89, "13": 67, "14": 45, "15": 56,
        "16": 78, "17": 123, "18": 89, "19": 34
      },

      dailyActivity: {
        "monday": 234, "tuesday": 189, "wednesday": 267,
        "thursday": 201, "friday": 298, "saturday": 156, "sunday": 111
      }
    },

    createdAt: new Date("2024-09-01"),
    updatedAt: new Date("2024-09-14")
  };

  await geofences.createIndex({ area: "2dsphere" });
  await geofences.createIndex({ "config.isActive": 1, "config.type": 1 });

  await geofences.insertOne(geofenceDocument);

  // Real-time geofence checking function
  const checkGeofences = async (userId, currentLocation) => {
    console.log("Checking geofences for user location...");

    // Find all active geofences that contain the user's location
    const triggeredGeofences = await geofences.find({
      "config.isActive": true,
      area: {
        $geoIntersects: {
          $geometry: {
            type: "Point",
            coordinates: currentLocation
          }
        }
      }
    }).toArray();

    console.log(`Found ${triggeredGeofences.length} triggered geofences`);

    // Process each triggered geofence
    for (const geofence of triggeredGeofences) {
      console.log(`Processing geofence: ${geofence.name}`);

      // Update analytics
      await geofences.updateOne(
        { _id: geofence._id },
        {
          $inc: { 
            "analytics.totalEnters": 1,
            [`analytics.hourlyActivity.${new Date().getHours().toString().padStart(2, '0')}`]: 1,
            [`analytics.dailyActivity.${new Date().toLocaleDateString('en-US', { weekday: 'long' }).toLowerCase()}`]: 1
          },
          $set: { updatedAt: new Date() }
        }
      );

      // Trigger actions (notifications, webhooks, etc.)
      if (geofence.config.actions.notification.enabled) {
        console.log(`Sending notification: ${geofence.config.actions.notification.title}`);
        // Implementation would send actual notification
      }
    }

    return triggeredGeofences;
  };

  // Test geofence checking
  const testLocation = [-122.4150, 37.7750]; // Point within the geofence
  const triggeredFences = await checkGeofences(userLocationDocument.userId, testLocation);

  return {
    userLocationDocument,
    geofenceDocument,
    triggeredGeofences: triggeredFences.length
  };
};

// Advanced spatial analytics and heatmap generation
const generateSpatialAnalytics = async () => {
  const locations = db.collection('locations');
  const userLocations = db.collection('user_locations');

  console.log("=== Generating Spatial Analytics ===");

  // 1. Location Density Analysis
  const locationDensityAnalysis = await locations.aggregate([
    {
      $match: {
        "business.isActive": true
      }
    },

    // Create grid cells for density analysis
    {
      $addFields: {
        gridCell: {
          lat: {
            $floor: {
              $multiply: [
                { $arrayElemAt: ["$location.coordinates", 1] }, // latitude
                1000 // Create 0.001 degree grid cells (~100m)
              ]
            }
          },
          lng: {
            $floor: {
              $multiply: [
                { $arrayElemAt: ["$location.coordinates", 0] }, // longitude  
                1000
              ]
            }
          }
        }
      }
    },

    // Group by grid cell
    {
      $group: {
        _id: "$gridCell",
        locationCount: { $sum: 1 },
        avgRating: { $avg: "$business.rating" },
        categories: { $push: "$category" },

        // Calculate center point of grid cell
        centerCoordinates: {
          $first: {
            type: "Point",
            coordinates: [
              { $divide: ["$gridCell.lng", 1000] },
              { $divide: ["$gridCell.lat", 1000] }
            ]
          }
        },

        // Business metrics
        totalReviews: { $sum: "$business.totalReviews" },
        uniqueCategories: { $addToSet: "$category" }
      }
    },

    // Calculate density metrics
    {
      $addFields: {
        densityScore: {
          $multiply: [
            "$locationCount",
            { $divide: ["$avgRating", 5] } // Weight by average rating
          ]
        },
        categoryDiversity: { $size: "$uniqueCategories" }
      }
    },

    // Sort by density
    {
      $sort: { densityScore: -1 }
    },

    {
      $limit: 20 // Top 20 densest areas
    },

    {
      $project: {
        gridId: "$_id",
        locationCount: 1,
        densityScore: { $round: ["$densityScore", 2] },
        avgRating: { $round: ["$avgRating", 2] },
        categoryDiversity: 1,
        totalReviews: 1,
        centerCoordinates: 1
      }
    }
  ]).toArray();

  console.log(`Location Density Analysis - Found ${locationDensityAnalysis.length} high-density areas`);

  // 2. User Movement Patterns
  const userMovementAnalysis = await userLocations.aggregate([
    {
      $match: {
        "locationMetadata.timestamp": {
          $gte: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) // Last 7 days
        }
      }
    },

    // Unwind location history
    { $unwind: "$locationHistory" },

    // Calculate movement vectors
    {
      $addFields: {
        movement: {
          fromLat: { $arrayElemAt: ["$locationHistory.location.coordinates", 1] },
          fromLng: { $arrayElemAt: ["$locationHistory.location.coordinates", 0] },
          toLat: { $arrayElemAt: ["$currentLocation.coordinates", 1] },
          toLng: { $arrayElemAt: ["$currentLocation.coordinates", 0] },
          timestamp: "$locationHistory.timestamp"
        }
      }
    },

    // Calculate distance and bearing
    {
      $addFields: {
        "movement.distance": {
          // Haversine formula approximation
          $multiply: [
            6371000, // Earth radius in meters
            {
              $acos: {
                $add: [
                  {
                    $multiply: [
                      { $sin: { $multiply: [{ $degreesToRadians: "$movement.fromLat" }, 1] } },
                      { $sin: { $multiply: [{ $degreesToRadians: "$movement.toLat" }, 1] } }
                    ]
                  },
                  {
                    $multiply: [
                      { $cos: { $multiply: [{ $degreesToRadians: "$movement.fromLat" }, 1] } },
                      { $cos: { $multiply: [{ $degreesToRadians: "$movement.toLat" }, 1] } },
                      { $cos: {
                        $multiply: [
                          { $degreesToRadians: { $subtract: ["$movement.toLng", "$movement.fromLng"] } },
                          1
                        ]
                      } }
                    ]
                  }
                ]
              }
            }
          ]
        }
      }
    },

    // Group movement patterns
    {
      $group: {
        _id: {
          hour: { $hour: "$movement.timestamp" },
          dayOfWeek: { $dayOfWeek: "$movement.timestamp" }
        },

        totalMovements: { $sum: 1 },
        avgDistance: { $avg: "$movement.distance" },
        totalDistance: { $sum: "$movement.distance" },
        uniqueUsers: { $addToSet: "$userId" },

        // Movement characteristics
        shortMovements: {
          $sum: { $cond: [{ $lt: ["$movement.distance", 100] }, 1, 0] } // < 100m
        },
        mediumMovements: {
          $sum: { $cond: [
            { $and: [
              { $gte: ["$movement.distance", 100] },
              { $lt: ["$movement.distance", 1000] }
            ]}, 1, 0
          ] } // 100m - 1km
        },
        longMovements: {
          $sum: { $cond: [{ $gte: ["$movement.distance", 1000] }, 1, 0] } // > 1km
        }
      }
    },

    // Calculate additional metrics
    {
      $addFields: {
        uniqueUserCount: { $size: "$uniqueUsers" },
        avgMovementsPerUser: { $divide: ["$totalMovements", { $size: "$uniqueUsers" }] },
        movementDistribution: {
          short: { $divide: ["$shortMovements", "$totalMovements"] },
          medium: { $divide: ["$mediumMovements", "$totalMovements"] },
          long: { $divide: ["$longMovements", "$totalMovements"] }
        }
      }
    },

    {
      $sort: { totalMovements: -1 }
    },

    {
      $project: {
        hour: "$_id.hour",
        dayOfWeek: "$_id.dayOfWeek", 
        totalMovements: 1,
        uniqueUserCount: 1,
        avgDistance: { $round: ["$avgDistance", 1] },
        avgMovementsPerUser: { $round: ["$avgMovementsPerUser", 1] },
        movementDistribution: {
          short: { $round: ["$movementDistribution.short", 3] },
          medium: { $round: ["$movementDistribution.medium", 3] },
          long: { $round: ["$movementDistribution.long", 3] }
        }
      }
    }
  ]).toArray();

  console.log(`User Movement Analysis - Analyzed ${userMovementAnalysis.length} time periods`);

  // 3. Geographic Performance Analysis
  const geoPerformanceAnalysis = await locations.aggregate([
    {
      $match: {
        "business.isActive": true,
        "analytics.monthlyVisitors": { $exists: true }
      }
    },

    // Create geographic regions
    {
      $addFields: {
        region: {
          $switch: {
            branches: [
              {
                case: {
                  $and: [
                    { $gte: [{ $arrayElemAt: ["$location.coordinates", 1] }, 37.77] }, // North of 37.77°N
                    { $lte: [{ $arrayElemAt: ["$location.coordinates", 0] }, -122.41] } // West of -122.41°W
                  ]
                },
                then: "Northwest"
              },
              {
                case: {
                  $and: [
                    { $gte: [{ $arrayElemAt: ["$location.coordinates", 1] }, 37.77] },
                    { $gt: [{ $arrayElemAt: ["$location.coordinates", 0] }, -122.41] }
                  ]
                },
                then: "Northeast"
              },
              {
                case: {
                  $and: [
                    { $lt: [{ $arrayElemAt: ["$location.coordinates", 1] }, 37.77] },
                    { $lte: [{ $arrayElemAt: ["$location.coordinates", 0] }, -122.41] }
                  ]
                },
                then: "Southwest"
              },
              {
                case: {
                  $and: [
                    { $lt: [{ $arrayElemAt: ["$location.coordinates", 1] }, 37.77] },
                    { $gt: [{ $arrayElemAt: ["$location.coordinates", 0] }, -122.41] }
                  ]
                },
                then: "Southeast"
              }
            ],
            default: "Other"
          }
        }
      }
    },

    // Group by region and category
    {
      $group: {
        _id: {
          region: "$region",
          category: "$category"
        },

        locationCount: { $sum: 1 },
        avgRating: { $avg: "$business.rating" },
        avgMonthlyVisitors: { $avg: "$analytics.monthlyVisitors" },
        totalMonthlyVisitors: { $sum: "$analytics.monthlyVisitors" },

        // Performance metrics
        highPerformers: {
          $sum: {
            $cond: [
              {
                $and: [
                  { $gte: ["$business.rating", 4.5] },
                  { $gte: ["$analytics.monthlyVisitors", 10000] }
                ]
              }, 1, 0
            ]
          }
        },

        topLocation: {
          $max: {
            name: "$name",
            visitors: "$analytics.monthlyVisitors",
            rating: "$business.rating"
          }
        }
      }
    },

    // Calculate regional metrics
    {
      $group: {
        _id: "$_id.region",

        categories: {
          $push: {
            category: "$_id.category",
            locationCount: "$locationCount",
            avgRating: "$avgRating",
            avgMonthlyVisitors: "$avgMonthlyVisitors",
            totalMonthlyVisitors: "$totalMonthlyVisitors",
            highPerformers: "$highPerformers",
            topLocation: "$topLocation"
          }
        },

        regionalTotals: {
          totalLocations: { $sum: "$locationCount" },
          totalMonthlyVisitors: { $sum: "$totalMonthlyVisitors" },
          totalHighPerformers: { $sum: "$highPerformers" }
        }
      }
    },

    // Sort by total visitors
    {
      $sort: { "regionalTotals.totalMonthlyVisitors": -1 }
    },

    {
      $project: {
        region: "$_id",
        categories: 1,
        regionalTotals: 1,

        // Calculate regional performance metrics
        performanceMetrics: {
          avgVisitorsPerLocation: {
            $divide: ["$regionalTotals.totalMonthlyVisitors", "$regionalTotals.totalLocations"]
          },
          highPerformerRatio: {
            $divide: ["$regionalTotals.totalHighPerformers", "$regionalTotals.totalLocations"]
          }
        }
      }
    }
  ]).toArray();

  console.log(`Geographic Performance Analysis - Analyzed ${geoPerformanceAnalysis.length} regions`);

  return {
    densityAnalysis: locationDensityAnalysis,
    movementAnalysis: userMovementAnalysis,
    performanceAnalysis: geoPerformanceAnalysis,

    summary: {
      densityHotspots: locationDensityAnalysis.length,
      movementPatterns: userMovementAnalysis.length,
      regionalInsights: geoPerformanceAnalysis.length
    }
  };
};

// Benefits of MongoDB Geospatial Features:
// - Native GeoJSON support with automatic validation
// - Multiple coordinate reference systems (2D, 2dsphere)
// - Built-in spatial operators and aggregation functions
// - Automatic spatial indexing with B-tree and R-tree structures
// - Spherical geometry calculations for Earth-based applications
// - Integration with aggregation framework for complex analytics
// - Real-time geofencing and location tracking capabilities
// - Scalable to billions of location data points
// - Simple query syntax compared to PostGIS extensions
// - No additional setup required - works out of the box

module.exports = {
  createLocationServiceDataModel,
  performGeospatialOperations,
  setupLocationTracking,
  generateSpatialAnalytics
};