graph TB
    subgraph "Signal Sources"
        DR[(Redis<br/>Driver Locations)]
        OR[(Postgres<br/>Order History)]
        WE[Weather API]
        DI[Distance API]
        TI[Time Service]
    end

    subgraph "Pricing Service"
        SC[Signal Collector]
        SM[Surge Multiplier]
        DM[Distance Multiplier]
        WM[Weather Multiplier]
        PE[Price Engine]
    end

    subgraph "Price Lock"
        PL[(Redis<br/>Locked Prices)]
        PLS[Price Lock Service]
    end

    subgraph "Analytics"
        EL[Elasticity Tracker]
        AB[A/B Test Framework]
        AM[Analytics Monitor]
    end

    DR --> SC
    OR --> SC
    WE --> SC
    DI --> SC
    TI --> SC

    SC --> SM
    SC --> DM
    SC --> WM

    SM --> PE
    DM --> PE
    WM --> PE

    PE --> PLS
    PLS --> PL

    PE --> EL
    EL --> AM
    AB --> PE

    style PE fill:#2ecc71,color:#fff
    style PL fill:#f39c12,color:#fff
    style AM fill:#3498db,color:#fff

sequenceDiagram
    participant U as User
    participant C as Checkout Service
    participant PS as Pricing Service
    participant PL as Price Lock (Redis)
    participant SC as Signal Collector
    participant P as Payment Service

    U->>C: Click "Checkout"
    C->>PS: Calculate delivery fee
    PS->>SC: Collect current signals
    SC->>SC: Get driver count, pending orders, weather, distance

    alt Surge active
        SC-->>PS: Load ratio = 3.2 (surge!)
        PS->>PS: Compute surge_mult = 1.8x
    else Normal
        SC-->>PS: Load ratio = 0.8 (normal)
        PS->>PS: Surge_mult = 1.0x
    end

    PS->>PS: fee = base × distance × surge × weather
    PS-->>C: Return delivery_fee = 18000

    C->>PL: Lock price (order_id, 18000, TTL=15min)
    PL-->>C: Price locked
    C-->>U: Show total: 18000

    Note over U,C: User browses other items, 5 minutes pass

    U->>P: Confirm payment
    P->>PL: Get locked price for order
    PL-->>P: Return: 18000
    P->>P: Charge 18000 (ignoring current surge)
    P-->>U: Payment successful (18000)

    Note over PL,P: Even if surge multiplier changed to 2.5x,<br/>price is locked at 18000

package signal

import (
    "context"
    "encoding/json"
    "fmt"
    "log/slog"
    "math"
    "net/http"
    "sync"
    "time"

    "github.com/redis/go-redis/v9"
)

// AreaSignals adalah kumpulan sinyal untuk satu area pada satu waktu.
type AreaSignals struct {
    AreaID      string    `json:"area_id"`
    Timestamp   time.Time `json:"timestamp"`

    // Supply
    DriverCount       int     `json:"driver_count"`
    DriversOnline     int     `json:"drivers_online"`
    DriversBusy       int     `json:"drivers_busy"`
    AvgDriverDistance float64 `json:"avg_driver_distance_km"` // Avg distance to nearest hub

    // Demand
    PendingOrders     int     `json:"pending_orders"`
    OrdersLast15Min   int     `json:"orders_last_15min"`
    OrdersLast60Min   int     `json:"orders_last_60min"`

    // Computed
    LoadRatio         float64 `json:"load_ratio"`          // pending_orders / drivers_online
    AvgWaitTimeMin    float64 `json:"avg_wait_time_min"`

    // External
    Temperature       float64 `json:"temperature_celsius"`
    IsRaining         bool    `json:"is_raining"`
    IsPeakHour        bool    `json:"is_peak_hour"`
    IsPublicHoliday   bool    `json:"is_public_holiday"`
}

// SignalCollector mengumpulkan sinyal real-time dari berbagai sumber.
// Semua pengumpulan dilakukan concurrent untuk meminimalkan latency.
type SignalCollector struct {
    rdb         *redis.Client
    httpClient  *http.Client
    weatherKey  string
}

func NewSignalCollector(rdb *redis.Client, weatherAPIKey string) *SignalCollector {
    return &SignalCollector{
        rdb:        rdb,
        httpClient: &http.Client{Timeout: 5 * time.Second},
        weatherKey: weatherAPIKey,
    }
}

