Virtual Gifts

import Foundation
import AtomicXCore 
import Combine     

class GiftManager {
    private let liveId: String
    private let giftStore: GiftStore
    private var cancellables = Set<AnyCancellable>()
    
    // Expose gift events for the UI layer to subscribe and trigger animations
    let giftEventPublisher = PassthroughSubject<GiftEvent, Never>()
    // Expose gift list externally
    let giftListPublisher = CurrentValueSubject<[GiftCategory], Never>([])

    init(liveId: String) {
        self.liveId = liveId
        // 1. Obtain GiftStore instance using liveId
        self.giftStore = GiftStore.create(liveID: liveId)
        
        subscribeToGiftState()
        subscribeToGiftEvents()
    }

    /// 2. Subscribe to gift events
    private func subscribeToGiftEvents() {
        giftStore.giftEventPublisher
            .receive(on: DispatchQueue.main)
            .sink { [weak self] event in
                // Forward the event to the UI layer for handling
                self?.giftEventPublisher.send(event)
            }
            .store(in: &cancellables)
    }
    
    /// 3. Subscribe to gift list state
    private func subscribeToGiftState() {
        giftStore.state
            .subscribe(StatePublisherSelector(keyPath: \GiftState.usableGifts))
            .receive(on: DispatchQueue.main)
            .assign(to: \.value, on: giftListPublisher)
            .store(in: &cancellables)
    }
}

extension GiftManager {
    /// Refresh the gift list from the server
    func fetchGiftList() {
        giftStore.refreshUsableGifts { result in
            switch result {
            case .success:
                print("Gift list fetched successfully")
                // On success, data is automatically updated via the state subscription
            case .failure(let error):
                print("Failed to fetch gift list: \(error.localizedDescription)")
            }
        }
    }
}

extension GiftManager {
    /// User sends a gift
    func sendGift(giftID: String, count: UInt) {
        giftStore.sendGift(giftID: giftID, count: count) { result in
            switch result {
            case .success:
                print("Gift \(giftID) sent successfully")
                // After a successful send, everyone in the room, including the sender, will receive the onReceiveGift event
            case .failure(let error):
                print("Failed to send gift: \(error.localizedDescription)")
                // Prompt the user, e.g., "Insufficient balance" or "Network error"
            }
        }
    }
}

import UIKit
import AtomicXCore 
import Combine
import SVGAPlayer // 1. Import

class LiveRoomViewController: UIViewController, SVGAPlayerDelegate {
    private var giftManager: GiftManager!
    private var cancellables = Set<AnyCancellable>()
    private let svgaPlayer = SVGAPlayer() // 2. Prepare instance
    private let svgaParser = SVGAParser()

    override func viewDidLoad() {
        super.viewDidLoad()
        setupSVGAPlayer()
    }

    private func setupSVGAPlayer() {
        svgaPlayer.delegate = self
        svgaPlayer.loops = 1 // Play once by default
        svgaPlayer.clearsAfterStop = true // Automatically clear after playback
        view.addSubview(svgaPlayer)
        svgaPlayer.frame = view.bounds // Full screen by default
        svgaPlayer.isHidden = true
    }

    func setupGiftSubscription(liveId: String) {
        self.giftManager = GiftManager(liveId: liveId)

        giftManager.giftEventPublisher
            .sink { [weak self] event in // 3. Listen for events
                guard case .onReceiveGift(_, let gift, _, _) = event else { return }

                if !gift.resourceURL.isEmpty, let url = URL(string: gift.resourceURL) { // 4. Parse and play
                    self?.playAnimation(from: url)
                }
            }
            .store(in: &cancellables)
    }

    private func playAnimation(from url: URL) {
        svgaParser.parse(with: url, completionBlock: { [weak self] videoItem in
            guard let self = self, let videoItem = videoItem else { return }
            DispatchQueue.main.async {
                self.svgaPlayer.videoItem = videoItem
                self.svgaPlayer.isHidden = false
                self.svgaPlayer.startAnimation()
            }
        }, failureBlock: { error in
            print("Failed to parse SVGA animation: \(error?.localizedDescription ?? "unknown error")")
            // Add retry or error reporting logic as needed
        })
    }

    func svgaPlayerDidFinishedAnimation(_ player: SVGAPlayer!) { /* ... Handle end of playback ... */ }
}

// In LiveRoomManager or a similar top-level manager
private func setupGiftToBarrageFlow() {
    giftStore.giftEventPublisher
        .receive(on: DispatchQueue.main)
        .sink { [weak self] event in // 1. Listen for events
            guard case .onReceiveGift(_, let gift, let count, let sender) = event else { return } // 2. Extract information

            guard let self = self else { return }
            // 3. Get BarrageStore (assume barrageStore is already initialized)

            // 4. Compose message
            let tipText = "\(sender.userName) sent \(gift.name) x \(count)"
            var giftTip = Barrage()
            giftTip.messageType = .text 
            giftTip.textContent = tipText
            // Optional: set a special sender

            // 5. Insert locally
            self.barrageStore.appendLocalTip(message: giftTip)
        }
        .store(in: &cancellables)
}