MongoDB Atlas Deployment Automation and Cloud Infrastructure: Advanced DevOps Integration and Infrastructure-as-Code for Scalable Database Operations

-- Traditional cloud database management - manual setup with extensive operational overhead

-- Basic database server provisioning tracking (manual process)
CREATE TABLE database_servers (
    server_id SERIAL PRIMARY KEY,
    server_name VARCHAR(255) NOT NULL,
    cloud_provider VARCHAR(100) NOT NULL,
    instance_type VARCHAR(100) NOT NULL,
    region VARCHAR(100) NOT NULL,

    -- Manual resource configuration
    cpu_cores INTEGER,
    memory_gb INTEGER,
    storage_gb INTEGER,
    iops INTEGER,

    -- Network configuration (manual setup)
    vpc_id VARCHAR(100),
    subnet_id VARCHAR(100),
    security_group_ids TEXT[],
    public_ip INET,
    private_ip INET,

    -- Database configuration
    database_engine VARCHAR(50) DEFAULT 'postgresql',
    engine_version VARCHAR(20),
    port INTEGER DEFAULT 5432,

    -- Status tracking
    server_status VARCHAR(50) DEFAULT 'creating',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    provisioned_by VARCHAR(100),

    -- Cost tracking (manual)
    estimated_monthly_cost DECIMAL(10,2),
    actual_monthly_cost DECIMAL(10,2)
);

-- Database deployment tracking (complex manual process)
CREATE TABLE database_deployments (
    deployment_id SERIAL PRIMARY KEY,
    deployment_name VARCHAR(255) NOT NULL,
    server_id INTEGER REFERENCES database_servers(server_id),
    environment VARCHAR(100) NOT NULL,

    -- Deployment configuration (manual setup)
    database_name VARCHAR(100) NOT NULL,
    schema_version VARCHAR(50),
    application_version VARCHAR(50),

    -- Manual backup configuration
    backup_enabled BOOLEAN DEFAULT true,
    backup_schedule VARCHAR(100), -- Cron format
    backup_retention_days INTEGER DEFAULT 30,
    backup_storage_location VARCHAR(200),

    -- Scaling configuration (manual)
    enable_auto_scaling BOOLEAN DEFAULT false,
    min_capacity INTEGER,
    max_capacity INTEGER,
    target_cpu_utilization DECIMAL(5,2) DEFAULT 70.0,
    target_memory_utilization DECIMAL(5,2) DEFAULT 80.0,

    -- Monitoring setup (manual integration)
    monitoring_enabled BOOLEAN DEFAULT false,
    monitoring_tools TEXT[],
    alert_endpoints TEXT[],

    -- Deployment metadata
    deployment_status VARCHAR(50) DEFAULT 'pending',
    deployed_at TIMESTAMP,
    deployed_by VARCHAR(100),
    deployment_duration_seconds INTEGER,

    -- Configuration validation
    config_validation_status VARCHAR(50),
    validation_errors TEXT[]
);

-- Manual scaling operation tracking
CREATE TABLE scaling_operations (
    scaling_id SERIAL PRIMARY KEY,
    server_id INTEGER REFERENCES database_servers(server_id),
    scaling_trigger VARCHAR(100),

    -- Resource changes (manual calculation)
    previous_cpu_cores INTEGER,
    new_cpu_cores INTEGER,
    previous_memory_gb INTEGER,
    new_memory_gb INTEGER,
    previous_storage_gb INTEGER,
    new_storage_gb INTEGER,

    -- Scaling metrics
    trigger_metric VARCHAR(100),
    trigger_threshold DECIMAL(10,2),
    current_utilization DECIMAL(10,2),

    -- Scaling execution
    scaling_status VARCHAR(50) DEFAULT 'pending',
    started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    completed_at TIMESTAMP,
    downtime_seconds INTEGER,

    -- Cost impact
    previous_hourly_cost DECIMAL(10,4),
    new_hourly_cost DECIMAL(10,4),
    cost_impact_monthly DECIMAL(10,2)
);

-- Basic monitoring and alerting (very limited automation)
CREATE OR REPLACE FUNCTION check_database_health()
RETURNS TABLE (
    server_id INTEGER,
    health_status VARCHAR(50),
    cpu_utilization DECIMAL(5,2),
    memory_utilization DECIMAL(5,2),
    disk_utilization DECIMAL(5,2),
    connection_count INTEGER,
    active_queries INTEGER,
    replication_lag_seconds INTEGER,
    backup_status VARCHAR(50),
    alert_level VARCHAR(20),
    recommendations TEXT[]
) AS $$
BEGIN
    -- This would be a very simplified health check
    -- Real implementation would require complex monitoring integration

    RETURN QUERY
    SELECT 
        ds.server_id,

        -- Basic status assessment (very limited)
        CASE 
            WHEN ds.server_status != 'running' THEN 'unhealthy'
            ELSE 'healthy'
        END as health_status,

        -- Simulated metrics (would need real monitoring integration)
        (random() * 100)::DECIMAL(5,2) as cpu_utilization,
        (random() * 100)::DECIMAL(5,2) as memory_utilization,
        (random() * 100)::DECIMAL(5,2) as disk_utilization,
        (random() * 100)::INTEGER as connection_count,
        (random() * 20)::INTEGER as active_queries,
        (random() * 10)::INTEGER as replication_lag_seconds,

        -- Backup status (manual tracking)
        'unknown' as backup_status,

        -- Alert level determination
        CASE 
            WHEN ds.server_status != 'running' THEN 'critical'
            WHEN random() > 0.9 THEN 'warning'
            ELSE 'info'
        END as alert_level,

        -- Basic recommendations (very limited)
        ARRAY[
            CASE WHEN random() > 0.8 THEN 'Consider scaling up CPU resources' END,
            CASE WHEN random() > 0.7 THEN 'Review backup configuration' END,
            CASE WHEN random() > 0.6 THEN 'Monitor connection pool usage' END
        ]::TEXT[] as recommendations

    FROM database_servers ds
    WHERE ds.server_status = 'running';