// CollectSignals mengumpulkan semua sinyal untuk suatu area.
func (sc *SignalCollector) CollectSignals(ctx context.Context, areaID string) (*AreaSignals, error) {
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()

    // Concurrent collection with error tolerance
    type result struct {
        drivers int
        orders  int
        orders15 int
        orders60 int
        raining bool
        temp    float64
    }

    resultCh := make(chan result, 1)
    errCh := make(chan error, 1)

    go func() {
        var r result
        var wg sync.WaitGroup
        var mu sync.Mutex

        wg.Add(3)
        go func() {
            defer wg.Done()
            d := sc.getDriverCounts(ctx, areaID)
            mu.Lock()
            r.drivers = d
            mu.Unlock()
        }()
        go func() {
            defer wg.Done()
            o, o15, o60 := sc.getOrderCounts(ctx, areaID)
            mu.Lock()
            r.orders = o
            r.orders15 = o15
            r.orders60 = o60
            mu.Unlock()
        }()
        go func() {
            defer wg.Done()
            rain, temp := sc.getWeather(ctx, areaID)
            mu.Lock()
            r.raining = rain
            r.temp = temp
            mu.Unlock()
        }()

        wg.Wait()
        resultCh <- r
    }()

    select {
    case r := <-resultCh:
        loadRatio := 0.0
        if r.drivers > 0 {
            loadRatio = float64(r.orders) / float64(r.drivers)
        }

        now := time.Now()
        isPeak := isPeakHour(now)

        signals := &AreaSignals{
            AreaID:           areaID,
            Timestamp:        now,
            DriverCount:      r.drivers,
            DriversOnline:    r.drivers,
            PendingOrders:    r.orders,
            OrdersLast15Min:  r.orders15,
            OrdersLast60Min:  r.orders60,
            LoadRatio:        math.Round(loadRatio*100) / 100,
            IsRaining:        r.raining,
            Temperature:      r.temp,
            IsPeakHour:       isPeak,
            IsPublicHoliday:  isIndonesianHoliday(now),
        }

        return signals, nil

    case <-ctx.Done():
        return nil, fmt.Errorf("collect signals: %w", ctx.Err())

    case err := <-errCh:
        return nil, fmt.Errorf("collect signals: %w", err)
    }
}

func (sc *SignalCollector) getDriverCounts(ctx context.Context, areaID string) int {
    // Driver locations stored in Redis sorted sets:
    // key: "drivers:{area_id}" with member = driver_id, score = last_heartbeat_unix
    now := time.Now().Unix()
    fiveMinAgo := now - 300

    cmd := sc.rdb.ZCount(ctx, fmt.Sprintf("drivers:%s", areaID),
        fmt.Sprintf("%d", fiveMinAgo), fmt.Sprintf("%d", now))
    count, err := cmd.Result()
    if err != nil {
        slog.WarnContext(ctx, "failed to get driver count", "area", areaID, "error", err)
        return 0
    }
    return int(count)
}

func (sc *SignalCollector) getOrderCounts(ctx context.Context, areaID string) (pending, last15min, last60min int) {
    now := time.Now()

    // Pending orders count
    pipe := sc.rdb.Pipeline()
    pendingCmd := pipe.SCard(ctx, fmt.Sprintf("orders:pending:%s", areaID))
    last15Cmd := pipe.ZCount(ctx, fmt.Sprintf("orders:history:%s", areaID),
        fmt.Sprintf("%d", now.Add(-15*time.Minute).Unix()), fmt.Sprintf("%d", now.Unix()))
    last60Cmd := pipe.ZCount(ctx, fmt.Sprintf("orders:history:%s", areaID),
        fmt.Sprintf("%d", now.Add(-60*time.Minute).Unix()), fmt.Sprintf("%d", now.Unix()))

    _, err := pipe.Exec(ctx)
    if err != nil {
        slog.WarnContext(ctx, "failed to get order counts", "area", areaID, "error", err)
        return 0, 0, 0
    }

    return int(pendingCmd.Val()), int(last15Cmd.Val()), int(last60Cmd.Val())
}

func (sc *SignalCollector) getWeather(ctx context.Context, areaID string) (raining bool, temp float64) {
    // Simplified: in production, call OpenWeatherMap / BMKG API
    // Cache weather data for 30 minutes to avoid excessive API calls
    cacheKey := fmt.Sprintf("weather:%s", areaID)
    cached, err := sc.rdb.Get(ctx, cacheKey).Result()
    if err == nil {
        var w struct {
            Raining bool    `json:"raining"`
            Temp    float64 `json:"temp"`
        }
        if json.Unmarshal([]byte(cached), &w) == nil {
            return w.Raining, w.Temp
        }
    }

    // Fetch from external API
    // ... (simplified for brevity)

    // Cache for 30 min
    data, _ := json.Marshal(map[string]interface{}{
        "raining": false,
        "temp":    30.0,
    })
    sc.rdb.Set(ctx, cacheKey, string(data), 30*time.Minute)

    return false, 30.0
}

package pricing

import (
    "context"
    "fmt"
    "log/slog"
    "math"
    "sync"
    "time"
)

// SurgeConfig mengatur parameter surge detection.
type SurgeConfig struct {
    // Load ratio thresholds
    LowLoadRatio     float64 // < this = no surge
    MediumLoadRatio  float64 // >= this = 1.5x surge
    HighLoadRatio    float64 // >= this = 2.0x surge
    CriticalRatio    float64 // >= this = 3.0x surge (cap)

    // Weather multiplier
    RainMultiplier   float64 // Multiplier when raining

    // Peak hour multiplier
    PeakHourMultiplier float64

    // Smoothing: berapa lama multiplier bertahan
    SurgeDecayMinutes int     // Gradually decrease surge over N minutes
}

