interface TaggingPolicy {
  required: string[];      // Tags that must be present
  allowed: string[];       // Permitted tag values
  enforcement: "strict" | "advisory";
}
 
const defaultPolicy: TaggingPolicy = {
  required: ["team", "environment", "project", "cost-center"],
  allowed: [],
  enforcement: "strict",
};
 
// AWS tag enforcement via SCP (Service Control Policy)
const scpPolicy = {
  Version: "2012-10-17",
  Statement: [
    {
      Effect: "Deny",
      Action: ["ec2:RunInstances", "rds:CreateDBInstance"],
      Resource: "*",
      Condition: {
        Null: {
          "aws:RequestTag/team": "true",
          "aws:RequestTag/environment": "true",
        },
      },
    },
  ],
};

interface ResourceMetrics {
  resourceId: string;
  resourceType: string;
  instanceType: string;
  cpuUtilization: number[];    // Hourly samples over 14 days
  memoryUtilization: number[];
  networkIO: number[];
  currentCost: number;         // Monthly cost
}
 
interface RightSizeRecommendation {
  resourceId: string;
  currentType: string;
  recommendedType: string;
  currentCost: number;
  recommendedCost: number;
  savings: number;
  savingsPercent: number;
  confidence: "high" | "medium" | "low";
  reason: string;
}
 
class RightSizer {
  analyze(metrics: ResourceMetrics): RightSizeRecommendation | null {
    const avgCpu = this.average(metrics.cpuUtilization);
    const p95Cpu = this.percentile(metrics.cpuUtilization, 95);
    const avgMemory = this.average(metrics.memoryUtilization);
    const p95Memory = this.percentile(metrics.memoryUtilization, 95);
 
    // Only recommend if consistently underutilized
    if (p95Cpu > 60 || p95Memory > 70) return null;
 
    const recommendedType = this.findOptimalType(
      p95Cpu,
      p95Memory,
      metrics.instanceType
    );
 
    if (!recommendedType || recommendedType === metrics.instanceType) return null;
 
    const currentCost = metrics.currentCost;
    const recommendedCost = this.estimateCost(recommendedType);
 
    return {
      resourceId: metrics.resourceId,
      currentType: metrics.instanceType,
      recommendedType,
      currentCost,
      recommendedCost,
      savings: currentCost - recommendedCost,
      savingsPercent: ((currentCost - recommendedCost) / currentCost) * 100,
      confidence: p95Cpu < 30 && p95Memory < 40 ? "high" : "medium",
      reason: `CPU p95: ${p95Cpu.toFixed(1)}%, Memory p95: ${p95Memory.toFixed(1)}%`,
    };
  }
 
  private average(values: number[]): number {
    return values.reduce((a, b) => a + b, 0) / values.length;
  }
 
  private percentile(values: number[], p: number): number {
    const sorted = [...values].sort((a, b) => a - b);
    const index = Math.ceil((p / 100) * sorted.length) - 1;
    return sorted[index];
  }
 
  private findOptimalType(cpuP95: number, memoryP95: number, currentType: string): string | null {
    // Simplified — in practice, query the cloud provider's instance type API
    const instanceTypes = [
      { type: "t3.micro", cpu: 2, memory: 1, cost: 8 },
      { type: "t3.small", cpu: 2, memory: 2, cost: 16 },
      { type: "t3.medium", cpu: 2, memory: 4, cost: 30 },
      { type: "t3.large", cpu: 2, memory: 8, cost: 60 },
      { type: "t3.xlarge", cpu: 4, memory: 16, cost: 120 },
      { type: "t3.2xlarge", cpu: 8, memory: 32, cost: 240 },
    ];
 
    // Find smallest instance that can handle the workload
    const needed = instanceTypes.find(
      (t) => t.cpu >= cpuP95 / 100 * 8 && t.memory >= memoryP95 / 100 * 32
    );
 
    return needed?.type ?? null;
  }
 
  private estimateCost(instanceType: string): number {
    // Simplified pricing lookup
    const pricing: Record<string, number> = {
      "t3.micro": 8, "t3.small": 16, "t3.medium": 30,
      "t3.large": 60, "t3.xlarge": 120, "t3.2xlarge": 240,
    };
    return pricing[instanceType] ?? 0;
  }
}