END;
$$ LANGUAGE plpgsql;

-- Manual deployment automation attempt (very basic)
CREATE OR REPLACE FUNCTION deploy_database_environment(
    deployment_name_param VARCHAR(255),
    environment_param VARCHAR(100),
    instance_type_param VARCHAR(100),
    database_name_param VARCHAR(100)
) RETURNS TABLE (
    deployment_success BOOLEAN,
    deployment_id INTEGER,
    server_id INTEGER,
    deployment_time_seconds INTEGER,
    error_message TEXT
) AS $$
DECLARE
    new_deployment_id INTEGER;
    new_server_id INTEGER;
    deployment_start TIMESTAMP;
    deployment_end TIMESTAMP;
    deployment_error TEXT := '';
    deployment_result BOOLEAN := true;
BEGIN
    deployment_start := clock_timestamp();

    BEGIN
        -- Step 1: Create database server record (manual provisioning simulation)
        INSERT INTO database_servers (
            server_name,
            cloud_provider,
            instance_type,
            region,
            cpu_cores,
            memory_gb,
            storage_gb,
            server_status,
            provisioned_by
        )
        VALUES (
            deployment_name_param || '_' || environment_param,
            'manual_cloud_provider',
            instance_type_param,
            'us-east-1',
            -- Static resource allocation (no optimization)
            CASE instance_type_param
                WHEN 't3.micro' THEN 1
                WHEN 't3.small' THEN 2
                WHEN 't3.medium' THEN 2
                ELSE 4
            END,
            CASE instance_type_param
                WHEN 't3.micro' THEN 1
                WHEN 't3.small' THEN 2
                WHEN 't3.medium' THEN 4
                ELSE 8
            END,
            100, -- Fixed storage
            'creating',
            current_user
        )
        RETURNING server_id INTO new_server_id;

        -- Simulate provisioning time
        PERFORM pg_sleep(2);

        -- Update server status
        UPDATE database_servers 
        SET server_status = 'running', last_updated = clock_timestamp()
        WHERE server_id = new_server_id;

        -- Step 2: Create deployment record
        INSERT INTO database_deployments (
            deployment_name,
            server_id,
            environment,
            database_name,
            deployment_status,
            deployed_by
        )
        VALUES (
            deployment_name_param,
            new_server_id,
            environment_param,
            database_name_param,
            'creating',
            current_user
        )
        RETURNING deployment_id INTO new_deployment_id;

        -- Simulate deployment process
        PERFORM pg_sleep(1);

        -- Update deployment status
        UPDATE database_deployments 
        SET deployment_status = 'completed',
            deployed_at = clock_timestamp()
        WHERE deployment_id = new_deployment_id;

    EXCEPTION WHEN OTHERS THEN
        deployment_result := false;
        deployment_error := SQLERRM;

        -- Cleanup on failure
        IF new_server_id IS NOT NULL THEN
            UPDATE database_servers 
            SET server_status = 'failed'
            WHERE server_id = new_server_id;
        END IF;

        IF new_deployment_id IS NOT NULL THEN
            UPDATE database_deployments 
            SET deployment_status = 'failed'
            WHERE deployment_id = new_deployment_id;
        END IF;
    END;

    deployment_end := clock_timestamp();

    RETURN QUERY SELECT 
        deployment_result,
        new_deployment_id,
        new_server_id,
        EXTRACT(SECONDS FROM deployment_end - deployment_start)::INTEGER,
        deployment_error;
END;
$$ LANGUAGE plpgsql;

-- Basic infrastructure monitoring query (very limited capabilities)
WITH server_utilization AS (
    SELECT 
        ds.server_id,
        ds.server_name,
        ds.instance_type,
        ds.cpu_cores,
        ds.memory_gb,
        ds.storage_gb,
        ds.server_status,
        ds.estimated_monthly_cost,

        -- Simulated current utilization (would need real monitoring)
        (random() * 100)::DECIMAL(5,2) as current_cpu_percent,
        (random() * 100)::DECIMAL(5,2) as current_memory_percent,
        (random() * 100)::DECIMAL(5,2) as current_storage_percent,

        -- Basic scaling recommendations (very limited logic)
        CASE 
            WHEN random() > 0.8 THEN 'scale_up'
            WHEN random() < 0.2 THEN 'scale_down'
            ELSE 'no_action'
        END as scaling_recommendation

    FROM database_servers ds
    WHERE ds.server_status = 'running'
),