// DefaultSurgeConfig mengembalikan konfigurasi surge default.
// Semua nilai ini harus di-tuning berdasarkan data historis dan A/B test.
func DefaultSurgeConfig() SurgeConfig {
    return SurgeConfig{
        LowLoadRatio:      1.0,  // Normal
        MediumLoadRatio:   2.0,  // 1.5x surge
        HighLoadRatio:     3.5,  // 2.0x surge
        CriticalRatio:     5.0,  // 3.0x surge (max)

        RainMultiplier:     1.3, // Hujan: +30%
        PeakHourMultiplier: 1.2, // Jam sibuk: +20%

        SurgeDecayMinutes:  15,  // Surge turun bertahap dalam 15 menit
    }
}

// SurgeResult adalah hasil kalkulasi surge untuk suatu area.
type SurgeResult struct {
    AreaID           string  `json:"area_id"`
    LoadRatio        float64 `json:"load_ratio"`
    SurgeMultiplier  float64 `json:"surge_multiplier"`
    WeatherMultiplier float64 `json:"weather_multiplier"`
    PeakMultiplier   float64 `json:"peak_multiplier"`
    TotalMultiplier  float64 `json:"total_multiplier"`
    IsSurge          bool    `json:"is_surge"`
    SurgeLevel       string  `json:"surge_level"` // none | low | medium | high | critical
    ComputedAt       time.Time `json:"computed_at"`
}

// SurgeDetector mengelola deteksi dan aplikasi surge multiplier.
type SurgeDetector struct {
    config     SurgeConfig
    history    map[string][]SurgeResult // areaID -> last N results
    mu         sync.RWMutex
    decayTrack map[string]time.Time     // areaID -> last surge time
}

func NewSurgeDetector(config SurgeConfig) *SurgeDetector {
    return &SurgeDetector{
        config:     config,
        history:    make(map[string][]SurgeResult),
        decayTrack: make(map[string]time.Time),
    }
}

// Detect menghitung surge multiplier berdasarkan sinyal area saat ini.
func (sd *SurgeDetector) Detect(ctx context.Context, signals *AreaSignals) *SurgeResult {
    sd.mu.Lock()
    defer sd.mu.Unlock()

    // 1. Tentukan surge multiplier dari load ratio
    loadRatio := signals.LoadRatio
    var surgeMult float64
    var surgeLevel string

    switch {
    case loadRatio >= sd.config.CriticalRatio:
        surgeMult = 3.0
        surgeLevel = "critical"
    case loadRatio >= sd.config.HighLoadRatio:
        surgeMult = 2.0
        surgeLevel = "high"
    case loadRatio >= sd.config.MediumLoadRatio:
        surgeMult = 1.5
        surgeLevel = "medium"
    case loadRatio >= sd.config.LowLoadRatio:
        surgeMult = 1.2
        surgeLevel = "low"
    default:
        surgeMult = 1.0
        surgeLevel = "none"
    }

    // 2. Terapkan smoothing: jangan langsung turun ke 1.0
    // Gunakan exponential decay
    if lastSurge, ok := sd.decayTrack[signals.AreaID]; ok {
        elapsed := time.Since(lastSurge).Minutes()
        if elapsed < float64(sd.config.SurgeDecayMinutes) && surgeMult < sd.getLastMultiplier(signals.AreaID) {
            // Decay phase: gradual decrease
            decayFactor := 1.0 - (elapsed / float64(sd.config.SurgeDecayMinutes))
            lastMult := sd.getLastMultiplier(signals.AreaID)
            surgeMult = 1.0 + (lastMult-1.0)*decayFactor
            surgeLevel = surgeLevel + "_decaying"
        }
    }

    // 3. Weather multiplier
    weatherMult := 1.0
    if signals.IsRaining {
        weatherMult = sd.config.RainMultiplier
    }

    // 4. Peak hour multiplier
    peakMult := 1.0
    if signals.IsPeakHour {
        peakMult = sd.config.PeakHourMultiplier
    }

    // 5. Total multiplier (capped)
    totalMult := math.Min(surgeMult*weatherMult*peakMult, 5.0)

    // Track for decay
    if surgeMult > 1.0 {
        sd.decayTrack[signals.AreaID] = time.Now()
    }

    result := &SurgeResult{
        AreaID:            signals.AreaID,
        LoadRatio:         loadRatio,
        SurgeMultiplier:   math.Round(surgeMult*100) / 100,
        WeatherMultiplier: weatherMult,
        PeakMultiplier:    peakMult,
        TotalMultiplier:   math.Round(totalMult*100) / 100,
        IsSurge:           totalMult > 1.0,
        SurgeLevel:        surgeLevel,
        ComputedAt:        time.Now(),
    }

    // Store history
    sd.history[signals.AreaID] = append(sd.history[signals.AreaID], *result)
    if len(sd.history[signals.AreaID]) > 100 {
        sd.history[signals.AreaID] = sd.history[signals.AreaID][1:]
    }

    slog.InfoContext(ctx, "surge detection result",
        "area", signals.AreaID,
        "load_ratio", loadRatio,
        "total_multiplier", totalMult,
        "surge_level", surgeLevel,
    )

    return result
}

