geutebruck/geutebruck_app/lib/presentation/blocs/server/server_bloc.dart

import 'package:flutter_bloc/flutter_bloc.dart';
import 'server_event.dart';
import 'server_state.dart';
import '../../../domain/repositories/server_repository.dart';
import '../../../data/services/sync_service.dart';

class ServerBloc extends Bloc<ServerEvent, ServerState> {
  final ServerRepository serverRepository;

  ServerBloc({required this.serverRepository}) : super(const ServerInitial()) {
    on<LoadServers>(_onLoadServers);
    on<LoadGCoreServers>(_onLoadGCoreServers);
    on<LoadGeViScopeServers>(_onLoadGeViScopeServers);
    on<CreateServerEvent>(_onCreateServer);
    on<UpdateServerEvent>(_onUpdateServer);
    on<DeleteServerEvent>(_onDeleteServer);
    on<SyncServersEvent>(_onSyncServers);
    on<DownloadServersEvent>(_onDownloadServers);
    on<CheckDirtyCountEvent>(_onCheckDirtyCount);
  }

  Future<void> _onLoadServers(
    LoadServers event,
    Emitter<ServerState> emit,
  ) async {
    emit(const ServerLoading());

    final result = await serverRepository.getAllServers();
    final dirtyCountResult = await serverRepository.getDirtyCount();

    result.fold(
      (failure) => emit(ServerError(failure.message)),
      (servers) {
        final dirtyCount = dirtyCountResult.fold((_) => 0, (count) => count);
        emit(ServerLoaded(servers, dirtyCount: dirtyCount));
      },
    );
  }

  Future<void> _onLoadGCoreServers(
    LoadGCoreServers event,
    Emitter<ServerState> emit,
  ) async {
    emit(const ServerLoading());

    final result = await serverRepository.getGCoreServers();
    final dirtyCountResult = await serverRepository.getDirtyCount();

    result.fold(
      (failure) => emit(ServerError(failure.message)),
      (servers) {
        final dirtyCount = dirtyCountResult.fold((_) => 0, (count) => count);
        emit(ServerLoaded(servers, dirtyCount: dirtyCount));
      },
    );
  }

  Future<void> _onLoadGeViScopeServers(
    LoadGeViScopeServers event,
    Emitter<ServerState> emit,
  ) async {
    emit(const ServerLoading());

    final result = await serverRepository.getGeViScopeServers();
    final dirtyCountResult = await serverRepository.getDirtyCount();

    result.fold(
      (failure) => emit(ServerError(failure.message)),
      (servers) {
        final dirtyCount = dirtyCountResult.fold((_) => 0, (count) => count);
        emit(ServerLoaded(servers, dirtyCount: dirtyCount));
      },
    );
  }

  Future<void> _onCreateServer(
    CreateServerEvent event,
    Emitter<ServerState> emit,
  ) async {
    emit(const ServerLoading());

    final result = await serverRepository.createServer(event.server);

    await result.fold(
      (failure) async => emit(ServerError(failure.message)),
      (_) async {
        // Reload servers first
        final serversResult = await serverRepository.getAllServers();
        final dirtyCountResult = await serverRepository.getDirtyCount();

        serversResult.fold(
          (failure) => emit(ServerError(failure.message)),
          (servers) {
            final dirtyCount = dirtyCountResult.fold((_) => 0, (count) => count);
            emit(ServerLoaded(servers, dirtyCount: dirtyCount));
          },
        );
      },
    );
  }

  Future<void> _onUpdateServer(
    UpdateServerEvent event,
    Emitter<ServerState> emit,
  ) async {
    emit(const ServerLoading());

    final result = await serverRepository.updateServer(event.server);

    await result.fold(
      (failure) async => emit(ServerError(failure.message)),
      (_) async {
        // Reload servers first
        final serversResult = await serverRepository.getAllServers();
        final dirtyCountResult = await serverRepository.getDirtyCount();

        serversResult.fold(
          (failure) => emit(ServerError(failure.message)),
          (servers) {
            final dirtyCount = dirtyCountResult.fold((_) => 0, (count) => count);
            emit(ServerLoaded(servers, dirtyCount: dirtyCount));
          },
        );
      },
    );
  }

  Future<void> _onDeleteServer(
    DeleteServerEvent event,
    Emitter<ServerState> emit,
  ) async {
    emit(const ServerLoading());

    final result = await serverRepository.deleteServer(event.id, event.type);

    await result.fold(
      (failure) async => emit(ServerError(failure.message)),
      (_) async {
        // Reload servers first
        final serversResult = await serverRepository.getAllServers();
        final dirtyCountResult = await serverRepository.getDirtyCount();

        serversResult.fold(
          (failure) => emit(ServerError(failure.message)),
          (servers) {
            final dirtyCount = dirtyCountResult.fold((_) => 0, (count) => count);
            emit(ServerLoaded(servers, dirtyCount: dirtyCount));
          },
        );
      },
    );
  }

  Future<void> _onSyncServers(
    SyncServersEvent event,
    Emitter<ServerState> emit,
  ) async {
    emit(const ServerSyncing());

    final result = await serverRepository.syncToServer();

    result.fold(
      (failure) => emit(ServerError(failure.message)),
      (syncResult) {
        if (syncResult.status == SyncStatus.success) {
          emit(ServerSyncSuccess(
            syncResult.message ?? 'Sync completed',
            syncResult.syncedCount ?? 0,
          ));
          // Reload servers after sync
          add(const LoadServers());
        } else if (syncResult.status == SyncStatus.error) {
          emit(ServerError(syncResult.message ?? 'Sync failed'));
        }
      },
    );
  }

  Future<void> _onDownloadServers(
    DownloadServersEvent event,
    Emitter<ServerState> emit,
  ) async {
    emit(const ServerDownloading());

    final result = await serverRepository.downloadFromServer();

    result.fold(
      (failure) => emit(ServerError(failure.message)),
      (count) {
        emit(ServerOperationSuccess('Downloaded $count servers from server'));
        // Reload servers after download
        add(const LoadServers());
      },
    );
  }

  Future<void> _onCheckDirtyCount(
    CheckDirtyCountEvent event,
    Emitter<ServerState> emit,
  ) async {
    final result = await serverRepository.getDirtyCount();

    result.fold(
      (failure) => emit(ServerError(failure.message)),
      (count) {
        // Just trigger a reload which will include the dirty count
        add(const LoadServers());
      },
    );
  }
}