jiu/client/lib/providers/product_provider.dart

import 'package:flutter_riverpod/flutter_riverpod.dart';
import '../core/api/api_client.dart';
import '../core/auth/auth_state.dart';
import '../core/config/app_constants.dart';
import '../core/models/page_result.dart';
import '../models/product.dart';
import '../repositories/product_repository.dart';
import 'connectivity_provider.dart';

final productRepositoryProvider = Provider<ProductRepository>((ref) {
  return ProductRepository(ref.watch(apiClientProvider));
});

final productListProvider =
    AsyncNotifierProvider<ProductListNotifier, PageResult<Product>>(
  ProductListNotifier.new,
);

class ProductListNotifier extends AsyncNotifier<PageResult<Product>> {
  int _page = 1;
  int _pageSize = AppConstants.defaultPageSize;
  String _keyword = '';
  int? _categoryId;
  PageResult<Product>? _cache;

  @override
  Future<PageResult<Product>> build() async {
    ref.watch(authStateProvider.select((s) => s.user?.shopId));
    ref.watch(networkRecoveryCountProvider);
    try {
      final result = await _fetch();
      _cache = result;
      return result;
    } catch (_) {
      if (_cache != null) return _cache!;
      rethrow;
    }
  }

  Future<PageResult<Product>> _fetch() {
    final repo = ref.read(productRepositoryProvider);
    return repo.list(
      page: _page,
      pageSize: _pageSize,
      keyword: _keyword.isEmpty ? null : _keyword,
      categoryId: _categoryId,
    );
  }

  void setPage(int page) {
    _page = page;
    reload();
  }

  void setPageSize(int pageSize) {
    _pageSize = pageSize;
    _page = 1;
    reload();
  }

  void setKeyword(String keyword) {
    _keyword = keyword;
    _page = 1;
    reload();
  }

  void setCategoryId(int? categoryId) {
    _categoryId = categoryId;
    _page = 1;
    reload();
  }

  void reload() {
    state = const AsyncValue.loading();
    _fetch().then((result) {
      _cache = result;
      state = AsyncValue.data(result);
    }, onError: (e, st) {
      if (_cache != null) {
        state = AsyncValue.data(_cache!);
      } else {
        state = AsyncValue.error(e, st);
      }
    });
  }

  Future<void> createProduct(Map<String, dynamic> data) async {
    final repo = ref.read(productRepositoryProvider);
    await repo.create(data);
    reload();
  }

  Future<void> updateProduct(int id, Map<String, dynamic> data) async {
    final repo = ref.read(productRepositoryProvider);
    await repo.update(id, data);
    reload();
  }

  Future<void> deleteProduct(int id) async {
    final repo = ref.read(productRepositoryProvider);
    await repo.delete(id);
    reload();
  }
}