second commit

lib/domain/entities/cart.dart

@@ -0,0 +1,238 @@
+import 'package:equatable/equatable.dart';
+
+import '../../core/constants/app_constants.dart';
+import '../../core/utils/extensions.dart';
+import 'customer.dart';
+import 'product.dart';
+
+/// How a discount value should be interpreted.
+enum DiscountType { none, percentage, flat }
+
+/// A discount applied to a single line or to the whole bill.
+class Discount extends Equatable {
+  const Discount({this.type = DiscountType.none, this.value = 0, this.reason});
+
+  final DiscountType type;
+  final double value;
+  final String? reason;
+
+  static const Discount none = Discount();
+
+  bool get isActive => type != DiscountType.none && value > 0;
+
+  /// Resolves the discount to rupees against [base], never exceeding it.
+  double amountOn(double base) {
+    if (!isActive || base <= 0) return 0;
+    final raw = switch (type) {
+      DiscountType.percentage => base * (value / 100),
+      DiscountType.flat => value,
+      DiscountType.none => 0.0,
+    };
+    return raw.clamp(0, base).toDouble().asMoney;
+  }
+
+  String get label => switch (type) {
+        DiscountType.percentage => '${value.toStringAsFixed(0)}% off',
+        DiscountType.flat => 'Flat ${AppConstants.currencySymbol}$value off',
+        DiscountType.none => 'No discount',
+      };
+
+  @override
+  List<Object?> get props => [type, value, reason];
+}
+
+/// One product line inside the cart.
+class CartLine extends Equatable {
+  const CartLine({
+    required this.product,
+    required this.quantity,
+    this.discount = Discount.none,
+    this.addedAt,
+  });
+
+  final Product product;
+  final double quantity;
+  final Discount discount;
+  final DateTime? addedAt;
+
+  String get id => product.id;
+
+  /// Line value before discount, GST inclusive.
+  double get grossAmount => (product.price * quantity).asMoney;
+
+  double get discountAmount => discount.amountOn(grossAmount);
+
+  /// Payable for this line after discount, GST inclusive.
+  double get payable => (grossAmount - discountAmount).asMoney;
+
+  /// Taxable value inside [payable].
+  double get taxableValue => (payable / (1 + product.gstRate)).asMoney;
+
+  /// GST rupees inside [payable].
+  double get taxAmount => (payable - taxableValue).asMoney;
+
+  double get cgst => (taxAmount / 2).asMoney;
+  double get sgst => (taxAmount / 2).asMoney;
+
+  double get mrpSavings => product.hasDiscount
+      ? (product.savings * quantity).asMoney
+      : 0;
+
+  bool get exceedsStock => quantity > product.stock;
+
+  CartLine copyWith({double? quantity, Discount? discount}) => CartLine(
+        product: product,
+        quantity: quantity ?? this.quantity,
+        discount: discount ?? this.discount,
+        addedAt: addedAt,
+      );
+
+  @override
+  List<Object?> get props => [product.id, quantity, discount];
+}
+
+/// The live bill. Immutable — every mutation returns a new instance, which
+/// keeps the Riverpod notifier predictable and makes undo trivial.
+class Cart extends Equatable {
+  const Cart({
+    this.lines = const [],
+    this.customer,
+    this.billDiscount = Discount.none,
+    this.pointsRedeemed = 0,
+    this.note,
+  });
+
+  final List<CartLine> lines;
+  final Customer? customer;
+  final Discount billDiscount;
+  final int pointsRedeemed;
+  final String? note;
+
+  static const Cart empty = Cart();
+
+  bool get isEmpty => lines.isEmpty;
+  bool get isNotEmpty => lines.isNotEmpty;
+  bool get isWalkIn => customer == null;
+
+  int get lineCount => lines.length;
+
+  double get totalQuantity =>
+      lines.fold(0.0, (sum, l) => sum + l.quantity);
+
+  /// Sum of line values before any bill-level discount, GST inclusive.
+  double get subtotal =>
+      lines.fold(0.0, (sum, l) => sum + l.payable).asMoney;
+
+  /// Discounts applied at the individual line level.
+  double get lineDiscountTotal =>
+      lines.fold(0.0, (sum, l) => sum + l.discountAmount).asMoney;
+
+  /// Automatic discount earned through the customer's membership tier.
+  Discount get membershipDiscount {
+    final rate = customer?.tier.discountRate ?? 0;
+    if (rate <= 0) return Discount.none;
+    return Discount(
+      type: DiscountType.percentage,
+      value: rate * 100,
+      reason: '${customer!.tier.label} member',
+    );
+  }
+
+  double get membershipDiscountAmount =>
+      membershipDiscount.amountOn(subtotal);
+
+  double get manualBillDiscountAmount => billDiscount.amountOn(subtotal);
+
+  /// All bill-level reductions combined.
+  double get billDiscountTotal =>
+      (membershipDiscountAmount + manualBillDiscountAmount)
+          .clamp(0, subtotal)
+          .toDouble()
+          .asMoney;
+
+  double get loyaltyRedemptionValue =>
+      (pointsRedeemed * AppConstants.loyaltyPointValue).asMoney;
+
+  /// Payable after every discount, GST inclusive, before round-off.
+  double get netAmount {
+    final v = subtotal - billDiscountTotal - loyaltyRedemptionValue;
+    return v.clamp(0, double.infinity).toDouble().asMoney;
+  }
+
+  /// Proportion of the bill remaining after bill-level reductions. Used to
+  /// spread those reductions fairly across lines when apportioning GST.
+  double get _billFactor => subtotal <= 0 ? 1 : netAmount / subtotal;
+
+  /// GST payable across the bill, after apportioning bill-level discounts.
+  double get taxAmount =>
+      lines.fold(0.0, (sum, l) => sum + l.taxAmount * _billFactor).asMoney;
+
+  double get cgst => (taxAmount / 2).asMoney;
+  double get sgst => (taxAmount / 2).asMoney;
+
+  /// Taxable value across the bill.
+  double get taxableAmount => (netAmount - taxAmount).asMoney;
+
+  /// GST broken out per slab — required on a compliant tax invoice.
+  Map<double, double> get taxBreakdown {
+    final map = <double, double>{};
+    for (final line in lines) {
+      final rate = line.product.gstRate;
+      map[rate] = ((map[rate] ?? 0) + line.taxAmount * _billFactor).asMoney;
+    }
+    return map;
+  }
+
+  double get grandTotal => netAmount.roundedToRupee;
+
+  /// The paise adjustment shown as "Round Off" on the bill.
+  double get roundOff => (grandTotal - netAmount).asMoney;
+
+  double get mrpSavingsTotal =>
+      lines.fold(0.0, (sum, l) => sum + l.mrpSavings).asMoney;
+
+  /// Everything the shopper saved on this bill.
+  double get totalSavings =>
+      (mrpSavingsTotal + lineDiscountTotal + billDiscountTotal).asMoney;
+
+  /// Points this sale will earn. Walk-in customers earn nothing.
+  int get pointsEarned {
+    if (customer == null) return 0;
+    return (grandTotal / AppConstants.loyaltyRupeesPerPoint).floor();
+  }
+
+  int get maxRedeemablePoints {
+    final c = customer;
+    if (c == null) return 0;
+    final byBalance = c.loyaltyPoints;
+    final byBill =
+        (subtotal - billDiscountTotal) ~/ AppConstants.loyaltyPointValue;
+    return byBalance < byBill ? byBalance : byBill;
+  }
+
+  CartLine? lineFor(String productId) =>
+      lines.firstWhereOrNull((l) => l.product.id == productId);
+
+  bool contains(String productId) => lineFor(productId) != null;
+
+  Cart copyWith({
+    List<CartLine>? lines,
+    Customer? customer,
+    bool clearCustomer = false,
+    Discount? billDiscount,
+    int? pointsRedeemed,
+    String? note,
+  }) {
+    return Cart(
+      lines: lines ?? this.lines,
+      customer: clearCustomer ? null : (customer ?? this.customer),
+      billDiscount: billDiscount ?? this.billDiscount,
+      pointsRedeemed: pointsRedeemed ?? this.pointsRedeemed,
+      note: note ?? this.note,
+    );
+  }
+
+  @override
+  List<Object?> get props =>
+      [lines, customer, billDiscount, pointsRedeemed, note];
+}