import 'package:atomic_x_core/atomicxcore.dart';

class AudienceManager {
    final String liveId;
    late final LiveAudienceStore audienceStore;
    late LiveAudienceListener _audienceListener;
    late final VoidCallback _audienceListChangedListener = _onAudienceListChanged;
    late final VoidCallback _audienceCountChangedListener = _onAudienceCountChanged;

    // Externally exposed [full] audience list
    List<LiveUserInfo> audienceList = [];
    // Externally exposed total audience count
    int audienceCount = 0;

    // Status change callback
    Function()? onStateChanged;

    AudienceManager({required this.liveId}) {
        // 1. Retrieve an instance of LiveAudienceStore by liveId
        audienceStore = LiveAudienceStore.create(liveId);

        // 2. Subscribe to status and events
        _subscribeToAudienceState();
        _subscribeToAudienceEvents();

        // 3. Actively pull first screen data
        fetchInitialAudienceList();
    }

    /// Proactively retrieve an audience list snapshot once
    Future<void> fetchInitialAudienceList() async {
        final result = await audienceStore.fetchAudienceList();
        if (result.isSuccess) {
            print("First pull audience list successfully");
            // Upon success, data will be auto-updated via the state subscription channel below
        } else {
            print("First pull audience list failed: ${result.errorMessage}");
        }
    }

    void dispose() {
        audienceStore.liveAudienceState.audienceList.removeListener(_audienceListChangedListener);
        audienceStore.liveAudienceState.audienceCount.removeListener(_audienceCountChangedListener);
        audienceStore.removeLiveAudienceListener(_audienceListener);
    }
}

extension AudienceManagerSubscription on AudienceManager {
    /// Subscribe to state to obtain the total count of audience and list snapshots
    void _subscribeToAudienceState() {
        // Listen to audience list adjustments
        audienceStore.liveAudienceState.audienceList.addListener(_audienceListChangedListener);
        // Listen to audience change rate
        audienceStore.liveAudienceState.audienceCount.addListener(_audienceCountChangedListener);
    }

    void _onAudienceListChanged() {
        // audienceList is a full snapshot
        audienceList = audienceStore.liveAudienceState.audienceList.value;
        onStateChanged?.call();
    }

    void _onAudienceCountChanged() {
        // audienceCount is the real-time total count
        audienceCount = audienceStore.liveAudienceState.audienceCount.value;
        onStateChanged?.call();
    }

    /// Subscribe to events for processing real-time audience entry and exit
    void _subscribeToAudienceEvents() {
        _audienceListener = LiveAudienceListener(
            onAudienceJoined: (audience) {
                print("Audience ${audience.userName} joined the live streaming room");
                // Incremental update: Add new audience at the end of the current list
                if (!audienceList.any((a) => a.userID == audience.userID)) {
                    audienceList.add(audience);
                    onStateChanged?.call();
                }
            },
            onAudienceLeft: (audience) {
                print("Audience ${audience.userName} left the live streaming room");
                // Incremental update: Remove leaving audience from the current list
                audienceList.removeWhere((a) => a.userID == audience.userID);
                onStateChanged?.call();
            },
        );
        audienceStore.addLiveAudienceListener(_audienceListener);
    }
}

extension AudienceManagerActions on AudienceManager {
    Future<void> kick(String userId) async {
        final result = await audienceStore.kickUserOutOfRoom(userId);
        if (result.isSuccess) {
            print("Successfully kicked user $userId out of room");
            // Upon success, you will receive the onAudienceLeft event
        } else {
            print("Failed to kick out user $userId: ${result.errorMessage}");
        }
    }
}

extension AudienceManagerAdmin on AudienceManager {
    /// Set the user as administrator
    Future<void> promoteToAdmin(String userId) async {
        final result = await audienceStore.setAdministrator(userId);
        if (result.isSuccess) {
            print("Successfully set user $userId as administrator");
        }
    }

    /// Revoke the user's administrator privileges
    Future<void> revokeAdmin(String userId) async {
        final result = await audienceStore.revokeAdministrator(userId);
        if (result.isSuccess) {
            print("Successfully revoked user $userId's administrator privileges");
        }
    }
}

import 'package:atomic_x_core/atomicxcore.dart';

class LiveRoomManager {
    final String liveId;
    late LiveAudienceListener _welcomeListener;

    LiveRoomManager({required this.liveId}) {
        _setupWelcomeMessageFlow();
    }

    void _setupWelcomeMessageFlow() {
        // 1. Retrieve an instance of LiveAudienceStore
        final audienceStore = LiveAudienceStore.create(liveId);

        // 2. Retrieve an instance of BarrageStore (thanks to the internal mechanism, this will be the same instance)
        final barrageStore = BarrageStore.create(liveId);

        // 3. Subscribe to audience events
        _welcomeListener = LiveAudienceListener(
            onAudienceJoined: (audience) {
                // 4. Create a local Prompt message
                final welcomeTip = Barrage(
                    messageType: BarrageType.text,
                    textContent: "Welcome ${audience.userName} to the live streaming room."
                );

                // 5. Call the BarrageStore API to insert it into the bullet screen list
                barrageStore.appendLocalTip(welcomeTip);
            },
        );
        audienceStore.addLiveAudienceListener(_welcomeListener);
    }

    void dispose() {
        final audienceStore = LiveAudienceStore.create(liveId);
        audienceStore.removeLiveAudienceListener(_welcomeListener);
    }
}