func (sd *SurgeDetector) getLastMultiplier(areaID string) float64 {
    hist := sd.history[areaID]
    if len(hist) == 0 {
        return 1.0
    }
    return hist[len(hist)-1].TotalMultiplier
}

flowchart TD
    A[New pricing request] --> B[Collect signals for area]
    B --> C[Compute load ratio L = pending / drivers]

    C --> D{L >= 5.0?}
    D -->|Yes| E[Surge = 3.0x CRITICAL]
    D -->|No| F{L >= 3.5?}
    F -->|Yes| G[Surge = 2.0x HIGH]
    F -->|No| H{L >= 2.0?}
    H -->|Yes| I[Surge = 1.5x MEDIUM]
    H -->|No| J{L >= 1.0?}
    J -->|Yes| K[Surge = 1.2x LOW]
    J -->|No| L[Surge = 1.0x NONE]

    E --> M{Is raining?}
    G --> M
    I --> M
    K --> M
    L --> M

    M -->|Yes| N[Apply weather mult 1.3x]
    M -->|No| O[Weather mult = 1.0x]

    N --> P{Is peak hour?}
    O --> P

    P -->|Yes| Q[Apply peak mult 1.2x]
    P -->|No| R[Peak mult = 1.0x]

    Q --> S[Total = surge * weather * peak]
    R --> S

    S --> T{Total > 1.0?}
    T -->|Yes| U[Apply surge decay smoothing]
    T -->|No| V[No surge]

    U --> W[Cap total <= 5.0x]
    W --> X[Output: total_multiplier]

    V --> X

    style A fill:#3498db,color:#fff
    style E fill:#e74c3c,color:#fff
    style L fill:#2ecc71,color:#fff
    style X fill:#2ecc71,color:#fff

package pricing

import (
    "context"
    "encoding/json"
    "fmt"
    "log/slog"
    "math"
    "time"
)

// =============================================================================
// Interfaces
// =============================================================================

// SignalSource adalah interface untuk mendapatkan sinyal area.
type SignalSource interface {
    CollectSignals(ctx context.Context, areaID string) (*AreaSignals, error)
}

// PriceLocker adalah interface untuk menyimpan dan mengambil locked price.
type PriceLocker interface {
    LockPrice(ctx context.Context, orderID string, fee int, duration time.Duration) error
    GetLockedPrice(ctx context.Context, orderID string) (int, error)
}

// =============================================================================
// Fee Calculation
// =============================================================================

// FeeRequest adalah input untuk kalkulasi delivery fee.
type FeeRequest struct {
    OrderID         string  `json:"order_id"`
    UserID          string  `json:"user_id"`
    AreaID          string  `json:"area_id"`
    HubID           string  `json:"hub_id"`
    DestinationLat  float64 `json:"destination_lat"`
    DestinationLng  float64 `json:"destination_lng"`
    OrderItemsTotal float64 `json:"order_items_total"`
    RequestedAt     time.Time `json:"requested_at"`
}

// FeeBreakdown adalah rincian komponen delivery fee.
// Transparan: setiap komponen dilaporkan ke pengguna.
type FeeBreakdown struct {
    BaseFee          int     `json:"base_fee"`
    DistanceKm       float64 `json:"distance_km"`
    DistanceFee      int     `json:"distance_fee"`
    SurgeMultiplier  float64 `json:"surge_multiplier"`
    WeatherMultiplier float64 `json:"weather_multiplier"`
    PeakMultiplier   float64 `json:"peak_multiplier"`
    TotalMultiplier  float64 `json:"total_multiplier"`
    FinalFee         int     `json:"final_fee"`
    SurgeActive      bool    `json:"surge_active"`
}

// PriceEngine adalah komponen inti yang menghitung delivery fee.
type PriceEngine struct {
    signalSource   SignalSource
    surgeDetector  *SurgeDetector
    priceLocker    PriceLocker

    // Fee configuration (tunable via A/B test)
    baseFee          int     // Base delivery fee in IDR
    baseFeePerKm     int     // Fee per km in IDR
    minFee           int     // Minimum fee
    maxFee           int     // Maximum fee (safety cap)

    // Distance config
    maxDistanceKm    float64 // Max delivery radius
}

func NewPriceEngine(
    signalSource SignalSource,
    surgeDetector *SurgeDetector,
    priceLocker PriceLocker,
) *PriceEngine {
    return &PriceEngine{
        signalSource:   signalSource,
        surgeDetector:  surgeDetector,
        priceLocker:    priceLocker,
        baseFee:        8000,
        baseFeePerKm:   2000,
        minFee:         5000,
        maxFee:         75000,
        maxDistanceKm:  10.0,
    }
}

