package main

import (
    "context"
    "fmt"
    "math"
    "sort"
    "sync"
    "time"
)

type AcceleratorType int
const (
    TPUv8t AcceleratorType = iota
    TPUv8i
    NVidiaVeraRubin
)
func (a AcceleratorType) String() string {
    return [...]string{"TPUv8t", "TPUv8i", "NVidiaVeraRubin"}[a]
}

type Accelerator struct {
    ID        string
    Type      AcceleratorType
    FLOPSFP8  float64
    MemoryGB  int
    PowerW    int
    Region    string
    Available bool
    CostPerHr float64
}

type VirgoCluster struct {
    mu           sync.RWMutex
    accelerators []Accelerator
    regions      []string
    interRegionBW map[string]map[string]float64
}

func NewVirgoCluster() *VirgoCluster {
    vc := &VirgoCluster{
        accelerators: make([]Accelerator, 0),
        regions:      []string{"us-central1", "us-east4", "europe-west4", "asia-east1"},
        interRegionBW: make(map[string]map[string]float64),
    }
    for _, r1 := range vc.regions {
        vc.interRegionBW[r1] = make(map[string]float64)
        for _, r2 := range vc.regions {
            if r1 == r2 {
                vc.interRegionBW[r1][r2] = 10000
            } else {
                vc.interRegionBW[r1][r2] = 1000
            }
        }
    }
    return vc
}

func (vc *VirgoCluster) AddAccelerators(accs []Accelerator) {
    vc.mu.Lock()
    defer vc.mu.Unlock()
    vc.accelerators = append(vc.accelerators, accs...)
}

type TrainingJob struct {
    ID              string
    Name            string
    RequiredFLOPS   float64
    RequiredMemoryGB int
    Parallelism     int
    Duration        time.Duration
    DataLocality    string
    Priority        int
}

type ScheduleResult struct {
    JobID        string
    Region       string
    Accelerators []string
    TotalFLOPS   float64
    EstimatedCost float64
    LatencyMs    float64
}

func (vc *VirgoCluster) ScheduleVirgoTraining(ctx context.Context, jobs []TrainingJob) []ScheduleResult {
    vc.mu.RLock()
    defer vc.mu.RUnlock()

    sort.Slice(jobs, func(i, j int) bool {
        return jobs[i].Priority > jobs[j].Priority
    })

    results := make([]ScheduleResult, 0)
    available := make([]Accelerator, len(vc.accelerators))
    copy(available, vc.accelerators)

    for _, job := range jobs {
        select {
        case <-ctx.Done():
            return results
        default:
        }

        accsPerJob := int(math.Ceil(job.RequiredFLOPS / 1000.0))
        if accsPerJob < 1 {
            accsPerJob = 1
        }

        bestRegion := job.DataLocality
        regionAccs := filterByRegion(available, bestRegion)

        if len(regionAccs) < accsPerJob {
            for _, region := range vc.regions {
                if region == bestRegion { continue }
                extra := filterByRegion(available, region)
                regionAccs = append(regionAccs, extra...)
                if len(regionAccs) >= accsPerJob { break }
            }
        }

        if len(regionAccs) < accsPerJob { continue }

        assigned := regionAccs[:accsPerJob]
        totalFLOPS := 0.0
        totalCost := 0.0
        accIDs := make([]string, accsPerJob)
        for i, acc := range assigned {
            totalFLOPS += acc.FLOPSFP8
            totalCost += acc.CostPerHr * job.Duration.Hours()
            accIDs[i] = acc.ID
            for j := range available {
                if available[j].ID == acc.ID {
                    available[j].Available = false
                    break
                }
            }
        }

        latencyMs := 0.0
        for _, acc := range assigned {
            if acc.Region != job.DataLocality {
                latencyMs += 50.0
            }
        }

        results = append(results, ScheduleResult{
            JobID: job.ID, Region: bestRegion,
            Accelerators: accIDs, TotalFLOPS: totalFLOPS,
            EstimatedCost: totalCost, LatencyMs: latencyMs,
        })
    }
    return results
}

func filterByRegion(accs []Accelerator, region string) []Accelerator {
    result := make([]Accelerator, 0)
    for _, acc := range accs {
        if acc.Region == region && acc.Available {
            result = append(result, acc)
        }
    }
    return result
}

// Python implementation for real-time monitoring

import numpy as np
import asyncio
from dataclasses import dataclass
from typing import List, Dict, Optional
from collections import defaultdict
import time

@dataclass
class VirgoMetrics:
    total_utilization: float
    region_utilization: Dict[str, float]
    avg_latency: float
    throughput: float  # Tbps
    active_jobs: int
    queued_jobs: int

