import 'dart:async';

import 'package:commons_core/commons_core.dart';
import 'package:equatable/equatable.dart';
import 'package:flutter_bloc/flutter_bloc.dart';

import '../data/variety_repository.dart';
import '../db/enums.dart';

class VarietyDetailState extends Equatable {
  const VarietyDetailState({
    this.detail,
    this.loading = true,
    this.deleted = false,
  });

  final VarietyDetail? detail;
  final bool loading;
  final bool deleted;

  @override
  List<Object?> get props => [detail, loading, deleted];
}

/// Streams one variety's detail and edits it through the repository.
class VarietyDetailCubit extends Cubit<VarietyDetailState> {
  VarietyDetailCubit(this._repo, this.varietyId)
    : super(const VarietyDetailState()) {
    _sub = _repo
        .watchVariety(varietyId)
        .listen(
          (d) => emit(
            VarietyDetailState(
              detail: d,
              loading: false,
              deleted: state.deleted,
            ),
          ),
        );
  }

  final VarietyRepository _repo;
  final String varietyId;
  late final StreamSubscription<VarietyDetail?> _sub;

  Future<void> updateFields({String? label, String? category, String? notes}) =>
      _repo.updateVariety(
        id: varietyId,
        label: label,
        category: category,
        notes: notes,
      );

  Future<void> addLot({
    LotType type = LotType.seed,
    int? year,
    Quantity? quantity,
  }) => _repo.addLot(
    varietyId: varietyId,
    type: type,
    harvestYear: year,
    quantity: quantity,
  );

  Future<void> linkSpecies(String speciesId) =>
      _repo.linkSpecies(varietyId, speciesId);

  Future<void> addGerminationTest({
    required String lotId,
    int? testedOn,
    int? sampleSize,
    int? germinatedCount,
  }) => _repo.addGerminationTest(
    lotId: lotId,
    testedOn: testedOn,
    sampleSize: sampleSize,
    germinatedCount: germinatedCount,
  );

  Future<void> deleteVariety() async {
    await _repo.softDeleteVariety(varietyId);
    emit(
      VarietyDetailState(detail: state.detail, loading: false, deleted: true),
    );
  }

  @override
  Future<void> close() async {
    await _sub.cancel();
    return super.close();
  }
}