// SetConfig memungkinkan update konfigurasi runtime (untuk A/B test).
func (pe *PriceEngine) SetConfig(cfg PriceEngineConfig) {
    if cfg.BaseFee > 0 {
        pe.baseFee = cfg.BaseFee
    }
    if cfg.BaseFeePerKm > 0 {
        pe.baseFeePerKm = cfg.BaseFeePerKm
    }
    if cfg.MinFee > 0 {
        pe.minFee = cfg.MinFee
    }
    if cfg.MaxFee > 0 {
        pe.maxFee = cfg.MaxFee
    }
}

type PriceEngineConfig struct {
    BaseFee      int
    BaseFeePerKm int
    MinFee       int
    MaxFee       int
}

// CalculateFee adalah entry point utama untuk menghitung delivery fee.
func (pe *PriceEngine) CalculateFee(ctx context.Context, req *FeeRequest) (*FeeBreakdown, error) {
    slog.InfoContext(ctx, "calculating delivery fee",
        "order_id", req.OrderID,
        "area_id", req.AreaID,
        "user_id", req.UserID,
    )

    // 1. Hitung jarak dari hub ke tujuan
    distance, err := pe.calculateDistance(ctx, req.HubID, req.DestinationLat, req.DestinationLng)
    if err != nil {
        return nil, fmt.Errorf("calculate distance: %w", err)
    }

    // Validasi jarak maksimum
    if distance > pe.maxDistanceKm {
        return nil, fmt.Errorf("delivery distance %.1f km exceeds max %.1f km", distance, pe.maxDistanceKm)
    }

    // 2. Kumpulkan sinyal area
    signals, err := pe.signalSource.CollectSignals(ctx, req.AreaID)
    if err != nil {
        // Jika signal collection gagal, fallback ke pricing normal tanpa surge
        slog.WarnContext(ctx, "signal collection failed, using no-surge fallback",
            "area", req.AreaID, "error", err)
        signals = &AreaSignals{
            AreaID: req.AreaID,
        }
    }

    // 3. Deteksi surge
    surgeResult := pe.surgeDetector.Detect(ctx, signals)

    // 4. Hitung fee
    baseFee := pe.baseFee
    distanceFee := int(math.Round(distance * float64(pe.baseFeePerKm)))
    subtotal := baseFee + distanceFee

    finalFee := int(math.Round(float64(subtotal) * surgeResult.TotalMultiplier))

    // Ensure within bounds
    if finalFee < pe.minFee {
        finalFee = pe.minFee
    }
    if finalFee > pe.maxFee {
        finalFee = pe.maxFee
    }

    breakdown := &FeeBreakdown{
        BaseFee:           baseFee,
        DistanceKm:        math.Round(distance*10) / 10,
        DistanceFee:       distanceFee,
        SurgeMultiplier:   surgeResult.SurgeMultiplier,
        WeatherMultiplier: surgeResult.WeatherMultiplier,
        PeakMultiplier:    surgeResult.PeakMultiplier,
        TotalMultiplier:   surgeResult.TotalMultiplier,
        FinalFee:          finalFee,
        SurgeActive:       surgeResult.IsSurge,
    }

    // 5. Lock price untuk durasi checkout
    if err := pe.priceLocker.LockPrice(ctx, req.OrderID, finalFee, 15*time.Minute); err != nil {
        // Price lock failure bukan fatal error
        // Order tetap bisa dilanjutkan, tapi tanpa lock protection
        slog.WarnContext(ctx, "price lock failed, continuing without lock",
            "order_id", req.OrderID, "error", err)
    }

    slog.InfoContext(ctx, "delivery fee calculated",
        "order_id", req.OrderID,
        "base_fee", baseFee,
        "distance_fee", distanceFee,
        "subtotal", subtotal,
        "final_fee", finalFee,
        "surge", surgeResult.IsSurge,
        "total_multiplier", surgeResult.TotalMultiplier,
    )

    return breakdown, nil
}

func (pe *PriceEngine) calculateDistance(ctx context.Context, hubID string, destLat, destLng float64) (float64, error) {
    // In production: gunakan OpenStreetMap / Google Maps Distance API
    // untuk jarak jalan (driving distance), bukan Euclidean.
    //
    // Simplified: haversine formula untuk jarak garis lurus.
    hubLat, hubLng := getHubCoordinates(hubID)
    return haversine(hubLat, hubLng, destLat, destLng), nil
}

func haversine(lat1, lng1, lat2, lng2 float64) float64 {
    r := 6371.0 // Earth radius in km

    dLat := (lat2 - lat1) * math.Pi / 180
    dLng := (lng2 - lng1) * math.Pi / 180

    a := math.Sin(dLat/2)*math.Sin(dLat/2) +
        math.Cos(lat1*math.Pi/180)*math.Cos(lat2*math.Pi/180)*
            math.Sin(dLng/2)*math.Sin(dLng/2)

    c := 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))
    return r * c
}

