tencent cloud

import Foundation
import AtomicXCore // Import the core library
import Combine     // For reactive programming

class BarrageManager {
    private let liveId: String
    private let barrageStore: BarrageStore
    private var cancellables = Set<AnyCancellable>()
    
    // Publisher for the complete message list, for UI layer subscription
    let messagesPublisher = PassthroughSubject<[Barrage], Never>()
    
    init(liveId: String) {
        self.liveId = liveId
        // 1. Obtain the BarrageStore singleton for the given liveId
        self.barrageStore = BarrageStore.create(liveID: liveId)
        // 2. Start listening for barrage messages immediately after initialization
        subscribeToBarrageUpdates()
    }
    
    private func subscribeToBarrageUpdates() {
        barrageStore.state
            .subscribe() // Subscribe to all BarrageState changes
            .receive(on: DispatchQueue.main) // Ensure main thread for UI safety
            .sink { [weak self] barrageState in
                // 3. Forward the updated message list to the UI layer
                // Note: This provides the complete list, including all historical messages
                self?.messagesPublisher.send(barrageState.messageList)
            }
            .store(in: &cancellables) // Manage subscription lifecycle
    }


extension BarrageManager {
    /// Send a text barrage message
    func sendTextMessage(text: String) {
        // Prevent sending empty messages
        guard !text.isEmpty else {
            print("Barrage content cannot be empty")
            return
        }
        
        // Send the message using the core API
        barrageStore.sendTextMessage(text: text, extensionInfo: nil) { result in
            // Handle the result in the callback, e.g., show a prompt to the user
            switch result {
            case .success:
                print("Text barrage '\\(text)' sent successfully")
            case .failure(let error):
                print("Failed to send text barrage: \\(error.localizedDescription)")
            }
        }
    }
}

extension BarrageManager {
    /// Send a custom barrage, e.g., for sending gifts
    func sendGiftMessage(giftId: String, giftCount: Int) {
        // 1. Define a business-recognizable ID
        let businessId = "live_gift"
        
        // 2. Encode business data as a JSON string
        let giftData: [String: Any] = ["gift_id": giftId, "gift_count": giftCount]
        guard let jsonData = try? JSONSerialization.data(withJSONObject: giftData),
              let jsonString = String(data: jsonData, encoding: .utf8) else {
            print("Failed to encode gift data as JSON")
            return
        }
        
        // 3. Send the custom message using the core API
        barrageStore.sendCustomMessage(businessID: businessId, data: jsonString) { result in
            switch result {
            case .success:
                print("Gift message (custom barrage) sent successfully")
            case .failure(let error):
                print("Failed to send gift message: \\(error.localizedDescription)")
            }
        }
    }
}

extension BarrageManager {
    /// Insert a welcome tip into the local message list
    func showWelcomeMessage(for user: LiveUserInfo) {
        // 1. Create a Barrage message
        var welcomeTip = Barrage()
        welcomeTip.messageType = .text // Reuse the text type for display
        welcomeTip.textContent = "Welcome \\(user.userName) to the live room!"
        // sender can be left empty or set to a system user identifier
        
        // 2. Insert the message into the local list
        barrageStore.appendLocalTip(message: welcomeTip)
    }
}

import AtomicXCore

// 1. Get the LiveAudienceStore instance for the current live room
let audienceStore = LiveAudienceStore.create(liveID: "your_live_id")

// 2. Specify the user ID and mute status
let userIdToMute = "user_id_to_be_muted"
let shouldDisable = true // true to mute, false to unmute

// 3. Call the API to perform the operation
audienceStore.disableSendMessage(userID: userIdToMute, isDisable: shouldDisable) { [weak self] result in
    guard let self = self else { return }
    switch result {
    case .success:
        print("\\(shouldDisable ? "Muted" : "Unmuted") user \\(userIdToMute) successfully")
    case .failure(let error):
        print("Operation failed: \\(error.localizedDescription)")
    }
}

import AtomicXCore

// 1. Get the LiveListStore singleton
let liveListStore = LiveListStore.shared

// 2. Get the current live room info and modify the global mute status
var currentLiveInfo = liveListStore.state.value.currentLive 
currentLiveInfo.isMessageDisable = true // true to enable global mute, false to disable

// 3. Call the update API and specify the modify flag
liveListStore.updateLiveInfo(currentLiveInfo, modifyFlag: .isMessageDisable) { result in
    switch result {
    case .success:
        print("Global mute status updated successfully")
    case .failure(let error):
        print("Operation failed: \\(error.localizedDescription)")
    }
}

class BarrageUIManager {
    private var latestMessageList: [BarrageViewModel]?
    private var refreshTimer: Timer?
    private weak var tableView: UITableView?
    private var dataSource: [BarrageViewModel] = []

    init(tableView: UITableView) {
        self.tableView = tableView
        // Check every 0.3 seconds if a refresh is needed
        self.refreshTimer = Timer.scheduledTimer(withTimeInterval: 0.3, repeats: true) { [weak self] _ in
            self?.refreshUIIfNeeded()
        }
    }

    /// Frequently called from outside, passing in the latest full list
    func update(with fullList: [BarrageViewModel]) {
        self.latestMessageList = fullList
    }

    private func refreshUIIfNeeded() {
        // Check if there is new data to refresh
        guard let newList = self.latestMessageList, let tableView = self.tableView else { return }
        self.latestMessageList = nil // Clear the flag to avoid repeated refreshes

        // Update the data source and refresh the UI
        self.dataSource = newList
        tableView.reloadData()
    }

    deinit {
        refreshTimer?.invalidate()
    }
}

class BarrageUIManager {
    private let capacity: Int = 500 // Retain only the latest 500 messages
    // ... (other code as above) ...

    private func refreshUIIfNeeded() {
        guard let fullList = self.latestMessageList, let tableView = self.tableView else { return }
        self.latestMessageList = nil 

        // Only keep the latest N messages
        let cappedList = Array(fullList.suffix(self.capacity))

        self.dataSource = cappedList
        tableView.reloadData()
    }
}

import UIKit

// In your custom barrage cell
class BarrageCell: UITableViewCell {

    // ... (UILabel, UIImageView, and other subview declarations)

    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
        super.init(style: style, reuseIdentifier: reuseIdentifier)

        // Enable asynchronous drawing
        self.layer.drawsAsynchronously = true
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    func configure(with viewModel: BarrageViewModel) {
        // Set label text, images, etc.
        // With asynchronous drawing enabled, rendering occurs on a background thread when possible
    }

    // Advanced: fully manual drawing
    override func draw(_ rect: CGRect) {
        // For finer control, manually draw text and images here using Core Graphics
        // Combine generating UIImage on a background thread, then draw it in the main thread's draw method for fully asynchronous rendering
    }
}