cost_analysis AS (
    SELECT 
        su.*,
        dd.environment,

        -- Basic cost optimization suggestions (manual analysis)
        CASE 
            WHEN su.current_cpu_percent < 30 AND su.current_memory_percent < 30 THEN 'overprovisioned'
            WHEN su.current_cpu_percent > 80 OR su.current_memory_percent > 80 THEN 'underprovisioned'
            ELSE 'appropriately_sized'
        END as resource_sizing,

        -- Simple cost projection
        su.estimated_monthly_cost * 
        CASE su.scaling_recommendation
            WHEN 'scale_up' THEN 1.5
            WHEN 'scale_down' THEN 0.7
            ELSE 1.0
        END as projected_monthly_cost

    FROM server_utilization su
    JOIN database_deployments dd ON su.server_id = dd.server_id
)

SELECT 
    ca.server_name,
    ca.environment,
    ca.instance_type,
    ca.server_status,

    -- Resource utilization
    ca.current_cpu_percent,
    ca.current_memory_percent,
    ca.current_storage_percent,

    -- Scaling analysis
    ca.scaling_recommendation,
    ca.resource_sizing,

    -- Cost analysis
    ca.estimated_monthly_cost,
    ca.projected_monthly_cost,
    ROUND((ca.projected_monthly_cost - ca.estimated_monthly_cost), 2) as monthly_cost_impact,

    -- Basic recommendations
    CASE 
        WHEN ca.resource_sizing = 'overprovisioned' THEN 'Consider downsizing to reduce costs'
        WHEN ca.resource_sizing = 'underprovisioned' THEN 'Scale up to improve performance'
        WHEN ca.current_storage_percent > 85 THEN 'Increase storage capacity soon'
        ELSE 'Monitor current resource usage'
    END as operational_recommendation

FROM cost_analysis ca
ORDER BY ca.estimated_monthly_cost DESC;

-- Problems with traditional cloud database deployment:
-- 1. Manual provisioning with no infrastructure-as-code integration
-- 2. Limited auto-scaling capabilities requiring manual intervention
-- 3. Basic monitoring with no intelligent alerting or remediation
-- 4. Complex backup and disaster recovery configuration
-- 5. No built-in security best practices or compliance features
-- 6. Manual cost optimization requiring constant monitoring
-- 7. Limited integration with CI/CD pipelines and DevOps workflows
-- 8. No automatic patching or maintenance scheduling
-- 9. Complex networking and security group management
-- 10. Basic performance optimization requiring database expertise

// MongoDB Atlas Advanced Deployment Automation and Cloud Infrastructure Management
const { MongoClient } = require('mongodb');
const axios = require('axios');

// Comprehensive MongoDB Atlas Infrastructure Manager
class AdvancedAtlasInfrastructureManager {
  constructor(atlasConfig = {}) {
    // Atlas API configuration
    this.atlasConfig = {
      publicKey: atlasConfig.publicKey,
      privateKey: atlasConfig.privateKey,
      baseURL: atlasConfig.baseURL || 'https://cloud.mongodb.com/api/atlas/v1.0',

      // Organization and project configuration
      organizationId: atlasConfig.organizationId,
      projectId: atlasConfig.projectId,

      // Infrastructure automation settings
      enableAutomatedDeployment: atlasConfig.enableAutomatedDeployment !== false,
      enableInfrastructureAsCode: atlasConfig.enableInfrastructureAsCode || false,
      enableAutomatedScaling: atlasConfig.enableAutomatedScaling !== false,

      // DevOps integration
      cicdIntegration: atlasConfig.cicdIntegration || false,
      terraformIntegration: atlasConfig.terraformIntegration || false,
      kubernetesIntegration: atlasConfig.kubernetesIntegration || false,

      // Monitoring and alerting
      enableAdvancedMonitoring: atlasConfig.enableAdvancedMonitoring !== false,
      enableAutomatedAlerting: atlasConfig.enableAutomatedAlerting !== false,
      enablePerformanceAdvisor: atlasConfig.enablePerformanceAdvisor !== false,

      // Security and compliance
      enableAdvancedSecurity: atlasConfig.enableAdvancedSecurity !== false,
      enableEncryptionAtRest: atlasConfig.enableEncryptionAtRest !== false,
      enableNetworkSecurity: atlasConfig.enableNetworkSecurity !== false,

      // Backup and disaster recovery
      enableContinuousBackup: atlasConfig.enableContinuousBackup !== false,
      enableCrossRegionBackup: atlasConfig.enableCrossRegionBackup || false,
      backupRetentionDays: atlasConfig.backupRetentionDays || 30,

      // Cost optimization
      enableCostOptimization: atlasConfig.enableCostOptimization || false,
      enableAutoArchiving: atlasConfig.enableAutoArchiving || false,
      costBudgetAlerts: atlasConfig.costBudgetAlerts || []
    };

    // Infrastructure state management
    this.clusters = new Map();
    this.deployments = new Map();
    this.scalingOperations = new Map();
    this.monitoringAlerts = new Map();

    // DevOps integration state
    this.cicdPipelines = new Map();
    this.infrastructureTemplates = new Map();

    // Performance and cost tracking
    this.performanceMetrics = {
      totalClusters: 0,
      averageResponseTime: 0,
      totalMonthlySpend: 0,
      costPerOperation: 0
    };

    this.initializeAtlasInfrastructure();
  }

