part of 'index.dart';

/// -----------------------------------------------
/// [DocumentPageBloc]
/// -----------------------------------------------

class DocumentPageBloc extends Bloc<DocumentPageEvent, DocumentPageState> {
  final DocumentPageModel model;

  DocumentPageBloc._(this.model, DocumentPageState initialState)
      : super(initialState) {
    on<SelectDocumentEvent>(_selectDocument);
    on<UnselectDocumentEvent>(_unselectDocument);
    on<FilterCategoryEvent>(_filterCategoryEvent);
  }

  static DocumentPageBloc create(DocumentPageModel model) {
    final initialState = DocumentPageState();
    return DocumentPageBloc._(model, initialState);
  }

  Future<void> _filterCategoryEvent(
      FilterCategoryEvent event, Emitter<DocumentPageState> emit) async {
    state.isCategorySelected
        ? _unselectCategory(event, emit)
        : _selectCategory(event, emit);
  }

  Future<void> _selectCategory(
      FilterCategoryEvent event, Emitter<DocumentPageState> emit) async {
    emit(state.copyWith(
      isCategorySelected: true,
    ));

    final s = model.managerKey.currentState!;
    state.isCategorySelected ? s.filter(event.query) : s.filter(event.query);
  }

  Future<void> _unselectCategory(
      FilterCategoryEvent event, Emitter<DocumentPageState> emit) async {
    emit(state.copyWith(
      isCategorySelected: false,
    ));

    final s = model.managerKey.currentState!;
    final Query q = Document.fromDesc('');
    s.filter(q);
  }

  Future<void> _selectDocument(
      SelectDocumentEvent event, Emitter<DocumentPageState> emit) async {
    print('-> select');
    emit(
      state.copyWith(
        uri: await GetPDF().call(
          event.document.id,
        ),
        currentDocument: event.document,
        isDocumentSelected: true,
      ),
    );
  }

  Future<void> _unselectDocument(
      UnselectDocumentEvent event, Emitter<DocumentPageState> emit) async {
    // final docs = await model.generateDocuments(state.page, state.query);
    // final cats = await model.generateCategories();

    emit(
      state.copyWith(
        currentDocument: null,
        isDocumentSelected: false,
        // documents: docs.$2,
        // categories: cats,
      ),
    );
  }
}

/// -----------------------------------------------
/// [DocumentPageEvent]
/// -----------------------------------------------

abstract class DocumentPageEvent {}

class SelectDocumentEvent extends DocumentPageEvent {
  final Document document;
  SelectDocumentEvent(
    this.document,
  );
}

class UnselectDocumentEvent extends DocumentPageEvent {}

class FilterCategoryEvent extends DocumentPageEvent {
  final Query query;
  FilterCategoryEvent(this.query);
}

/// -----------------------------------------------
/// [DocumentPageState]
/// -----------------------------------------------

class DocumentPageState {
  final bool isCategorySelected;
  final bool isDocumentSelected;
  final Document? currentDocument;
  final Category? currentCategory;
  final Uri? uri;
  final int? count;
  final dynamic page;
  final Query? query;

  const DocumentPageState({
    this.query,
    this.count,
    this.page,
    this.uri,
    this.currentDocument,
    this.isCategorySelected = false,
    this.currentCategory,
    this.isDocumentSelected = false,
  });

  DocumentPageState copyWith({
    Uri? uri,
    Query? query,
    int? count,
    dynamic page,
    List<Document?>? documents,
    Document? currentDocument,
    bool? isDocumentSelected,
    List<Category?>? categories,
    Category? currentCategory,
    bool? isCategorySelected,
  }) {
    return DocumentPageState(
      uri: uri ?? this.uri,
      query: query ?? this.query,
      count: count ?? this.count,
      page: page ?? this.page,
      //
      currentDocument: currentDocument ?? this.currentDocument,
      isDocumentSelected: isDocumentSelected ?? this.isDocumentSelected,
      //
      currentCategory: currentCategory ?? this.currentCategory,
      isCategorySelected: isCategorySelected ?? this.isCategorySelected,
    );
  }
}