Chat API

resp, err := client.GetChatters(ctx, &helix.GetChattersParams{
    BroadcasterID: "12345",
    ModeratorID:   "67890",
    PaginationParams: &helix.PaginationParams{
        First: 100,
    },
})

for _, chatter := range resp.Data {
    fmt.Printf("Chatter: %s (%s)\n", chatter.UserName, chatter.UserLogin)
}

resp, err := client.GetChannelEmotes(ctx, "12345")

for _, emote := range resp.Data {
    fmt.Printf("Emote: %s - %s\n", emote.Name, emote.ID)
}

resp, err := client.GetGlobalEmotes(ctx)

for _, emote := range resp.Data {
    fmt.Printf("Global Emote: %s - %s\n", emote.Name, emote.ID)
}

resp, err := client.GetEmoteSets(ctx, []string{"12345", "67890"})

for _, emote := range resp.Data {
    fmt.Printf("Emote: %s (Set: %s)\n", emote.Name, emote.EmoteSetID)
}

resp, err := client.GetChannelChatBadges(ctx, "12345")

for _, badgeSet := range resp.Data {
    fmt.Printf("Badge Set: %s\n", badgeSet.SetID)
    for _, version := range badgeSet.Versions {
        fmt.Printf("  Version %s: %s\n", version.ID, version.Title)
    }
}

resp, err := client.GetGlobalChatBadges(ctx)

for _, badgeSet := range resp.Data {
    fmt.Printf("Badge Set: %s\n", badgeSet.SetID)
    for _, version := range badgeSet.Versions {
        fmt.Printf("  Version %s: %s\n", version.ID, version.Title)
    }
}

// Channel role badges
helix.BadgeBroadcaster   // "broadcaster"
helix.BadgeModerator     // "moderator"
helix.BadgeLeadModerator // "lead_moderator"
helix.BadgeVIP           // "vip"

// Subscription badges
helix.BadgeSubscriber    // "subscriber"
helix.BadgeFounder       // "founder"
helix.BadgeSubGifter     // "sub-gifter"

// Bits badges
helix.BadgeBits          // "bits"
helix.BadgeBitsLeader    // "bits-leader"

// Twitch staff badges
helix.BadgeStaff         // "staff"
helix.BadgeAdmin         // "admin"
helix.BadgeGlobalMod     // "global_mod"

// Other badges
helix.BadgePartner       // "partner"
helix.BadgePremium       // "premium"
helix.BadgeArtist        // "artist"
helix.BadgePredictions   // "predictions"
helix.BadgeHypeTrain     // "hype-train"

// In an EventSub chat message handler
func handleChatMessage(event *helix.ChannelChatMessageEvent) {
    // Convert badges to use helper methods
    badges := helix.ToChatEventBadges(event.Badges)

    // Check for moderator privileges (handles both moderator and lead_moderator)
    if badges.HasModeratorPrivileges() {
        fmt.Printf("%s is a moderator\n", event.ChatterUserName)
    }

    // Check for broadcaster
    if badges.HasBroadcasterPrivileges() {
        fmt.Printf("%s is the broadcaster\n", event.ChatterUserName)
    }

    // Check for VIP
    if badges.HasVIPStatus() {
        fmt.Printf("%s is a VIP\n", event.ChatterUserName)
    }

    // Check for subscriber (includes founders)
    if badges.IsSubscriber() {
        fmt.Printf("%s is a subscriber\n", event.ChatterUserName)
    }

    // Check for Twitch staff (staff, admin, global_mod)
    if badges.IsStaff() {
        fmt.Printf("%s is Twitch staff\n", event.ChatterUserName)
    }
}

// OLD: Only checks for moderator badge (misses Lead Moderators)
func isModeratorOld(badges []helix.ChatEventBadge) bool {
    for _, badge := range badges {
        if badge.SetID == "moderator" {
            return true
        }
    }
    return false
}

// NEW: Properly checks for both moderator and lead_moderator
func isModeratorNew(badges []helix.ChatEventBadge) bool {
    return helix.ToChatEventBadges(badges).HasModeratorPrivileges()
}

// Get chat settings
resp, err := client.GetChatSettings(ctx, "12345", "")

// Get chat settings with moderator context
resp, err = client.GetChatSettings(ctx, "12345", "67890")