func getHubCoordinates(hubID string) (lat, lng float64) {
    // Simplified: lookup from database/config
    coords := map[string][2]float64{
        "hub-jkt-01": {-6.2146, 106.8451},  // Jakarta Pusat
        "hub-jkt-02": {-6.2618, 106.8106},  // Jakarta Selatan
        "hub-bdg-01": {-6.9175, 107.6191},  // Bandung
        "hub-sby-01": {-7.2575, 112.7521},  // Surabaya
    }
    if c, ok := coords[hubID]; ok {
        return c[0], c[1]
    }
    return -6.2, 106.8 // Default: Jakarta
}

package pricing

import (
    "context"
    "fmt"
    "strconv"
    "time"

    "github.com/redis/go-redis/v9"
)

// RedisPriceLocker menyimpan locked price di Redis.
//
// Key format: "price_lock:{order_id}"
// Value: fee dalam integer (IDR)
// TTL: durasi checkout (default 15 menit)
//
// Keuntungan Redis untuk price lock:
// 1. In-memory, sangat cepat (sub-millisecond read/write)
// 2. TTL otomatis: expired lock tidak perlu cleanup manual
// 3. Atomic: tidak ada race condition saat lock/unlock
type RedisPriceLocker struct {
    rdb *redis.Client
}

func NewRedisPriceLocker(rdb *redis.Client) *RedisPriceLocker {
    return &RedisPriceLocker{
        rdb: rdb,
    }
}

// LockPrice menyimpan fee yang sudah di-lock untuk suatu order.
func (l *RedisPriceLocker) LockPrice(ctx context.Context, orderID string, fee int, ttl time.Duration) error {
    key := fmt.Sprintf("price_lock:%s", orderID)
    err := l.rdb.Set(ctx, key, fee, ttl).Err()
    if err != nil {
        return fmt.Errorf("redis set price lock: %w", err)
    }
    return nil
}

// GetLockedPrice mengambil fee yang sudah di-lock untuk suatu order.
// Mengembalikan error jika lock tidak ditemukan (expired atau tidak pernah dibuat).
func (l *RedisPriceLocker) GetLockedPrice(ctx context.Context, orderID string) (int, error) {
    key := fmt.Sprintf("price_lock:%s", orderID)
    val, err := l.rdb.Get(ctx, key).Result()
    if err == redis.Nil {
        return 0, fmt.Errorf("price lock not found or expired: order=%s", orderID)
    }
    if err != nil {
        return 0, fmt.Errorf("redis get price lock: %w", err)
    }

    fee, err := strconv.Atoi(val)
    if err != nil {
        return 0, fmt.Errorf("invalid price lock value: %s", val)
    }

    return fee, nil
}

// ExtendLock memperpanjang TTL lock jika checkout memakan waktu lama.
func (l *RedisPriceLocker) ExtendLock(ctx context.Context, orderID string, extraTTL time.Duration) error {
    key := fmt.Sprintf("price_lock:%s", orderID)
    err := l.rdb.Expire(ctx, key, extraTTL).Err()
    if err == redis.Nil {
        return fmt.Errorf("cannot extend expired lock: order=%s", orderID)
    }
    if err != nil {
        return fmt.Errorf("redis extend price lock: %w", err)
    }
    return nil
}

// ReleaseLock menghapus lock setelah pembayaran selesai atau dibatalkan.
func (l *RedisPriceLocker) ReleaseLock(ctx context.Context, orderID string) error {
    key := fmt.Sprintf("price_lock:%s", orderID)
    err := l.rdb.Del(ctx, key).Err()
    if err != nil {
        return fmt.Errorf("redis delete price lock: %w", err)
    }
    return nil
}

package experiment

import (
    "context"
    "crypto/rand"
    "encoding/binary"
    "fmt"
    "log/slog"
    "math"
    "sync"
    "time"
)

// ABTestConfig mendefinisikan sebuah A/B test.
type ABTestConfig struct {
    Name       string    `json:"name"`
    StartAt    time.Time `json:"start_at"`
    EndAt      time.Time `json:"end_at"`
    TrafficPct int       `json:"traffic_pct"` // 0-100: percentage of users in experiment
    Variants   []Variant `json:"variants"`
}

// Variant adalah satu opsi dalam A/B test.
type Variant struct {
    Name     string      `json:"name"`
    Weight   int         `json:"weight"`   // Relative weight for allocation
    Config   interface{} `json:"config"`   // Pricing config for this variant
}

// ExperimentManager mengelola A/B test untuk pricing parameters.
type ExperimentManager struct {
    mu       sync.RWMutex
    tests    map[string]*ABTestConfig
    results  map[string]*ExperimentResults
}

type ExperimentResults struct {
    TestName       string
    VariantResults map[string]VariantResult
}

type VariantResult struct {
    TotalOrders      int
    TotalRevenue     float64
    ConversionRate   float64
    AvgOrderValue    float64
    CancellationRate float64
    AvgDeliveryFee   float64
}

func NewExperimentManager() *ExperimentManager {
    return &ExperimentManager{
        tests:   make(map[string]*ABTestConfig),
        results: make(map[string]*ExperimentResults),
    }
}

