import com.amity.socialcloud.sdk.AmityClient
import com.amity.socialcloud.sdk.model.social.reaction.*

class ReactionQueryManager(private val client: AmityClient) {
    private val reactionRepository = AmityReactionRepository(client)
    
    fun queryReactions(
        referenceType: AmityReactionReferenceType,
        referenceId: String,
        reactionName: String? = null
    ): Flowable<PagingData<AmityReaction>> {
        return reactionRepository.getReactions(
            referenceType = referenceType,
            referenceId = referenceId,
            reactionName = reactionName
        )
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .doOnNext { pagingData ->
            Log.d("ReactionQuery", "Loaded ${pagingData.size} reactions")
        }
    }
    
    fun queryPostReactions(postId: String): Flowable<PagingData<AmityReaction>> {
        return queryReactions(
            referenceType = AmityReactionReferenceType.POST,
            referenceId = postId
        )
    }
    
    fun queryCommentReactions(commentId: String): Flowable<PagingData<AmityReaction>> {
        return queryReactions(
            referenceType = AmityReactionReferenceType.COMMENT,
            referenceId = commentId
        )
    }
}

import { AmityClient, ReactionReferenceType, Reaction } from '@amityco/ts-sdk';

class ReactionQueryManager {
    constructor(private client: AmityClient) {}
    
    async queryReactions(
        referenceType: ReactionReferenceType,
        referenceId: string,
        options?: {
            reactionName?: string;
            limit?: number;
            sortOrder?: 'asc' | 'desc';
        }
    ): Promise<Reaction[]> {
        try {
            const reactions = await this.client.getReactions({
                referenceType,
                referenceId,
                reactionName: options?.reactionName,
                limit: options?.limit || 50,
                sortOrder: options?.sortOrder || 'desc'
            });
            
            console.log(`Loaded ${reactions.length} reactions for ${referenceType}:${referenceId}`);
            return reactions;
        } catch (error) {
            console.error('Failed to query reactions:', error);
            throw error;
        }
    }
    
    async getReactionSummary(
        referenceType: ReactionReferenceType,
        referenceId: string
    ): Promise<ReactionSummary> {
        const reactions = await this.queryReactions(referenceType, referenceId);
        
        const summary = {
            totalReactions: reactions.length,
            reactionCounts: this.groupReactionsByType(reactions),
            topReactors: this.getTopReactors(reactions),
            myReactions: this.getMyReactions(reactions)
        };
        
        return summary;
    }
    
    private groupReactionsByType(reactions: Reaction[]): Record<string, number> {
        return reactions.reduce((acc, reaction) => {
            acc[reaction.reactionName] = (acc[reaction.reactionName] || 0) + 1;
            return acc;
        }, {} as Record<string, number>);
    }
    
    private getTopReactors(reactions: Reaction[], limit: number = 5): Reactor[] {
        const reactorCounts = reactions.reduce((acc, reaction) => {
            const reactor = acc.find(r => r.userId === reaction.reactorId);
            if (reactor) {
                reactor.reactionCount++;
            } else {
                acc.push({
                    userId: reaction.reactorId,
                    displayName: reaction.reactorDisplayName,
                    reactionCount: 1
                });
            }
            return acc;
        }, [] as Reactor[]);
        
        return reactorCounts
            .sort((a, b) => b.reactionCount - a.reactionCount)
            .slice(0, limit);
    }
    
    private getMyReactions(reactions: Reaction[]): string[] {
        const currentUserId = this.client.getCurrentUser()?.userId;
        return reactions
            .filter(reaction => reaction.reactorId === currentUserId)
            .map(reaction => reaction.reactionName);
    }
}

interface ReactionSummary {
    totalReactions: number;
    reactionCounts: Record<string, number>;
    topReactors: Reactor[];
    myReactions: string[];
}

interface Reactor {
    userId: string;
    displayName: string;
    reactionCount: number;
}

import 'package:amity_sdk/amity_sdk.dart';

class ReactionQueryManager {
    
    Future<List<AmityReaction>> queryReactions({
        required String referenceType,
        required String referenceId,
        String? reactionName,
        int? limit,
    }) async {
        try {
            // Query reactions based on reference type
            switch (referenceType.toLowerCase()) {
                case 'post':
                    return await _queryPostReactions(referenceId, reactionName, limit);
                case 'comment':
                    return await _queryCommentReactions(referenceId, reactionName, limit);
                case 'story':
                    return await _queryStoryReactions(referenceId, reactionName, limit);
                case 'message':
                    return await _queryMessageReactions(referenceId, reactionName, limit);
                default:
                    throw ArgumentError('Unsupported reference type: $referenceType');
            }
        } catch (error) {
            print('Failed to query reactions: $error');
            rethrow;
        }
    }
    
    Future<List<AmityReaction>> _queryPostReactions(
        String postId, 
        String? reactionName, 
        int? limit
    ) async {
        final query = AmityReactionRepository().getReactions(
            referenceType: AmityReactionReferenceType.POST,
            referenceId: postId,
            reactionName: reactionName,
        );
        
        // Apply limit if specified
        if (limit != null) {
            query.limit(limit);
        }
        
        final snapshot = await query.get();
        return snapshot.data;
    }
    
    Future<List<AmityReaction>> _queryCommentReactions(
        String commentId, 
        String? reactionName, 
        int? limit
    ) async {
        final query = AmityReactionRepository().getReactions(
            referenceType: AmityReactionReferenceType.COMMENT,
            referenceId: commentId,
            reactionName: reactionName,
        );
        
        if (limit != null) {
            query.limit(limit);
        }
        
        final snapshot = await query.get();
        return snapshot.data;
    }
    
    Future<ReactionSummary> getReactionSummary({
        required String referenceType,
        required String referenceId,
    }) async {
        final reactions = await queryReactions(
            referenceType: referenceType,
            referenceId: referenceId,
        );
        
        return _generateSummary(reactions);
    }
    
    ReactionSummary _generateSummary(List<AmityReaction> reactions) {
        final reactionCounts = <String, int>{};
        final uniqueReactors = <String>{};
        
        for (final reaction in reactions) {
            // Count reactions by type
            reactionCounts[reaction.reactionName] = 
                (reactionCounts[reaction.reactionName] ?? 0) + 1;
            
            // Track unique reactors
            uniqueReactors.add(reaction.reactorId);
        }
        
        // Find most popular reaction
        String? mostPopular;
        int maxCount = 0;
        reactionCounts.forEach((reaction, count) {
            if (count > maxCount) {
                maxCount = count;
                mostPopular = reaction;
            }
        });
        
        return ReactionSummary(
            totalReactions: reactions.length,
            uniqueReactors: uniqueReactors.length,
            reactionBreakdown: reactionCounts,
            mostPopularReaction: mostPopular,
        );
    }
}

class ReactionSummary {
    final int totalReactions;
    final int uniqueReactors;
    final Map<String, int> reactionBreakdown;
    final String? mostPopularReaction;
    
    const ReactionSummary({
        required this.totalReactions,
        required this.uniqueReactors,
        required this.reactionBreakdown,
        this.mostPopularReaction,
    });
    
    @override
    String toString() {
        return 'ReactionSummary(total: $totalReactions, unique: $uniqueReactors, '
               'popular: $mostPopularReaction, breakdown: $reactionBreakdown)';
    }
}