class SpotInstanceManager {
  private spotFleet: SpotFleetConfig;
  private interruptionHandler: InterruptionHandler;
 
  constructor(config: SpotFleetConfig) {
    this.spotFleet = config;
    this.interruptionHandler = new InterruptionHandler();
  }
 
  async createSpotFleet(): Promise<string> {
    // Diversify across instance types and availability zones
    const launchSpecifications = this.spotFleet.instanceTypes.flatMap((type) =>
      this.spotFleet.availabilityZones.map((az) => ({
        InstanceType: type,
        AvailabilityZone: az,
        ImageId: this.spotFleet.amiId,
        KeyName: this.spotFleet.keyName,
        SecurityGroups: this.spotFleet.securityGroups,
        UserData: Buffer.from(this.spotFleet.userData).toString("base64"),
      }))
    );
 
    // AWS API call to create spot fleet
    const fleetId = await this.awsCreateSpotFleet({
      IamFleetRole: this.spotFleet.fleetRole,
      TargetCapacity: this.spotFleet.targetCapacity,
      AllocationStrategy: "capacityOptimized", // Prefer capacity over price
      LaunchSpecifications: launchSpecifications,
      ReplaceUnhealthyInstances: true,
      TerminateInstancesWithExpiration: true,
    });
 
    return fleetId;
  }
 
  async handleInterruption(instanceId: string): Promise<void> {
    // 1. Drain connections from load balancer
    await this.drainFromLoadBalancer(instanceId);
 
    // 2. Save in-progress work
    await this.checkpointWork(instanceId);
 
    // 3. Terminate gracefully
    await this.terminateInstance(instanceId);
 
    // 4. Request replacement capacity
    await this.requestReplacement();
  }
 
  private async drainFromLoadBalancer(instanceId: string): Promise<void> {
    // Deregister instance and wait for in-flight requests to complete
  }
 
  private async checkpointWork(instanceId: string): Promise<void> {
    // Save state to S3 or database
  }
 
  private async terminateInstance(instanceId: string): Promise<void> {
    // Graceful shutdown
  }
 
  private async requestReplacement(): Promise<void> {
    // Increase target capacity to trigger new spot request
  }
}

class ResourceCleanup {
  private cloudClient: CloudClient;
 
  constructor(cloudClient: CloudClient) {
    this.cloudClient = cloudClient;
  }
 
  async findUnusedResources(): Promise<UnusedResource[]> {
    const resources: UnusedResource[] = [];
 
    // Unattached EBS volumes
    const volumes = await this.cloudClient.describeVolumes();
    for (const vol of volumes) {
      if (vol.Attachments.length === 0) {
        resources.push({
          type: "ebs-volume",
          id: vol.VolumeId,
          cost: this.estimateVolumeCost(vol),
          age: this.daysSince(vol.CreateTime),
        });
      }
    }
 
    // Unused Elastic IPs
    const eips = await this.cloudClient.describeAddresses();
    for (const eip of eips) {
      if (!eip.AssociationId) {
        resources.push({
          type: "elastic-ip",
          id: eip.AllocationId,
          cost: 3.60, // $0.005/hour × 730 hours
          age: 0,
        });
      }
    }
 
    // Old snapshots
    const snapshots = await this.cloudClient.describeSnapshots({ ownerIds: ["self"] });
    for (const snap of snapshots) {
      const age = this.daysSince(snap.StartTime);
      if (age > 90) {
        resources.push({
          type: "snapshot",
          id: snap.SnapshotId,
          cost: this.estimateSnapshotCost(snap),
          age,
        });
      }
    }
 
    // Idle load balancers (no traffic in 14 days)
    const lbs = await this.cloudClient.describeLoadBalancers();
    for (const lb of lbs) {
      const metrics = await this.cloudClient.getLBMetrics(lb.LoadBalancerArn, "14d");
      if (metrics.requestCount === 0) {
        resources.push({
          type: "load-balancer",
          id: lb.LoadBalancerArn,
          cost: this.estimateLBCost(lb),
          age: 0,
        });
      }
    }
 
    return resources;
  }
 
  async generateCleanupReport(): Promise<CleanupReport> {
    const unused = await this.findUnusedResources();
    const totalSavings = unused.reduce((sum, r) => sum + r.cost, 0);
 
    return {
      resources: unused,
      totalMonthlySavings: totalSavings,
      totalAnnualSavings: totalSavings * 12,
      generatedAt: new Date(),
    };
  }
 
