package main

import (
    "fmt"
    "time"
    
    "github.com/nayarsystems/pubsub-go/ps"
)

func main() {
    // Create a new pub/sub instance
    pubsub := ps.New()
    
    // Create a subscriber
    sub := pubsub.Sub("user.login")
    
    // Publish a message
    pubsub.Pub("Hello, World!", "user.login")
    
    // Receive the message
    msg := sub.Get(time.Second)
    if msg != nil {
        fmt.Printf("Received: %v\n", msg.Data)
    }
}

pubsub := ps.New()

// Subscribe to parent topic
sub := pubsub.Sub("events")

// Messages to child topics are delivered to parent subscribers
pubsub.Pub("User logged in", "events.user.login")
pubsub.Pub("Order created", "events.order.create")

// Both messages will be received by the "events" subscriber
for i := 0; i < 2; i++ {
    msg := sub.Get(time.Second)
    fmt.Printf("Event: %v on topic: %s\n", msg.Data, msg.To)
}

pubsub := ps.New()

// Publish a sticky message (persists until cleared)
pubsub.PubSticky("System ready", "status")

// New subscribers immediately receive sticky messages
sub := pubsub.Sub("status")
msg := sub.Get(time.Second)
fmt.Printf("Status: %v (sticky: %v)\n", msg.Data, msg.Old)

pubsub := ps.New()

// Subscriber that responds to requests
go func() {
    sub := pubsub.Sub("math.add")
    for {
        msg := sub.Get(time.Hour)
        if msg == nil {
            break
        }
        
        // Process request and send response
        nums := msg.Data.([]int)
        result := nums[0] + nums[1]
        pubsub.Pub(result, msg.Res)
    }
}()

// Make a request and wait for response
result, err := pubsub.Call([]int{5, 3}, "math.add", time.Second)
if err == nil {
    fmt.Printf("5 + 3 = %v\n", result)
}

pubsub := ps.New()

// Subscribe with flags:
// 'S' - receive sticky messages from topic and children
// 'r' - rotate queue when full (drop oldest messages)
sub := pubsub.SubFlag("events", "Sr")

// Subscribe as hidden (doesn't count in delivery statistics)
hiddenSub := pubsub.SubFlag("events", "h")

// Skip sticky messages for this topic
noStickySub := pubsub.SubFlag("events", "s")

import "context"

pubsub := ps.New()
sub := pubsub.Sub("data")

// Use context for cancellation
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

msg := sub.GetWithCtx(ctx)
if msg != nil {
    fmt.Printf("Received: %v\n", msg.Data)
}

pubsub := ps.New()

// Monitor subscription events
eventSub := pubsub.Sub("$events")

go func() {
    for {
        msg := eventSub.Get(time.Hour)
        if msg == nil {
            break
        }
        
        event := msg.Data.(ps.HasSubsEvent)
        fmt.Printf("Topic %s now has %d subscribers\n", 
            event.Topic, event.Count)
    }
}()

// Create subscriptions (will trigger events)
sub1 := pubsub.Sub("notifications")
sub2 := pubsub.Sub("notifications")