Quire
Bookstore

class Book extends Equatable {
  final String id;
  final String title;
  final String author;
  final double price;
  final double? originalPrice;
  final double rating;
  final List<String> categories;
  final bool inStock;

  const Book({
    required this.id,
    required this.title,
    // ... 17 properties total
  });

  bool get hasDiscount =>
    originalPrice != null && originalPrice! > price;

  double get discountPercentage {
    if (!hasDiscount) return 0;
    return ((originalPrice! - price) / originalPrice! * 100);
  }

  @override
  List<Object?> get props => [id, title, author, ...];
}

class CartBloc extends Bloc<CartEvent, CartState> {
  final GetCart getCart;
  final AddToCart addToCart;
  final RemoveFromCart removeFromCart;
  final UpdateCartItem updateCartItem;
  final ClearCart clearCart;

  CartBloc({required this.getCart, ...})
    : super(const CartInitial()) {
    on<LoadCart>(_onLoadCart);
    on<AddBookToCart>(_onAddToCart);
    on<RemoveItemFromCart>(_onRemoveFromCart);
    on<IncrementItemQuantity>(_onIncrementQuantity);
    on<DecrementItemQuantity>(_onDecrementQuantity);
  }

  Future<void> _onAddToCart(AddBookToCart event, Emitter emit) async {
    final result = await addToCart(event.book, quantity: event.quantity);

    result.fold(
      (failure) => emit(CartError(failure)),
      (item) {
        emit(CartItemAdded(item));  // Optimistic UI feedback
        add(const LoadCart());     // Reload fresh state
      },
    );
  }
}

final sl = GetIt.instance;

Future<void> initDependencies() async {
  await Hive.initFlutter();
  await Hive.openBox(AppConstants.cartBox);
  await Hive.openBox(AppConstants.cacheBox);

  _initExternal();    // FlutterSecureStorage, Connectivity
  _initCore();        // NetworkInfo, ApiClient
  _initAuthFeature();  // Auth BLoC → UseCases → Repo → DataSources
  _initBooksFeature();
  _initCartFeature();
  _initOrdersFeature();
}

void _initCartFeature() {
  // BLoC — factory (new instance per widget tree)
  sl.registerFactory(() => CartBloc(
    getCart: sl(), addToCart: sl(),
    removeFromCart: sl(), updateCartItem: sl(), clearCart: sl(),
  ));

  // Use cases — singleton (stateless)
  sl.registerLazySingleton(() => GetCart(sl()));
  sl.registerLazySingleton(() => AddToCart(sl()));

  // Repository — singleton (single source of truth)
  sl.registerLazySingleton<CartRepository>(
    () => CartRepositoryImpl(localDataSource: sl()),
  );

  // DataSource — Hive box for local persistence
  sl.registerLazySingleton<CartLocalDataSource>(
    () => CartLocalDataSourceImpl(
      cartBox: Hive.box(AppConstants.cartBox),
    ),
  );
}

final authBloc = sl<AuthBloc>();

final router = GoRouter(
  refreshListenable: GoRouterRefreshStream(authBloc.stream),
  redirect: (context, state) {
    final isLoggedIn = authBloc.state is AuthAuthenticated;
    final isAuthRoute = state.matchedLocation.startsWith('/login');

    if (!isLoggedIn && !isAuthRoute) return '/login';
    if (isLoggedIn && isAuthRoute)  return '/';
    return null;
  },
  routes: [
    ShellRoute(
      builder: (context, state, child) => MultiBlocProvider(
        providers: [
          BlocProvider(create: (_) => sl<BooksBloc>()),
          BlocProvider(create: (_) => sl<CartBloc>()),
          BlocProvider(create: (_) => sl<FavoritesBloc>()),
        ],
        child: ScaffoldWithNavBar(child: child),
      ),
      routes: [ /* nested routes... */ ],
    ),
  ],
);

class CartLocalDataSourceImpl implements CartLocalDataSource {
  final Box cartBox;

  CartLocalDataSourceImpl({required this.cartBox});

  @override
  Future<CartItemModel> addToCart(Book book, {int quantity = 1}) async {
    // Deduplicate: increment if already exists
    final existing = cartBox.values.cast<String>()
      .map((json) => CartItemModel.fromJson(jsonDecode(json)))
      .where((item) => item.book.id == book.id);

    if (existing.isNotEmpty) {
      final updated = existing.first.copyWith(
        quantity: existing.first.quantity + quantity,
      );
      await cartBox.put(updated.id, jsonEncode(updated.toJson()));
      return updated;
    }

    final item = CartItemModel.create(book: book, quantity: quantity);
    await cartBox.put(item.id, jsonEncode(item.toJson()));
    return item;
  }
}