  private daysSince(date: Date): number {
    return Math.floor((Date.now() - date.getTime()) / (1000 * 60 * 60 * 24));
  }
 
  private estimateVolumeCost(vol: any): number {
    const pricePerGB = vol.VolumeType === "gp3" ? 0.08 : 0.10;
    return vol.Size * pricePerGB;
  }
 
  private estimateSnapshotCost(snap: any): number {
    return snap.VolumeSize * 0.05; // $0.05/GB-month
  }
 
  private estimateLBCost(lb: any): number {
    return lb.Type === "application" ? 16.20 : 16.20; // Base cost
  }
}

class CostAnomalyDetector {
  private costData: CostDataPoint[];
  private threshold: number;
 
  constructor(costData: CostDataPoint[], threshold = 2.0) {
    this.costData = costData;
    this.threshold = threshold; // Standard deviations
  }
 
  detect(): CostAnomaly[] {
    const anomalies: CostAnomaly[] = [];
    const values = this.costData.map((d) => d.cost);
    const mean = values.reduce((a, b) => a + b, 0) / values.length;
    const stdDev = Math.sqrt(
      values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / values.length
    );
 
    for (const point of this.costData) {
      const zScore = (point.cost - mean) / stdDev;
      if (Math.abs(zScore) > this.threshold) {
        anomalies.push({
          date: point.date,
          cost: point.cost,
          expected: mean,
          deviation: zScore,
          severity: Math.abs(zScore) > 3 ? "critical" : "warning",
        });
      }
    }
 
    return anomalies;
  }
 
  async alert(anomalies: CostAnomaly[]): Promise<void> {
    for (const anomaly of anomalies) {
      const message = [
        `🚨 Cost Anomaly Detected`,
        `Date: ${anomaly.date}`,
        `Actual: $${anomaly.cost.toFixed(2)}`,
        `Expected: $${anomaly.expected.toFixed(2)}`,
        `Deviation: ${anomaly.deviation.toFixed(1)}σ`,
        `Severity: ${anomaly.severity}`,
      ].join("\n");
 
      await this.sendAlert(message);
    }
  }
}

class BudgetEnforcer {
  private budgets: Map<string, Budget> = new Map();
 
  setBudget(team: string, monthlyLimit: number, alerts: AlertThreshold[]): void {
    this.budgets.set(team, { team, monthlyLimit, alerts, currentSpend: 0 });
  }
 
  async checkAndUpdate(team: string, additionalCost: number): Promise<BudgetAction> {
    const budget = this.budgets.get(team);
    if (!budget) return { action: "allow" };
 
    budget.currentSpend += additionalCost;
    const percentUsed = (budget.currentSpend / budget.monthlyLimit) * 100;
 
    // Check alert thresholds
    for (const alert of budget.alerts) {
      if (percentUsed >= alert.threshold && !alert.triggered) {
        alert.triggered = true;
        await this.sendAlert(team, percentUsed, alert);
      }
    }
 
    // Enforce hard limit
    if (percentUsed >= 100) {
      return {
        action: "block",
        reason: `Team ${team} has exceeded monthly budget ($${budget.currentSpend.toFixed(2)} / $${budget.monthlyLimit})`,
      };
    }
 
    // Warn at 80%
    if (percentUsed >= 80) {
      return {
        action: "warn",
        reason: `Team ${team} at ${percentUsed.toFixed(1)}% of monthly budget`,
      };
    }
 
    return { action: "allow" };
  }
}

class CostDashboard {
  async generateReport(): Promise<CostReport> {
    const [currentMonth, previousMonth] = await Promise.all([
      this.getCostForPeriod("current-month"),
      this.getCostForPeriod("previous-month"),
    ]);
 
    const services = await this.getCostByService();
    const teams = await this.getCostByTeam();
    const recommendations = await this.getRecommendations();
 
    return {
      currentMonth: currentMonth.total,
      previousMonth: previousMonth.total,
      change: ((currentMonth.total - previousMonth.total) / previousMonth.total) * 100,
      projectedAnnual: currentMonth.total * 12,
      byService: services.sort((a, b) => b.cost - a.cost).slice(0, 10),
      byTeam: teams.sort((a, b) => b.cost - a.cost),
      recommendations: recommendations.sort((a, b) => b.savings - a.savings),
      totalPotentialSavings: recommendations.reduce((sum, r) => sum + r.savings, 0),
    };
  }
 
