import 'dart:async';
import 'package:flutter_bloc/flutter_bloc.dart';
import '../../domain/entities/chat.dart';
import '../../domain/entities/message.dart';
import '../../domain/repositories/chat_repository.dart';
import 'chat_event.dart';
import 'chat_state.dart';

class ChatBloc extends Bloc<ChatEvent, ChatState> {
  final ChatRepository chatRepository;
  StreamSubscription? _messageSubscription;
  StreamSubscription? _typingSubscription;

  ChatBloc({required this.chatRepository}) : super(const ChatState.initial()) {
    on<ChatEventStarted>(_onStarted);
    on<ChatEventChatsLoaded>(_onChatsLoaded);
    on<ChatEventChatSelected>(_onChatSelected);
    on<ChatEventMessagesRequested>(_onMessagesRequested);
    on<ChatEventMessageSent>(_onMessageSent);
    on<ChatEventFavoritesRequested>(_onFavoritesRequested);
    on<ChatEventTypingUpdated>(_onTypingUpdated);
    on<ChatEventSendTypingStatus>(_onSendTypingStatus);
    on<ChatEventCacheCleared>(_onCacheCleared);
    
    _messageSubscription = chatRepository.messageStream.listen((message) {
      add(ChatEvent.messagesRequested(message.chatId));
    });

    _typingSubscription = chatRepository.typingStream.listen((data) {
      add(ChatEvent.typingUpdated(data['chatId'], data['userId'], data['isTyping']));
    });
  }

  Future<void> _onStarted(ChatEventStarted event, Emitter<ChatState> emit) async {
    // ignore: avoid_print
    print('[DEBUG] ChatBloc._onStarted for user: ${event.userId}');
    // Start SignalR in background
    chatRepository.initSignalR().catchError((e) {
      // Log or handle SignalR init error
    });
    // Immediately trigger chats loading
    add(ChatEvent.chatsLoaded(currentUserId: event.userId));
    add(const ChatEvent.favoritesRequested());
  }

  Future<void> _onChatsLoaded(ChatEventChatsLoaded event, Emitter<ChatState> emit) async {
    emit(const ChatState.loading());
    final result = await chatRepository.getChats(currentUserId: event.currentUserId);
    result.fold(
      (error) => emit(ChatState.error(error.message ?? 'Failed to load chats')),
      (chats) => emit(ChatState.chatsLoaded(chats)),
    );
  }

  Future<void> _onChatSelected(ChatEventChatSelected event, Emitter<ChatState> emit) async {
    emit(const ChatState.loading());
    final chatResult = await chatRepository.getChatById(event.chatId);
    final messagesResult = await chatRepository.getMessages(event.chatId);
    
    chatResult.fold(
      (error) => emit(ChatState.error(error.message ?? 'Failed to load chat')),
      (chat) {
        messagesResult.fold(
          (error) => emit(ChatState.chatSelected(chat, [])),
          (messages) => emit(ChatState.chatSelected(chat, messages)),
        );
      },
    );
  }

  Future<void> _onMessagesRequested(ChatEventMessagesRequested event, Emitter<ChatState> emit) async {
    final result = await chatRepository.getMessages(event.chatId);
    result.fold(
      (error) => emit(ChatState.error(error.message ?? 'Failed to load messages')),
      (messages) => emit(ChatState.messagesLoaded(messages)),
    );
  }

  Future<void> _onMessageSent(ChatEventMessageSent event, Emitter<ChatState> emit) async {
    final result = await chatRepository.sendMessage(event.chatId, event.content);
    result.fold(
      (error) => emit(ChatState.error(error.message ?? 'Failed to send message')),
      (_) => add(ChatEvent.messagesRequested(event.chatId)),
    );
  }

  Future<void> _onFavoritesRequested(ChatEventFavoritesRequested event, Emitter<ChatState> emit) async {
    emit(const ChatState.loading());
    final result = await chatRepository.getOrCreateFavorites();
    result.fold(
      (error) => emit(ChatState.error(error.message ?? 'Failed to open Favorites')),
      (chat) => add(ChatEvent.chatSelected(chat.id)),
    );
  }

  Future<void> _onTypingUpdated(ChatEventTypingUpdated event, Emitter<ChatState> emit) async {
    final Map<String, Set<String>> newTypingUsers = Map.from(state.typingUsers);
    final Set<String> chatTypingUsers = Set.from(newTypingUsers[event.chatId] ?? {});
    
    if (event.isTyping) {
      chatTypingUsers.add(event.userId);
    } else {
      chatTypingUsers.remove(event.userId);
    }
    
    if (chatTypingUsers.isEmpty) {
      newTypingUsers.remove(event.chatId);
    } else {
      newTypingUsers[event.chatId] = chatTypingUsers;
    }
    
    emit(state.copyWith(typingUsers: newTypingUsers));
  }

  Future<void> _onSendTypingStatus(ChatEventSendTypingStatus event, Emitter<ChatState> emit) async {
    await chatRepository.sendTypingStatus(event.chatId, event.isTyping);
  }

  Future<void> _onCacheCleared(ChatEventCacheCleared event, Emitter<ChatState> emit) async {
    // ignore: avoid_print
    print('[DEBUG] ChatBloc._onCacheCleared START');
    await chatRepository.clearCache();
    // ignore: avoid_print
    print('[DEBUG] ChatBloc._onCacheCleared END');
    emit(const ChatState.initial());
  }

  @override
  Future<void> close() {
    _messageSubscription?.cancel();
    _typingSubscription?.cancel();
    chatRepository.disposeSignalR();
    return super.close();
  }
}