class VirgoMonitor:
    """Real-time Virgo network monitoring"""
    
    def __init__(self, cluster_regions: List[str]):
        self.regions = cluster_regions
        self.metrics_history = defaultdict(list)
    
    async def sample_metrics(self, cluster_size: int, 
                            active_jobs: int) -> VirgoMetrics:
        """Sample current cluster metrics"""
        region_util = {}
        for region in self.regions:
            utilization = np.random.beta(7, 3)  # Simulate 70% avg utilization
            region_util[region] = min(utilization * 100, 100)
        
        metrics = VirgoMetrics(
            total_utilization=np.mean(list(region_util.values())),
            region_utilization=region_util,
            avg_latency=5.0 + np.random.exponential(2),
            throughput=800 + np.random.randn() * 50,
            active_jobs=active_jobs,
            queued_jobs=max(0, int(np.random.poisson(3)))
        )
        
        timestamp = time.time()
        self.metrics_history[timestamp] = metrics
        return metrics
    
    def get_anomaly_detection(self) -> List[str]:
        """Detect anomalies in Virgo network"""
        anomalies = []
        recent = list(self.metrics_history.values())[-10:]
        if len(recent) < 10:
            return anomalies
        
        avg_util = np.mean([m.total_utilization for m in recent])
        if avg_util > 95:
            anomalies.append("CRITICAL: Cluster utilization >95%, scale needed")
        elif avg_util > 85:
            anomalies.append("WARNING: Cluster utilization >85%, monitor closely")
        
        avg_latency = np.mean([m.avg_latency for m in recent])
        if avg_latency > 50:
            anomalies.append(f"WARNING: Avg latency {avg_latency:.1f}ms exceeds threshold")
        
        return anomalies

async def monitor_virgo_network():
    monitor = VirgoMonitor(["us-central1", "us-east4", "europe-west4", "asia-east1"])
    for i in range(5):
        metrics = await monitor.sample_metrics(100000, 42)
        print(f"Utilization: {metrics.total_utilization:.1f}%, "
              f"Latency: {metrics.avg_latency:.1f}ms, "
              f"Throughput: {metrics.throughput:.0f} Tbps")
        await asyncio.sleep(1)
    
    anomalies = monitor.get_anomaly_detection()
    for a in anomalies:
        print(f"⚠️ {a}")

asyncio.run(monitor_virgo_network())

import numpy as np
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
import asyncio

class AdFormat(Enum):
    SEARCH = "search"
    DISPLAY = "display"
    VIDEO = "video"
    AI_OVERVIEW = "ai_overview"

@dataclass
class AdRequest:
    request_id: str
    query: str
    device_type: str
    time_of_day: int
    ad_format: AdFormat
    ai_mode: bool

@dataclass
class AdCandidate:
    ad_id: str
    advertiser_id: str
    bid_price: float
    quality_score: float
    budget_remaining: float
    ctr_prediction: float
    conversion_probability: float

@dataclass
class AuctionResult:
    request_id: str
    winner_ad_id: str
    winner_price: float
    second_price: float
    estimated_ctr: float

class GeminiAuctionEngine:
    """AI-powered advertising auction engine"""
    
    def __init__(self, ai_mode_boost: float = 1.5):
        self.ai_mode_boost = ai_mode_boost
    
    def _predict_ctr(self, ad: AdCandidate, request: AdRequest) -> float:
        """AI-based CTR prediction"""
        base_ctr = ad.ctr_prediction
        hour_factor = 1.0 + 0.3 * np.sin(2 * np.pi * (request.time_of_day - 10) / 24)
        device_factor = {"mobile": 1.2, "desktop": 1.0}.get(request.device_type, 1.0)
        ai_factor = self.ai_mode_boost if request.ai_mode else 1.0
        return min(base_ctr * hour_factor * device_factor * ai_factor, 0.5)
    
    def _calculate_quality_score(self, ad: AdCandidate, request: AdRequest) -> float:
        """Comprehensive quality score calculation"""
        predicted_ctr = self._predict_ctr(ad, request)
        quality = 0.4 * (predicted_ctr * 100) + 0.3 * (ad.conversion_probability * 100) + 0.3 * ad.quality_score
        return min(quality, 10.0)
    
    async def run_auction(self, request: AdRequest, 
                         candidates: List[AdCandidate]) -> AuctionResult:
        """GSP (Generalized Second Price) auction"""
        qualified = [(ad, self._calculate_quality_score(ad, request)) 
                     for ad in candidates if ad.quality_score >= 3.0]
        
        if not qualified:
            return AuctionResult(request.request_id, "", 0, 0, 0)
        
        # Calculate effective bids = bid × quality score
        bids = [(ad, ad.bid_price * (quality / 10.0), quality) 
                for ad, quality in qualified]
        bids.sort(key=lambda x: x[1], reverse=True)
        
        winner, winner_eff_bid, winner_quality = bids[0]
        second_eff_bid = bids[1][1] if len(bids) > 1 else 0.01
        actual_price = second_eff_bid / (winner_quality / 10.0)
        
        return AuctionResult(
            request_id=request.request_id,
            winner_ad_id=winner.ad_id,
            winner_price=round(actual_price, 4),
            second_price=round(second_eff_bid, 4),
            estimated_ctr=self._predict_ctr(winner, request)
        )

# Simulate
async def simulate():
    engine = GeminiAuctionEngine()
    request = AdRequest("req_001", "AI cloud compute", "mobile", 14, 
                       AdFormat.SEARCH, False)
    candidates = [
        AdCandidate("ad_001", "Google Cloud", 5.0, 9.5, 100000, 0.08, 0.05),
        AdCandidate("ad_002", "MS Azure", 4.8, 8.9, 80000, 0.07, 0.04),
    ]
    result = await engine.run_auction(request, candidates)
    print(f"Winner: {result.winner_ad_id}, Price: ${result.winner_price:.4f}")

asyncio.run(simulate())