  async initializeAtlasInfrastructure() {
    console.log('Initializing MongoDB Atlas infrastructure management...');

    try {
      // Validate Atlas API credentials
      await this.validateAtlasCredentials();

      // Initialize infrastructure automation
      if (this.atlasConfig.enableAutomatedDeployment) {
        await this.setupAutomatedDeployment();
      }

      // Setup infrastructure-as-code integration
      if (this.atlasConfig.enableInfrastructureAsCode) {
        await this.setupInfrastructureAsCode();
      }

      // Initialize monitoring and alerting
      if (this.atlasConfig.enableAdvancedMonitoring) {
        await this.setupAdvancedMonitoring();
      }

      // Setup DevOps integrations
      if (this.atlasConfig.cicdIntegration) {
        await this.setupCICDIntegration();
      }

      console.log('Atlas infrastructure management initialized successfully');

    } catch (error) {
      console.error('Error initializing Atlas infrastructure:', error);
      throw error;
    }
  }

  async deployCluster(clusterConfig, deploymentOptions = {}) {
    console.log(`Deploying Atlas cluster: ${clusterConfig.name}`);

    try {
      const deployment = {
        deploymentId: this.generateDeploymentId(),
        clusterName: clusterConfig.name,

        // Cluster specification
        clusterSpec: {
          name: clusterConfig.name,
          clusterType: clusterConfig.clusterType || 'REPLICASET',
          mongoDBVersion: clusterConfig.mongoDBVersion || '7.0',

          // Provider configuration
          providerSettings: {
            providerName: clusterConfig.providerName || 'AWS',
            regionName: clusterConfig.regionName || 'US_EAST_1',
            instanceSizeName: clusterConfig.instanceSizeName || 'M30',

            // Advanced configuration
            diskIOPS: clusterConfig.diskIOPS,
            encryptEBSVolume: this.atlasConfig.enableEncryptionAtRest,
            volumeType: clusterConfig.volumeType || 'STANDARD'
          },

          // Replication configuration
          replicationSpecs: clusterConfig.replicationSpecs || [
            {
              numShards: 1,
              regionsConfig: {
                [clusterConfig.regionName || 'US_EAST_1']: {
                  electableNodes: 3,
                  priority: 7,
                  readOnlyNodes: 0
                }
              }
            }
          ],

          // Backup configuration
          backupEnabled: this.atlasConfig.enableContinuousBackup,
          providerBackupEnabled: this.atlasConfig.enableCrossRegionBackup,

          // Auto-scaling configuration
          autoScaling: {
            diskGBEnabled: this.atlasConfig.enableAutomatedScaling,
            compute: {
              enabled: this.atlasConfig.enableAutomatedScaling,
              scaleDownEnabled: true,
              minInstanceSize: clusterConfig.minInstanceSize || 'M10',
              maxInstanceSize: clusterConfig.maxInstanceSize || 'M80'
            }
          }
        },

        // Deployment configuration
        deploymentConfig: {
          environment: deploymentOptions.environment || 'production',
          deploymentType: deploymentOptions.deploymentType || 'standard',
          rolloutStrategy: deploymentOptions.rolloutStrategy || 'immediate',

          // Network security
          networkAccessList: clusterConfig.networkAccessList || [],

          // Database users
          databaseUsers: clusterConfig.databaseUsers || [],

          // Advanced security
          ldapConfiguration: clusterConfig.ldapConfiguration,
          encryptionAtRestProvider: clusterConfig.encryptionAtRestProvider
        },

        // Deployment metadata
        startTime: new Date(),
        status: 'creating',
        createdBy: deploymentOptions.createdBy || 'system'
      };

      // Store deployment state
      this.deployments.set(deployment.deploymentId, deployment);

      // Execute Atlas cluster creation
      const clusterResponse = await this.createAtlasCluster(deployment.clusterSpec);

      // Setup monitoring and alerting
      if (this.atlasConfig.enableAdvancedMonitoring) {
        await this.setupClusterMonitoring(clusterResponse.clusterId, deployment);
      }

      // Configure network security
      await this.configureNetworkSecurity(clusterResponse.clusterId, deployment.deploymentConfig);

      // Create database users
      await this.createDatabaseUsers(clusterResponse.clusterId, deployment.deploymentConfig.databaseUsers);

      // Wait for cluster to be ready
      const clusterStatus = await this.waitForClusterReady(clusterResponse.clusterId);

      // Update deployment status
      deployment.status = 'completed';
      deployment.endTime = new Date();
      deployment.clusterId = clusterResponse.clusterId;
      deployment.connectionString = clusterStatus.connectionString;

      // Store cluster information
      this.clusters.set(clusterResponse.clusterId, {
        clusterId: clusterResponse.clusterId,
        deployment: deployment,
        specification: deployment.clusterSpec,
        status: clusterStatus,
        createdAt: deployment.startTime
      });

      // Update performance metrics
      this.updateInfrastructureMetrics(deployment);

      console.log(`Cluster deployed successfully: ${clusterConfig.name} (${clusterResponse.clusterId})`);

      return {
        success: true,
        deploymentId: deployment.deploymentId,
        clusterId: clusterResponse.clusterId,
        clusterName: clusterConfig.name,
        connectionString: clusterStatus.connectionString,

        // Deployment details
        deploymentTime: deployment.endTime.getTime() - deployment.startTime.getTime(),
        environment: deployment.deploymentConfig.environment,
        configuration: deployment.clusterSpec,

        // Monitoring and security
        monitoringEnabled: this.atlasConfig.enableAdvancedMonitoring,
        securityEnabled: this.atlasConfig.enableAdvancedSecurity,
        backupEnabled: deployment.clusterSpec.backupEnabled
      };

    } catch (error) {
      console.error(`Error deploying cluster '${clusterConfig.name}':`, error);

      // Update deployment status
      const deployment = this.deployments.get(this.generateDeploymentId());
      if (deployment) {
        deployment.status = 'failed';
        deployment.error = error.message;
        deployment.endTime = new Date();
      }

      return {
        success: false,
        error: error.message,
        clusterName: clusterConfig.name
      };
    }
  }