// AssignVariant menentukan variant mana yang diterima oleh user.
// Menggunakan userID sebagai seed agar user yang sama selalu
// mendapat variant yang sama (deterministic bucketing).
func (em *ExperimentManager) AssignVariant(userID string, test *ABTestConfig) *Variant {
    if test == nil {
        return nil
    }

    // Check if user is in experiment
    userBucket := hashUserID(userID) % 100
    if userBucket >= test.TrafficPct {
        return nil // Control group / not in experiment
    }

    // Weighted random selection
    totalWeight := 0
    for _, v := range test.Variants {
        totalWeight += v.Weight
    }

    userSelection := hashUserID(userID+"_variant") % totalWeight
    cumulative := 0
    for i := range test.Variants {
        cumulative += test.Variants[i].Weight
        if userSelection < cumulative {
            return &test.Variants[i]
        }
    }

    return &test.Variants[0] // Fallback
}

// hashUserID mengubah userID menjadi integer untuk deterministic bucketing.
func hashUserID(userID string) int {
    h := 0
    for _, c := range userID {
        h = h*31 + int(c)
    }
    if h < 0 {
        h = -h
    }
    return h
}

// RecordConversion mencatat hasil konversi untuk eksperimen.
func (em *ExperimentManager) RecordConversion(ctx context.Context, testName, variantName string, orderValue, deliveryFee float64, converted bool) {
    // Simplified: in production, store to database for analysis
    slog.InfoContext(ctx, "experiment conversion recorded",
        "test", testName,
        "variant", variantName,
        "order_value", orderValue,
        "delivery_fee", deliveryFee,
        "converted", converted,
    )
}

package elasticity

import (
    "context"
    "log/slog"
    "math"
    "sync"
    "time"
)

// ElasticityTracker mengukur price elasticity of demand.
//
// Price elasticity = % change in demand / % change in price
// - Elastis (|e| > 1): pelanggan sensitif. Harga naik 10% -> demand turun >10%
// - Inelastis (|e| < 1): pelanggan tidak sensitif. Harga naik 10% -> demand turun <10%
// - Unitary (|e| = 1): proporsional
type ElasticityTracker struct {
    mu       sync.RWMutex
    data     map[string][]PriceDemandPoint // areaID -> data points
    windowDays int
}

type PriceDemandPoint struct {
    Timestamp   time.Time
    AvgFee      float64
    OrderCount  int
    AreaID      string
}

func NewElasticityTracker(windowDays int) *ElasticityTracker {
    if windowDays <= 0 {
        windowDays = 30
    }
    return &ElasticityTracker{
        data:       make(map[string][]PriceDemandPoint),
        windowDays: windowDays,
    }
}

// Record mencatat satu titik data harga-permintaan.
func (et *ElasticityTracker) Record(ctx context.Context, areaID string, avgFee float64, orderCount int) {
    et.mu.Lock()
    defer et.mu.Unlock()

    et.data[areaID] = append(et.data[areaID], PriceDemandPoint{
        Timestamp:  time.Now(),
        AvgFee:     avgFee,
        OrderCount: orderCount,
        AreaID:     areaID,
    })

    // Prune old data
    cutoff := time.Now().AddDate(0, 0, -et.windowDays)
    points := et.data[areaID]
    var kept []PriceDemandPoint
    for _, p := range points {
        if p.Timestamp.After(cutoff) {
            kept = append(kept, p)
        }
    }
    et.data[areaID] = kept
}

// ComputeElasticity menghitung price elasticity untuk suatu area.
//
// Formula: e = (ln(Q2/Q1)) / (ln(P2/P1))
// Di mana:
//   Q1, Q2 = demand sebelum dan sesudah
//   P1, P2 = harga sebelum dan sesudah
//
// Mengembalikan 0 jika data tidak mencukupi.
func (et *ElasticityTracker) ComputeElasticity(areaID string) float64 {
    et.mu.RLock()
    defer et.mu.RUnlock()

    points, ok := et.data[areaID]
    if !ok || len(points) < 2 {
        return 0
    }

    // Sort by fee
    sorted := make([]PriceDemandPoint, len(points))
    copy(sorted, points)
    for i := 0; i < len(sorted); i++ {
        for j := i + 1; j < len(sorted); j++ {
            if sorted[i].AvgFee > sorted[j].AvgFee {
                sorted[i], sorted[j] = sorted[j], sorted[i]
            }
        }
    }

    // Simple linear regression on log-log transformed data:
    // ln(OrderCount) = a + b * ln(AvgFee)
    // b = elasticity coefficient
    n := float64(len(sorted))
    var sumX, sumY, sumXY, sumX2 float64

    for _, p := range sorted {
        if p.AvgFee <= 0 || p.OrderCount <= 0 {
            continue
        }
        x := math.Log(p.AvgFee)
        y := math.Log(float64(p.OrderCount))
        sumX += x
        sumY += y
        sumXY += x * y
        sumX2 += x * x
    }

    denominator := n*sumX2 - sumX*sumX
    if math.Abs(denominator) < 1e-10 {
        return 0
    }

    // Slope = elasticity
    elasticity := (n*sumXY - sumX*sumY) / denominator

    return math.Round(elasticity*100) / 100
}

