GiteaClient/lib/cubit/search_bloc.dart

import 'dart:async';

import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:stream_transform/stream_transform.dart';

import '../model/repository.dart';
import '../service/gitea_service.dart';

part 'search_event.dart';

part 'search_state.dart';

class SearchBloc extends Bloc<SearchEvent, SearchState> {
  final GiteaService giteaService;

  SearchBloc({required this.giteaService}) : super(const SearchState()) {
    on<SearchInputEvent>(
      _SearchInputEvent,
      transformer: (events, mapper) => events.switchMap(mapper),
    );
    on<SearchFetchedEvent>(
      _SearchFetchedEvent,
      transformer: (events, mapper) => events.switchMap(mapper),
    );
  }

  Future<void> _SearchFetchedEvent(SearchFetchedEvent event,
      Emitter<SearchState> emit) async {
    if (state.hasReachedMax) return;
    if (state.queryString.isEmpty) return;
    try {
      if (state.status == SearchStatus.initial) {
        final searchResult = await giteaService.searchRepo(
            query: state.queryString, page: 1, limit: 100);
        if(searchResult.ok) {
          return emit(state.copyWith(
          status: SearchStatus.success,
          repos: searchResult.data,
          loadedPages: 1,
          hasReachedMax: false,
          error_message: null,
        ));
        }else {
          emit(state.copyWith(
              status: SearchStatus.failure, error_message: "No results"));
        }
      }
      final searchResult = await giteaService.searchRepo(
          query: state.queryString, page: state.loadedPages + 1, limit: 100);
      final repoList = List.of(state.repos);
      if(searchResult.ok) {
        searchResult.data.forEach((element) {
          if (repoList
              .where((selement) => selement.id == element.id)
              .isEmpty) {
            repoList.add(element);
          }
        });
        emit(searchResult.data.isEmpty
            ? state.copyWith(hasReachedMax: true)
            : state.copyWith(
          status: SearchStatus.success,
          repos: repoList,
          loadedPages: state.loadedPages + 1,
          hasReachedMax: false,
          error_message: null,
        ));
      }else {
        emit(state.copyWith(
            status: SearchStatus.failure, error_message: "No results"));
      }
    } on Exception catch (e) {
      emit(state.copyWith(
          status: SearchStatus.failure, error_message: e.toString()));
    }
  }

  Future<void> _SearchInputEvent(SearchInputEvent event,
      Emitter<SearchState> emit) async {
    if (event.queryText.isEmpty) {
      emit(state.copyWith(
        queryString: event.queryText,
        status: SearchStatus.initial,
        repos: [],
        loadedPages: 0,
        hasReachedMax: false,
        error_message: null,
      ));
      return;
    }

    print("New state: ${event.queryText}");

    try {
      final searchResult = await giteaService.searchRepo(
          query: event.queryText, page: 1, limit: 100);
      if(searchResult.ok) {
        return emit(state.copyWith(
          queryString: event.queryText,
          status: SearchStatus.success,
          repos: searchResult.data,
          loadedPages: 1,
          hasReachedMax: false,
          error_message: null,
        ));
      }else {
        emit(state.copyWith(
            status: SearchStatus.failure, error_message: "No results"));
      }
    } on Exception catch (e) {
      emit(state.copyWith(
          status: SearchStatus.failure, error_message: e.toString()));
    }
  }
}