// Horizontal vs. Vertical Scaling Strategies

class ScalingManager {
  constructor() {
    this.instances = [];
    this.currentInstanceType = 't3.medium';
  }

  // Vertical Scaling: Scale up existing instance
  async scaleVertically(newInstanceType) {
    console.log(`Scaling from ${this.currentInstanceType} to ${newInstanceType}`);

    // Check if new instance type is larger
    if (!this.isLargerInstance(newInstanceType, this.currentInstanceType)) {
      throw new Error('New instance must be larger');
    }

    // Scale up (process varies by cloud provider)
    await this.resizeInstance(newInstanceType);
    this.currentInstanceType = newInstanceType;

    return {
      oldType: this.currentInstanceType,
      newType: newInstanceType,
      action: 'vertical_scale'
    };
  }

  // Horizontal Scaling: Add more instances
  async scaleHorizontally(targetCount) {
    const currentCount = this.instances.length;

    if (targetCount > currentCount) {
      // Scale out: add instances
      const instancesToAdd = targetCount - currentCount;
      for (let i = 0; i < instancesToAdd; i++) {
        const instance = await this.launchInstance(this.currentInstanceType);
        this.instances.push(instance);
      }
    } else if (targetCount < currentCount) {
      // Scale in: remove instances
      const instancesToRemove = currentCount - targetCount;
      for (let i = 0; i < instancesToRemove; i++) {
        const instance = this.instances.pop();
        await this.terminateInstance(instance);
      }
    }

    return {
      oldCount: currentCount,
      newCount: this.instances.length,
      action: 'horizontal_scale'
    };
  }

  // Auto-scaling: Automatic horizontal scaling based on metrics
  async autoScale(metrics) {
    const cpuUtilization = metrics.cpu;
    const memoryUtilization = metrics.memory;

    // Scaling policies
    if (cpuUtilization > 70 || memoryUtilization > 80) {
      // Scale out
      const targetCount = Math.ceil(this.instances.length * 1.5);
      return await this.scaleHorizontally(targetCount);
    } else if (cpuUtilization < 30 && memoryUtilization < 40 && this.instances.length > 1) {
      // Scale in (but keep minimum 1 instance)
      const targetCount = Math.max(1, Math.floor(this.instances.length * 0.7));
      return await this.scaleHorizontally(targetCount);
    }

    return { action: 'no_change' };
  }

  // Hybrid approach: Vertical scaling within instance family, horizontal across instances
  async hybridScale(currentLoad) {
    // First try vertical scaling (simpler)
    const nextInstanceType = this.getNextLargerInstance(this.currentInstanceType);
    if (nextInstanceType && currentLoad < 0.8) {
      return await this.scaleVertically(nextInstanceType);
    }

    // If vertical scaling insufficient or maxed out, scale horizontally
    const additionalInstances = Math.ceil(currentLoad * 2);
    return await this.scaleHorizontally(this.instances.length + additionalInstances);
  }

  isLargerInstance(newType, currentType) {
    const instanceHierarchy = [
      't3.nano', 't3.micro', 't3.small', 't3.medium',
      't3.large', 't3.xlarge', 't3.2xlarge', 'm5.large',
      'm5.xlarge', 'm5.2xlarge', 'm5.4xlarge'
    ];
    return instanceHierarchy.indexOf(newType) > instanceHierarchy.indexOf(currentType);
  }
}

// Kubernetes Resource Management (for easy vertical scaling)
const k8sDeployment = {
  apiVersion: 'apps/v1',
  kind: 'Deployment',
  metadata: { name: 'app-deployment' },
  spec: {
    replicas: 3, // Horizontal scaling
    template: {
      spec: {
        containers: [{
          name: 'app',
          image: 'app:latest',
          resources: {
            requests: {
              cpu: '500m',   // Vertical scaling
              memory: '512Mi'
            },
            limits: {
              cpu: '1000m',  // Vertical scaling limits
              memory: '1Gi'
            }
          }
        }]
      }
    }
  }
};