  async createAtlasCluster(clusterSpec) {
    console.log(`Creating Atlas cluster via API: ${clusterSpec.name}`);

    try {
      const response = await this.atlasAPIRequest('POST', `/groups/${this.atlasConfig.projectId}/clusters`, clusterSpec);

      return {
        clusterId: response.id,
        name: response.name,
        stateName: response.stateName,
        createDate: response.createDate
      };

    } catch (error) {
      console.error('Error creating Atlas cluster:', error);
      throw error;
    }
  }

  async setupAutomatedScaling(clusterId, scalingConfig) {
    console.log(`Setting up automated scaling for cluster: ${clusterId}`);

    try {
      const scalingConfiguration = {
        clusterId: clusterId,

        // Compute scaling configuration
        computeScaling: {
          enabled: scalingConfig.computeScaling !== false,
          scaleDownEnabled: scalingConfig.scaleDownEnabled !== false,

          // Instance size limits
          minInstanceSize: scalingConfig.minInstanceSize || 'M10',
          maxInstanceSize: scalingConfig.maxInstanceSize || 'M80',

          // Scaling triggers
          targetCPUUtilization: scalingConfig.targetCPUUtilization || 75,
          targetMemoryUtilization: scalingConfig.targetMemoryUtilization || 80,

          // Scaling behavior
          scaleUpPolicy: {
            cooldownMinutes: scalingConfig.scaleUpCooldown || 15,
            incrementPercent: scalingConfig.scaleUpIncrement || 100,
            units: 'INSTANCE_SIZE'
          },
          scaleDownPolicy: {
            cooldownMinutes: scalingConfig.scaleDownCooldown || 30,
            decrementPercent: scalingConfig.scaleDownDecrement || 50,
            units: 'INSTANCE_SIZE'
          }
        },

        // Storage scaling configuration
        storageScaling: {
          enabled: scalingConfig.storageScaling !== false,

          // Storage scaling triggers
          targetStorageUtilization: scalingConfig.targetStorageUtilization || 85,
          incrementGigabytes: scalingConfig.storageIncrement || 10,
          maxStorageGigabytes: scalingConfig.maxStorage || 4096
        },

        // Advanced scaling features
        advancedScaling: {
          enablePredictiveScaling: scalingConfig.enablePredictiveScaling || false,
          enableScheduledScaling: scalingConfig.enableScheduledScaling || false,
          scheduledScalingEvents: scalingConfig.scheduledScalingEvents || []
        }
      };

      // Configure compute auto-scaling
      if (scalingConfiguration.computeScaling.enabled) {
        await this.configureComputeScaling(clusterId, scalingConfiguration.computeScaling);
      }

      // Configure storage auto-scaling
      if (scalingConfiguration.storageScaling.enabled) {
        await this.configureStorageScaling(clusterId, scalingConfiguration.storageScaling);
      }

      // Store scaling configuration
      this.scalingOperations.set(clusterId, scalingConfiguration);

      return {
        success: true,
        clusterId: clusterId,
        scalingConfiguration: scalingConfiguration
      };

    } catch (error) {
      console.error(`Error setting up automated scaling for cluster ${clusterId}:`, error);
      return {
        success: false,
        error: error.message,
        clusterId: clusterId
      };
    }
  }