  private async getRecommendations(): Promise<CostRecommendation[]> {
    const recommendations: CostRecommendation[] = [];
 
    // Right-sizing recommendations
    const rightSizer = new RightSizer();
    const resources = await this.getResourceMetrics();
    for (const resource of resources) {
      const rec = rightSizer.analyze(resource);
      if (rec) recommendations.push(rec);
    }
 
    // Unused resource cleanup
    const cleanup = new ResourceCleanup(this.cloudClient);
    const unused = await cleanup.findUnusedResources();
    for (const resource of unused) {
      recommendations.push({
        type: "cleanup",
        resource: resource.id,
        savings: resource.cost,
        action: `Delete unused ${resource.type}`,
      });
    }
 
    // Reserved instance recommendations
    const riRecs = await this.analyzeReservedInstanceOpportunities();
    recommendations.push(...riRecs);
 
    return recommendations;
  }
}

class EnvironmentScheduler {
  async scheduleShutdown(environment: string, startHour: number, endHour: number): Promise<void> {
    // Lambda function triggered by CloudWatch Events
    const now = new Date();
    const hour = now.getHours();
 
    if (hour < startHour || hour >= endHour) {
      await this.stopEnvironment(environment);
      console.log(`Stopped ${environment} at ${now.toISOString()}`);
    } else {
      await this.startEnvironment(environment);
      console.log(`Started ${environment} at ${now.toISOString()}`);
    }
  }
 
  // Typical schedule: stop at 8 PM, start at 7 AM
  // Savings: 13 hours/day × 30 days = 390 hours/month
  // On a $500/month instance: saves ~$265/month (53%)
}

class MultiCloudCostComparison {
  async compare(resourceSpec: ResourceSpec): Promise<CloudComparison> {
    const [aws, gcp, azure] = await Promise.all([
      this.getPriceAWS(resourceSpec),
      this.getPriceGCP(resourceSpec),
      this.getPriceAzure(resourceSpec),
    ]);
 
    return {
      aws: { monthly: aws.monthly, annual: aws.monthly * 12 },
      gcp: { monthly: gcp.monthly, annual: gcp.monthly * 12 },
      azure: { monthly: azure.monthly, annual: azure.monthly * 12 },
      cheapest: this.findCheapest(aws, gcp, azure),
      potentialSavings: this.calculateSavings(aws, gcp, azure),
    };
  }
}

async function investigateCostSpike(
  startDate: Date,
  endDate: Date
): Promise<CostInvestigation> {
  // 1. Get cost breakdown by service
  const byService = await getCostByService(startDate, endDate);
 
  // 2. Find the service with the largest increase
  const previousPeriod = await getCostByService(
    new Date(startDate.getTime() - (endDate.getTime() - startDate.getTime())),
    startDate
  );
 
  const increases = byService.map((current) => {
    const previous = previousPeriod.find((p) => p.service === current.service);
    return {
      service: current.service,
      current: current.cost,
      previous: previous?.cost ?? 0,
      change: current.cost - (previous?.cost ?? 0),
    };
  }).sort((a, b) => b.change - a.change);
 
  // 3. Drill into the highest increase
  const topIncrease = increases[0];
  const resources = await getResourcesByService(topIncrease.service, startDate, endDate);
 
  return {
    period: { startDate, endDate },
    topIncreases: increases.slice(0, 5),
    details: resources,
    recommendation: generateRecommendation(increases, resources),
  };
}

class CostAwareAutoScaler {
  async calculateOptimalCapacity(
    currentDemand: number,
    costConstraints: CostConstraints
  ): Promise<ScalingDecision> {
    // Calculate minimum capacity needed
    const minCapacity = Math.ceil(currentDemand * 1.1); // 10% headroom
 
    // Calculate maximum capacity within budget
    const spotPrice = await this.getSpotPrice();
    const onDemandPrice = await this.getOnDemandPrice();
    const maxSpotCapacity = Math.floor(costConstraints.spotBudget / spotPrice);
    const maxOnDemandCapacity = Math.floor(costConstraints.onDemandBudget / onDemandPrice);
 
    // Prefer spot instances, fall back to on-demand
    const spotCapacity = Math.min(minCapacity, maxSpotCapacity);
    const onDemandCapacity = Math.max(0, minCapacity - spotCapacity);
 
    return {
      spotInstances: spotCapacity,
      onDemandInstances: onDemandCapacity,
      totalCapacity: spotCapacity + onDemandCapacity,
      estimatedCost: spotCapacity * spotPrice + onDemandCapacity * onDemandPrice,
    };
  }
}

