type RateLimiter struct {
    mu         sync.Mutex
    limits     map[string]*UserLimit
    maxRequests int
    window      time.Duration
}

type UserLimit struct {
    count     int
    windowStart time.Time
}

func NewRateLimiter(max int, window time.Duration) *RateLimiter {
    return &RateLimiter{
        limits:      make(map[string]*UserLimit),
        maxRequests: max,
        window:      window,
    }
}

func (rl *RateLimiter) Allow(userID string) bool {
    rl.mu.Lock()
    defer rl.mu.Unlock()

    now := time.Now()
    if ul, exists := rl.limits[userID]; exists {
        // Check if window expired
        if now.Sub(ul.windowStart) > rl.window {
            ul.windowStart = now
            ul.count = 1
            return true
        }
        // If within window and count is below limit
        if ul.count < rl.maxRequests {
            ul.count++
            return true
        }
        return false
    }
    // New user: initialize
    rl.limits[userID] = &UserLimit{
        count:       1,
        windowStart: now,
    }
    return true
}

// Define a Vote structure
type Vote struct {
    UserID    string
    OptionID  string
    Timestamp time.Time
}

// Imagine a function that records or updates a vote
func RecordVote(vote Vote) error {
    // Pseudocode: check if user has an existing vote
    existing, err := db.GetVote(vote.UserID)
    if err != nil {
        return err
    }
    if existing != nil {
        // update the vote if different
        if existing.OptionID != vote.OptionID {
            db.UpdateVote(vote)
        }
    } else {
        db.InsertVote(vote)
    }
    // Recompute and publish new vote counts
    publishVoteCounts()
    return nil
}