  async setupAdvancedMonitoring(clusterId, monitoringConfig = {}) {
    console.log(`Setting up advanced monitoring for cluster: ${clusterId}`);

    try {
      const monitoringConfiguration = {
        clusterId: clusterId,

        // Performance monitoring
        performanceMonitoring: {
          enabled: monitoringConfig.performanceMonitoring !== false,

          // Metrics collection
          collectDetailedMetrics: true,
          metricsRetentionDays: monitoringConfig.metricsRetentionDays || 30,

          // Performance insights
          enableSlowQueryAnalysis: true,
          enableIndexSuggestions: true,
          enableQueryOptimization: true,

          // Real-time monitoring
          enableRealTimeAlerts: true,
          alertLatencyThresholds: {
            warning: monitoringConfig.warningLatency || 1000,
            critical: monitoringConfig.criticalLatency || 5000
          }
        },

        // Infrastructure monitoring
        infrastructureMonitoring: {
          enabled: monitoringConfig.infrastructureMonitoring !== false,

          // Resource monitoring
          monitorCPUUtilization: true,
          monitorMemoryUtilization: true,
          monitorStorageUtilization: true,
          monitorNetworkUtilization: true,

          // Capacity planning
          enableCapacityForecasting: true,
          forecastingHorizonDays: monitoringConfig.forecastingHorizon || 30,

          // Health checks
          enableHealthChecks: true,
          healthCheckIntervalMinutes: monitoringConfig.healthCheckInterval || 5
        },

        // Application monitoring
        applicationMonitoring: {
          enabled: monitoringConfig.applicationMonitoring !== false,

          // Connection monitoring
          monitorConnectionUsage: true,
          connectionPoolAnalysis: true,

          // Query monitoring
          slowQueryThresholdMs: monitoringConfig.slowQueryThreshold || 1000,
          enableQueryProfiling: true,
          profileSampleRate: monitoringConfig.profileSampleRate || 0.1,

          // Error monitoring
          enableErrorTracking: true,
          errorAlertThreshold: monitoringConfig.errorAlertThreshold || 10
        },

        // Security monitoring
        securityMonitoring: {
          enabled: this.atlasConfig.enableAdvancedSecurity,

          // Access monitoring
          monitorDatabaseAccess: true,
          unusualAccessAlerts: true,

          // Authentication monitoring
          authenticationFailureAlerts: true,
          multipleFailedAttemptsThreshold: 5,

          // Data access monitoring
          sensitiveDataAccessMonitoring: true,
          dataExportMonitoring: true
        }
      };

      // Setup performance monitoring
      if (monitoringConfiguration.performanceMonitoring.enabled) {
        await this.configurePerformanceMonitoring(clusterId, monitoringConfiguration.performanceMonitoring);
      }

      // Setup infrastructure monitoring
      if (monitoringConfiguration.infrastructureMonitoring.enabled) {
        await this.configureInfrastructureMonitoring(clusterId, monitoringConfiguration.infrastructureMonitoring);
      }

      // Setup application monitoring
      if (monitoringConfiguration.applicationMonitoring.enabled) {
        await this.configureApplicationMonitoring(clusterId, monitoringConfiguration.applicationMonitoring);
      }

      // Setup security monitoring
      if (monitoringConfiguration.securityMonitoring.enabled) {
        await this.configureSecurityMonitoring(clusterId, monitoringConfiguration.securityMonitoring);
      }

      // Store monitoring configuration
      this.monitoringAlerts.set(clusterId, monitoringConfiguration);

      return {
        success: true,
        clusterId: clusterId,
        monitoringConfiguration: monitoringConfiguration
      };

    } catch (error) {
      console.error(`Error setting up monitoring for cluster ${clusterId}:`, error);
      return {
        success: false,
        error: error.message,
        clusterId: clusterId
      };
    }
  }