settings := resp.Data[0]
fmt.Printf("Slow Mode: %v (%d seconds)\n", settings.SlowMode, settings.SlowModeWaitTime)
fmt.Printf("Follower Mode: %v (%d minutes)\n", settings.FollowerMode, settings.FollowerModeDuration)
fmt.Printf("Subscriber Mode: %v\n", settings.SubscriberMode)

emoteMode := true
followerMode := true
followerModeDuration := 10
nonModDelay := true
nonModDelayDuration := 2
slowMode := true
slowModeWaitTime := 30
subMode := false
uniqueChat := true

resp, err := client.UpdateChatSettings(ctx, &helix.UpdateChatSettingsParams{
    BroadcasterID:                 "12345",
    ModeratorID:                   "67890",
    EmoteMode:                     &emoteMode,
    FollowerMode:                  &followerMode,
    FollowerModeDuration:          &followerModeDuration, // 10 minutes
    NonModeratorChatDelay:         &nonModDelay,
    NonModeratorChatDelayDuration: &nonModDelayDuration, // 2 seconds
    SlowMode:                      &slowMode,
    SlowModeWaitTime:              &slowModeWaitTime, // 30 seconds
    SubscriberMode:                &subMode,
    UniqueChatMode:                &uniqueChat,
})

settings := resp.Data[0]
fmt.Printf("Chat settings updated: Slow Mode %v, Follower Mode %v\n",
    settings.SlowMode, settings.FollowerMode)

// Send an announcement with default color
err := client.SendChatAnnouncement(ctx, &helix.SendChatAnnouncementParams{
    BroadcasterID: "12345",
    ModeratorID:   "67890",
    Message:       "Welcome to the stream! Don't forget to follow!",
})

// Send a colored announcement
err = client.SendChatAnnouncement(ctx, &helix.SendChatAnnouncementParams{
    BroadcasterID: "12345",
    ModeratorID:   "67890",
    Message:       "Important update coming soon!",
    Color:         "purple", // blue, green, orange, purple, or primary
})

err := client.SendShoutout(ctx, &helix.SendShoutoutParams{
    FromBroadcasterID: "12345",
    ToBroadcasterID:   "67890",
    ModeratorID:       "12345",
})

if err != nil {
    fmt.Printf("Failed to send shoutout: %v\n", err)
}

resp, err := client.GetUserChatColor(ctx, []string{"12345", "67890"})

for _, userColor := range resp.Data {
    fmt.Printf("User %s has color: %s\n", userColor.UserID, userColor.Color)
}

// Update to a named color
err := client.UpdateUserChatColor(ctx, "12345", "blue")

// Update to a custom hex color (Turbo/Prime users only)
err = client.UpdateUserChatColor(ctx, "12345", "#9146FF")

// Send a regular message
resp, err := client.SendChatMessage(ctx, &helix.SendChatMessageParams{
    BroadcasterID: "12345",
    SenderID:      "67890",
    Message:       "Hello, chat!",
})

// Send a reply to another message
resp, err = client.SendChatMessage(ctx, &helix.SendChatMessageParams{
    BroadcasterID:        "12345",
    SenderID:             "67890",
    Message:              "That's a great point!",
    ReplyParentMessageID: "abc-123-def",
})

if resp.IsSent {
    fmt.Printf("Message sent: %s\n", resp.MessageID)
}

resp, err := client.GetSharedChatSession(ctx, "12345")

if resp != nil {
    fmt.Printf("Session ID: %s\n", resp.SessionID)
    fmt.Printf("Host Broadcaster: %s\n", resp.HostBroadcasterID)
    for _, participant := range resp.Participants {
        fmt.Printf("Participant: %s\n", participant.BroadcasterID)
    }
}

// Get all emotes for a user
resp, err := client.GetUserEmotes(ctx, &helix.GetUserEmotesParams{
    UserID: "12345",
    PaginationParams: &helix.PaginationParams{
        First: 100,
    },
})

// Get emotes for a user in a specific broadcaster's context
resp, err = client.GetUserEmotes(ctx, &helix.GetUserEmotesParams{
    UserID:        "12345",
    BroadcasterID: "67890",
    PaginationParams: &helix.PaginationParams{
        First: 50,
    },
})

for _, emote := range resp.Data {
    fmt.Printf("Emote: %s - %s (Type: %s)\n", emote.Name, emote.ID, emote.EmoteType)
}