// SuggestSurgeCap mengembalikan surge cap yang disarankan berdasarkan
// price elasticity. Area dengan pelanggan elastis -> surge cap lebih rendah.
func (et *ElasticityTracker) SuggestSurgeCap(areaID string) float64 {
    e := et.ComputeElasticity(areaID)

    switch {
    case e < -1.5:
        // Sangat elastis: pelanggan mudah kabur
        return 1.5
    case e < -1.0:
        // Moderat elastis
        return 2.0
    case e < -0.5:
        // Sedikit elastis
        return 3.0
    default:
        // Inelastis
        return 5.0
    }
}

package api

import (
    "context"
    "encoding/json"
    "fmt"
    "log/slog"
    "net/http"
    "time"
)

// PricingHandler adalah HTTP handler untuk endpoint pricing.
type PricingHandler struct {
    engine     *PriceEngine
    locker     *RedisPriceLocker
    expManager *ExperimentManager
    elasticity *ElasticityTracker
}

func NewPricingHandler(
    engine *PriceEngine,
    locker *RedisPriceLocker,
    expManager *ExperimentManager,
    elasticity *ElasticityTracker,
) *PricingHandler {
    return &PricingHandler{
        engine:     engine,
        locker:     locker,
        expManager: expManager,
        elasticity: elasticity,
    }
}

// HandleCalculateFee menangani POST /api/v1/delivery-fee.
func (h *PricingHandler) HandleCalculateFee(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
    defer cancel()

    var req FeeRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        writeError(w, http.StatusBadRequest, "invalid request body")
        return
    }

    // Validate
    if req.OrderID == "" || req.AreaID == "" {
        writeError(w, http.StatusBadRequest, "order_id and area_id are required")
        return
    }

    // A/B test assignment
    variant := h.expManager.AssignVariant(req.UserID,
        &ABTestConfig{
            Name:       "pricing_v2_base_fee",
            TrafficPct: 50,
            Variants: []Variant{
                {Name: "control", Weight: 50, Config: PriceEngineConfig{BaseFee: 8000}},
                {Name: "variant_a", Weight: 25, Config: PriceEngineConfig{BaseFee: 10000}},
                {Name: "variant_b", Weight: 25, Config: PriceEngineConfig{BaseFee: 6000}},
            },
        })

    if variant != nil {
        if cfg, ok := variant.Config.(PriceEngineConfig); ok {
            h.engine.SetConfig(cfg)
        }
    }

    // Hitung fee
    breakdown, err := h.engine.CalculateFee(ctx, &req)
    if err != nil {
        slog.ErrorContext(ctx, "fee calculation failed", "order_id", req.OrderID, "error", err)
        writeError(w, http.StatusInternalServerError, "fee calculation failed")
        return
    }

    // Record for elasticity tracking
    h.elasticity.Record(ctx, req.AreaID, float64(breakdown.FinalFee), 1)

    // Record experiment conversion
    if variant != nil {
        h.expManager.RecordConversion(ctx, "pricing_v2_base_fee", variant.Name,
            req.OrderItemsTotal, float64(breakdown.FinalFee), true)
    }

    writeJSON(w, http.StatusOK, map[string]interface{}{
        "delivery_fee": breakdown.FinalFee,
        "breakdown":    breakdown,
        "message":      formatFeeMessage(breakdown),
    })
}

// HandleGetLockedPrice menangani GET /api/v1/locked-price?order_id=xxx.
// Dipanggil oleh payment service sebelum charge.
func (h *PricingHandler) HandleGetLockedPrice(w http.ResponseWriter, r *http.Request) {
    orderID := r.URL.Query().Get("order_id")
    if orderID == "" {
        writeError(w, http.StatusBadRequest, "order_id is required")
        return
    }

    ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
    defer cancel()

    fee, err := h.locker.GetLockedPrice(ctx, orderID)
    if err != nil {
        // Lock expired atau tidak ditemukan
        writeError(w, http.StatusGone, fmt.Sprintf("price lock expired: %v", err))
        return
    }

    writeJSON(w, http.StatusOK, map[string]interface{}{
        "order_id":     orderID,
        "locked_fee":   fee,
        "locked_at":    time.Now().Add(-15 * time.Minute), // Simplified
    })
}

func formatFeeMessage(breakdown *FeeBreakdown) string {
    if breakdown.SurgeActive {
        return fmt.Sprintf("Biaya antar Rp%d (termasuk surge %.1fx karena permintaan tinggi)",
            breakdown.FinalFee, breakdown.TotalMultiplier)
    }
    return fmt.Sprintf("Biaya antar Rp%d", breakdown.FinalFee)
}

func writeJSON(w http.ResponseWriter, status int, data interface{}) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(status)
    json.NewEncoder(w).Encode(data)
}

func writeError(w http.ResponseWriter, status int, msg string) {
    writeJSON(w, status, map[string]string{"error": msg})
}