  async setupInfrastructureAsCode(templateConfig = {}) {
    console.log('Setting up infrastructure-as-code integration...');

    try {
      const infrastructureTemplate = {
        templateId: this.generateTemplateId(),
        templateName: templateConfig.name || 'mongodb-atlas-infrastructure',
        templateType: templateConfig.type || 'terraform',

        // Template configuration
        templateConfiguration: {
          // Provider configuration
          provider: templateConfig.provider || 'terraform',
          version: templateConfig.version || '1.0',

          // Atlas provider settings
          atlasProvider: {
            publicKey: '${var.atlas_public_key}',
            privateKey: '${var.atlas_private_key}',
            baseURL: this.atlasConfig.baseURL
          },

          // Infrastructure resources
          resources: {
            // Project resource
            project: {
              name: '${var.project_name}',
              orgId: this.atlasConfig.organizationId,

              // Project configuration
              isCollectingBugs: false,
              isDataExplorerEnabled: true,
              isPerformanceAdvisorEnabled: true,
              isRealtimePerformancePanelEnabled: true,
              isSchemaAdvisorEnabled: true
            },

            // Cluster resources
            clusters: templateConfig.clusters || [],

            // Database user resources
            databaseUsers: templateConfig.databaseUsers || [],

            // Network access rules
            networkAccessList: templateConfig.networkAccessList || [],

            // Alert configurations
            alertConfigurations: templateConfig.alertConfigurations || []
          },

          // Variables
          variables: {
            atlas_public_key: {
              description: 'MongoDB Atlas API Public Key',
              type: 'string',
              sensitive: false
            },
            atlas_private_key: {
              description: 'MongoDB Atlas API Private Key',
              type: 'string',
              sensitive: true
            },
            project_name: {
              description: 'Atlas Project Name',
              type: 'string',
              default: 'default-project'
            },
            environment: {
              description: 'Deployment Environment',
              type: 'string',
              default: 'development'
            }
          },

          // Outputs
          outputs: {
            cluster_connection_strings: {
              description: 'Atlas Cluster Connection Strings',
              value: '${tomap({ for k, cluster in mongodbatlas_cluster.clusters : k => cluster.connection_strings[0].standard_srv })}'
            },
            cluster_ids: {
              description: 'Atlas Cluster IDs',
              value: '${tomap({ for k, cluster in mongodbatlas_cluster.clusters : k => cluster.cluster_id })}'
            },
            project_id: {
              description: 'Atlas Project ID',
              value: '${mongodbatlas_project.project.id}'
            }
          }
        },

        // CI/CD integration
        cicdIntegration: {
          enabled: templateConfig.cicdIntegration || false,

          // Pipeline configuration
          pipeline: {
            stages: ['validate', 'plan', 'apply'],
            approvalRequired: templateConfig.requireApproval !== false,

            // Environment promotion
            environments: ['development', 'staging', 'production'],
            promotionStrategy: templateConfig.promotionStrategy || 'manual'
          },

          // Integration settings
          integrations: {
            github: templateConfig.githubIntegration || false,
            jenkins: templateConfig.jenkinsIntegration || false,
            gitlab: templateConfig.gitlabIntegration || false,
            azureDevOps: templateConfig.azureDevOpsIntegration || false
          }
        }
      };

      // Generate Terraform configuration
      const terraformConfig = this.generateTerraformConfig(infrastructureTemplate);

      // Generate CI/CD pipeline configuration
      const pipelineConfig = this.generatePipelineConfig(infrastructureTemplate);

      // Store template configuration
      this.infrastructureTemplates.set(infrastructureTemplate.templateId, infrastructureTemplate);

      return {
        success: true,
        templateId: infrastructureTemplate.templateId,
        templateConfiguration: infrastructureTemplate,
        terraformConfig: terraformConfig,
        pipelineConfig: pipelineConfig
      };

    } catch (error) {
      console.error('Error setting up infrastructure-as-code:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  async performCostOptimization(clusterId, optimizationOptions = {}) {
    console.log(`Performing cost optimization for cluster: ${clusterId}`);

    try {
      const cluster = this.clusters.get(clusterId);
      if (!cluster) {
        throw new Error(`Cluster not found: ${clusterId}`);
      }

      // Collect performance and utilization metrics
      const performanceMetrics = await this.collectPerformanceMetrics(clusterId);
      const utilizationMetrics = await this.collectUtilizationMetrics(clusterId);
      const costMetrics = await this.collectCostMetrics(clusterId);

      // Analyze optimization opportunities
      const optimizationAnalysis = {
        clusterId: clusterId,
        analysisTime: new Date(),

        // Performance analysis
        performanceAnalysis: {
          averageResponseTime: performanceMetrics.averageResponseTime,
          peakResponseTime: performanceMetrics.peakResponseTime,
          queryThroughput: performanceMetrics.queryThroughput,
          resourceBottlenecks: performanceMetrics.bottlenecks
        },

        // Utilization analysis
        utilizationAnalysis: {
          cpuUtilization: {
            average: utilizationMetrics.cpu.average,
            peak: utilizationMetrics.cpu.peak,
            recommendation: this.generateCPURecommendation(utilizationMetrics.cpu)
          },
          memoryUtilization: {
            average: utilizationMetrics.memory.average,
            peak: utilizationMetrics.memory.peak,
            recommendation: this.generateMemoryRecommendation(utilizationMetrics.memory)
          },
          storageUtilization: {
            used: utilizationMetrics.storage.used,
            available: utilizationMetrics.storage.available,
            growthRate: utilizationMetrics.storage.growthRate,
            recommendation: this.generateStorageRecommendation(utilizationMetrics.storage)
          }
        },

        // Cost analysis
        costAnalysis: {
          currentMonthlyCost: costMetrics.currentMonthlyCost,
          costTrends: costMetrics.trends,
          costBreakdown: costMetrics.breakdown,

          // Optimization opportunities
          optimizationOpportunities: []
        }
      };

      // Generate optimization recommendations
      const recommendations = this.generateOptimizationRecommendations(
        performanceMetrics,
        utilizationMetrics,
        costMetrics,
        optimizationOptions
      );

      optimizationAnalysis.recommendations = recommendations;

      // Calculate potential savings
      const savingsAnalysis = this.calculatePotentialSavings(recommendations, costMetrics);
      optimizationAnalysis.savingsAnalysis = savingsAnalysis;

      // Apply optimizations if auto-optimization is enabled
      if (optimizationOptions.autoOptimize) {
        const optimizationResults = await this.applyOptimizations(clusterId, recommendations);
        optimizationAnalysis.optimizationResults = optimizationResults;
      }

      return {
        success: true,
        clusterId: clusterId,
        optimizationAnalysis: optimizationAnalysis
      };

    } catch (error) {
      console.error(`Error performing cost optimization for cluster ${clusterId}:`, error);
      return {
        success: false,
        error: error.message,
        clusterId: clusterId
      };
    }
  }

  // Utility methods for Atlas operations

  async atlasAPIRequest(method, endpoint, data = null) {
    const url = `${this.atlasConfig.baseURL}${endpoint}`;
    const auth = Buffer.from(`${this.atlasConfig.publicKey}:${this.atlasConfig.privateKey}`).toString('base64');

    try {
      const config = {
        method: method,
        url: url,
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Basic ${auth}`
        }
      };

      if (data) {
        config.data = data;
      }

      const response = await axios(config);
      return response.data;

    } catch (error) {
      console.error(`Atlas API request failed: ${method} ${endpoint}`, error);
      throw error;
    }
  }

  async validateAtlasCredentials() {
    try {
      await this.atlasAPIRequest('GET', '/orgs');
      console.log('Atlas API credentials validated successfully');
    } catch (error) {
      throw new Error('Invalid Atlas API credentials');
    }
  }

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

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

  async waitForClusterReady(clusterId, timeoutMinutes = 30) {
    const timeout = timeoutMinutes * 60 * 1000;
    const startTime = Date.now();

    while (Date.now() - startTime < timeout) {
      try {
        const clusterStatus = await this.atlasAPIRequest('GET', `/groups/${this.atlasConfig.projectId}/clusters/${clusterId}`);

        if (clusterStatus.stateName === 'IDLE') {
          return {
            clusterId: clusterId,
            state: clusterStatus.stateName,
            connectionString: clusterStatus.connectionStrings?.standardSrv,
            mongoDBVersion: clusterStatus.mongoDBVersion
          };
        }

        console.log(`Waiting for cluster ${clusterId} to be ready. Current state: ${clusterStatus.stateName}`);
        await this.sleep(30000); // Wait 30 seconds

      } catch (error) {
        console.error(`Error checking cluster status: ${clusterId}`, error);
        await this.sleep(30000);
      }
    }

    throw new Error(`Cluster ${clusterId} did not become ready within ${timeoutMinutes} minutes`);
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  updateInfrastructureMetrics(deployment) {
    this.performanceMetrics.totalClusters++;
    // Update other metrics based on deployment
  }

  generateTerraformConfig(infrastructureTemplate) {
    // Generate Terraform configuration files based on template
    return {
      mainTf: `# MongoDB Atlas Infrastructure Configuration
provider "mongodbatlas" {
  public_key  = var.atlas_public_key
  private_key = var.atlas_private_key
}

# Variables and resources would be generated here based on template
`,
      variablesTf: `# Infrastructure variables
variable "atlas_public_key" {
  description = "MongoDB Atlas API Public Key"
  type        = string
}

variable "atlas_private_key" {
  description = "MongoDB Atlas API Private Key"
  type        = string
  sensitive   = true
}
`,
      outputsTf: `# Infrastructure outputs
output "cluster_connection_strings" {
  description = "Atlas Cluster Connection Strings"
  value       = mongodbatlas_cluster.main.connection_strings
}
`
    };
  }

  generatePipelineConfig(infrastructureTemplate) {
    // Generate CI/CD pipeline configuration
    return {
      githubActions: `# GitHub Actions workflow for Atlas infrastructure
name: MongoDB Atlas Infrastructure Deployment

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  terraform:
    name: Terraform
    runs-on: ubuntu-latest

    steps:
    - name: Checkout
      uses: actions/checkout@v2

    - name: Setup Terraform
      uses: hashicorp/setup-terraform@v1

    - name: Terraform Plan
      run: terraform plan

    - name: Terraform Apply
      if: github.ref == 'refs/heads/main'
      run: terraform apply -auto-approve
`,
      jenkins: `// Jenkins pipeline for Atlas infrastructure
pipeline {
    agent any

    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }

        stage('Terraform Plan') {
            steps {
                sh 'terraform plan -out=tfplan'
            }
        }

        stage('Terraform Apply') {
            when {
                branch 'main'
            }
            steps {
                sh 'terraform apply tfplan'
            }
        }
    }
}
`
    };
  }

  // Additional methods would include implementations for:
  // - setupAutomatedDeployment()
  // - setupCICDIntegration()
  // - configureNetworkSecurity()
  // - createDatabaseUsers()
  // - configureComputeScaling()
  // - configureStorageScaling()
  // - configurePerformanceMonitoring()
  // - configureInfrastructureMonitoring()
  // - configureApplicationMonitoring()
  // - configureSecurityMonitoring()
  // - collectPerformanceMetrics()
  // - collectUtilizationMetrics()
  // - collectCostMetrics()
  // - generateOptimizationRecommendations()
  // - calculatePotentialSavings()
  // - applyOptimizations()
}

// Benefits of MongoDB Atlas Advanced Infrastructure Management:
// - Automated deployment with infrastructure-as-code integration
// - Intelligent auto-scaling based on real-time metrics and predictions
// - Comprehensive monitoring and alerting for proactive management
// - Advanced security and compliance features built-in
// - DevOps pipeline integration for continuous deployment
// - Cost optimization with automated resource right-sizing
// - Enterprise-grade backup and disaster recovery capabilities
// - Multi-cloud deployment and management capabilities
// - SQL-compatible operations through QueryLeaf integration
// - Production-ready infrastructure automation and orchestration

module.exports = {
  AdvancedAtlasInfrastructureManager
};