fcs/lib/pages/carton/model/package_selection_model.dart

import 'dart:async';

import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:logging/logging.dart';

import '../../../constants.dart';
import '../../../domain/entities/package.dart';
import '../../../pagination/paginator_listener.dart';
import '../../main/model/base_model.dart';

class PackageSelectionModel extends BaseModel {
  final log = Logger("PackageSelectionModel");
  PaginatorListener<Package>? getPackages;

  List<Package> packages = [];
  bool isLoading = false;
  DocumentSnapshot? _lastDocument;
  bool ended = false;

  @override
  logout() async {
    packages.clear();
    getPackages?.close();
  }

  loadPackages(
      {required String senderId,
      required String consigneeId,
      required String shipmentId}) {
    if (user == null) return;

    String path = "/$packages_collection";
    Query col = FirebaseFirestore.instance
        .collection(path)
        .where("sender_id", isEqualTo: senderId)
        .where("user_id", isEqualTo: consigneeId)
        .where("fcs_shipment_id", isEqualTo: shipmentId);
    Query pageQuery = FirebaseFirestore.instance
        .collection(path)
        .where("sender_id", isEqualTo: senderId)
        .where("user_id", isEqualTo: consigneeId)
        .where("fcs_shipment_id", isEqualTo: shipmentId);

    pageQuery = pageQuery.orderBy("created_date", descending: true);
    getPackages?.close();
    getPackages = PaginatorListener<Package>(
        col, pageQuery, (data, id) => Package.fromMap(data, id),
        rowPerLoad: 30);
  }

  Future<void> refresh(
      {required String shipmentId,
      required String senderId,
      required String consigneeId}) async {
    packages.clear();
    _lastDocument = null;
    ended = false;
    await loadMoreData(
      shipmentId: shipmentId,
      senderId: senderId,
      consigneeId: consigneeId,
    );
    notifyListeners();
  }

  Future<void> loadMoreData(
      {required String shipmentId,
      required String senderId,
      required String consigneeId}) async {
    int rowPerPage = 20;

    try {
      isLoading = true;
      String path = "/$packages_collection";
      Query query = FirebaseFirestore.instance
          .collection(path)
          .where("status",
              whereIn: [package_processed_status, package_packed_status])
          .where("sender_id", isEqualTo: senderId)
          .where("user_id", isEqualTo: consigneeId)
          .where("fcs_shipment_id", isEqualTo: shipmentId)
          .where("is_deleted", isEqualTo: false);

      query = query.orderBy("created_date", descending: true);

      if (_lastDocument != null) {
        query = query.startAfterDocument(_lastDocument!);
      }

      QuerySnapshot querySnap = await query.limit(rowPerPage).get();

      if (querySnap.docs.isEmpty) return;
      _lastDocument = querySnap.docs[querySnap.docs.length - 1];

      List<Package> list = querySnap.docs.map((documentSnapshot) {
        var p = Package.fromMap(documentSnapshot.data() as Map<String, dynamic>,
            documentSnapshot.id);
        return p;
      }).toList();

      packages.addAll(list);
      if (list.length < rowPerPage) ended = true;
      notifyListeners();
    } catch (e) {
      log.warning("error:$e");
    } finally {
      isLoading = false;
    }
  }

  clearSelection() {
    packages.clear();
  }

  Future<List<Package>> getPackagesBySenderAndConsigneeId(
      {required String senderId, required String consigneeId}) async {
    List<Package> list = [];
    try {
      String path = "/$packages_collection";
      var snaps = await FirebaseFirestore.instance
          .collection(path)
          .where("sender_id", isEqualTo: senderId)
          .where("user_id", isEqualTo: consigneeId)
          .where("is_deleted", isEqualTo: false)
          .get(const GetOptions(source: Source.server));
      list = snaps.docs
          .map((documentSnapshot) =>
              Package.fromMap(documentSnapshot.data(), documentSnapshot.id))
          .toList();
    } catch (e) {
      log.warning("Error!! $e");
      list = [];
    }
    return list;
  }

  Future<List<Package>> getActivePackages(
      {required String shipmentId,
      required String senderId,
      required String consigneeId}) async {
    List<Package> list = [];
    try {
      String path = "/$packages_collection";

      var snaps = await FirebaseFirestore.instance
          .collection(path)
          .where("status",
              whereIn: [package_processed_status, package_packed_status])
          .where("sender_id", isEqualTo: senderId)
          .where("user_id", isEqualTo: consigneeId)
          .where("fcs_shipment_id", isEqualTo: shipmentId)
          .where("is_deleted", isEqualTo: false)
          .orderBy("created_date", descending: true)
          .get(const GetOptions(source: Source.server));
      list = snaps.docs
          .map((documentSnapshot) =>
              Package.fromMap(documentSnapshot.data(), documentSnapshot.id))
          .toList();
    } catch (e) {
      log.warning("Error!! $e");
      list = [];
    }
    return list;
  }

  Future<int?> getPackageCount(
      {required String senderId,
      required String consigneeId,
      required String shipmentId}) async {
    String path = "/$packages_collection";

    AggregateQuerySnapshot query = await FirebaseFirestore.instance
        .collection(path)
        .where("sender_id", isEqualTo: senderId)
        .where("user_id", isEqualTo: consigneeId)
        .where("fcs_shipment_id", isEqualTo: shipmentId)
        .where("delete_time", isEqualTo: 0)
        .count()
        .get();

    return query.count;
  }
}