class CostGovernance {
  private policies: GovernancePolicy[] = [];
 
  addPolicy(policy: GovernancePolicy): void {
    this.policies.push(policy);
  }
 
  async enforce(): Promise<EnforcementReport> {
    const violations: Violation[] = [];
 
    for (const policy of this.policies) {
      const resources = await this.getResources(policy.scope);
      for (const resource of resources) {
        const violation = await this.evaluatePolicy(policy, resource);
        if (violation) {
          violations.push(violation);
          await this.remediate(violation);
        }
      }
    }
 
    return { violations, remediated: violations.filter((v) => v.remediated).length };
  }
 
  private async evaluatePolicy(
    policy: GovernancePolicy,
    resource: any
  ): Promise<Violation | null> {
    switch (policy.type) {
      case "max-instance-size":
        return this.checkMaxInstanceSize(policy, resource);
      case "required-tags":
        return this.checkRequiredTags(policy, resource);
      case "max-monthly-cost":
        return this.checkMaxMonthlyCost(policy, resource);
      case "auto-shutdown":
        return this.checkAutoShutdown(policy, resource);
      default:
        return null;
    }
  }
 
  private async remediate(violation: Violation): Promise<void> {
    switch (violation.remediation) {
      case "stop":
        await this.stopResource(violation.resourceId);
        break;
      case "downsize":
        await this.downsizeResource(violation.resourceId);
        break;
      case "notify":
        await this.notifyTeam(violation);
        break;
    }
    violation.remediated = true;
  }
}

class CommitmentManager {
  async analyzeCommitmentOpportunities(): Promise<CommitmentRecommendation[]> {
    const recommendations: CommitmentRecommendation[] = [];
 
    // Analyze 30-day usage patterns
    const usage = await this.getUsagePatterns(30);
 
    for (const pattern of usage) {
      if (pattern.utilizationPercent > 70 && pattern.consistency > 0.8) {
        // Recommend reserved instance
        const riPricing = await this.getReservedPricing(
          pattern.instanceType,
          pattern.region,
          "1year"
        );
        const savings = pattern.onDemandCost - riPricing.upfront / 12 - riPricing.hourly * 730;
 
        recommendations.push({
          type: "reserved-instance",
          resource: pattern.instanceType,
          region: pattern.region,
          commitment: "1year",
          upfrontCost: riPricing.upfront,
          monthlySavings: savings,
          annualSavings: savings * 12,
          breakEvenMonths: riPricing.upfront / savings,
          confidence: pattern.consistency > 0.9 ? "high" : "medium",
        });
      } else if (pattern.utilizationPercent > 40) {
        // Recommend savings plan
        recommendations.push({
          type: "savings-plan",
          resource: pattern.service,
          commitment: "1year",
          monthlySavings: pattern.onDemandCost * 0.3,
          annualSavings: pattern.onDemandCost * 0.3 * 12,
          confidence: "medium",
        });
      }
    }
 
    return recommendations.sort((a, b) => b.annualSavings - a.annualSavings);
  }
}

import { test, expect } from "bun:test";
 
test("deployment does not increase infrastructure cost", async () => {
  const costBefore = await getInfrastructureCost("last-7-days");
  await deployNewVersion();
  await Bun.sleep(7 * 24 * 60 * 60 * 1000); // Wait 7 days
  const costAfter = await getInfrastructureCost("last-7-days");
 
  const changePercent = ((costAfter - costBefore) / costBefore) * 100;
  expect(changePercent).toBeLessThan(5); // Max 5% increase allowed
});
 
test("new feature does not exceed cost budget", async () => {
  const estimatedCost = await estimateFeatureCost("new-analytics-dashboard");
  expect(estimatedCost.monthly).toBeLessThan(500); // $500/month budget
});