Flutter Riverpod Provider 완벽 가이드 8편 - AsyncNotifierProvider

// 1. 데이터 모델 정의
class User {
  final String id;
  final String name;
  final String email;
  final DateTime lastSeen;
  
  const User({
    required this.id,
    required this.name,
    required this.email,
    required this.lastSeen,
  });
  
  User copyWith({
    String? id,
    String? name,
    String? email,
    DateTime? lastSeen,
  }) {
    return User(
      id: id ?? this.id,
      name: name ?? this.name,
      email: email ?? this.email,
      lastSeen: lastSeen ?? this.lastSeen,
    );
  }
}

// 2. AsyncNotifier 클래스 정의
class UserNotifier extends AsyncNotifier<User> {
  @override
  Future<User> build() async {
    // 초기 데이터 로딩 - 자동으로 AsyncValue로 래핑됨
    return await _fetchUser();
  }
  
  Future<User> _fetchUser() async {
    // API 호출 시뮬레이션
    await Future.delayed(const Duration(seconds: 2));
    
    return User(
      id: '1',
      name: 'John Doe',
      email: 'john@example.com',
      lastSeen: DateTime.now(),
    );
  }
  
  Future<void> updateName(String newName) async {
    // 낙관적 업데이트: UI를 먼저 업데이트
    final currentUser = state.value;
    if (currentUser == null) return;
    
    final updatedUser = currentUser.copyWith(name: newName);
    state = AsyncValue.data(updatedUser);
    
    try {
      // 서버에 변경사항 전송
      await _updateUserOnServer(updatedUser);
    } catch (e) {
      // 실패 시 원래 상태로 복구
      state = AsyncValue.data(currentUser);
      throw e;
    }
  }
  
  Future<void> _updateUserOnServer(User user) async {
    await Future.delayed(const Duration(seconds: 1));
    // 실제로는 HTTP PUT 요청
  }
  
  Future<void> refresh() async {
    // 데이터 새로고침
    state = const AsyncValue.loading();
    
    try {
      final user = await _fetchUser();
      state = AsyncValue.data(user);
    } catch (e) {
      state = AsyncValue.error(e, StackTrace.current);
    }
  }
}

// 3. Provider 정의
final userProvider = AsyncNotifierProvider<UserNotifier, User>(UserNotifier.new);

// 4. UI에서 사용
class UserProfileWidget extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final userAsync = ref.watch(userProvider);
    
    return userAsync.when(
      loading: () => const CircularProgressIndicator(),
      error: (error, stack) => Text('오류: $error'),
      data: (user) => Column(
        children: [
          Text('이름: ${user.name}'),
          Text('이메일: ${user.email}'),
          ElevatedButton(
            onPressed: () => ref.read(userProvider.notifier).updateName('New Name'),
            child: const Text('이름 변경'),
          ),
        ],
      ),
    );
  }
}

class Product {
  final String id;
  final String name;
  final double price;
  final String description;
  final bool isAvailable;
  
  const Product({
    required this.id,
    required this.name,
    required this.price,
    required this.description,
    required this.isAvailable,
  });
  
  Product copyWith({
    String? id,
    String? name,
    double? price,
    String? description,
    bool? isAvailable,
  }) {
    return Product(
      id: id ?? this.id,
      name: name ?? this.name,
      price: price ?? this.price,
      description: description ?? this.description,
      isAvailable: isAvailable ?? this.isAvailable,
    );
  }
}

class ProductListNotifier extends AsyncNotifier<List<Product>> {
  @override
  Future<List<Product>> build() async {
    // 초기 상품 목록 로딩
    return await _fetchProducts();
  }
  
  Future<List<Product>> _fetchProducts() async {
    await Future.delayed(const Duration(seconds: 1));
    
    // 실제로는 API 호출
    return [
      const Product(
        id: '1',
        name: '노트북',
        price: 1200000,
        description: '고성능 게이밍 노트북',
        isAvailable: true,
      ),
      const Product(
        id: '2',
        name: '마우스',
        price: 50000,
        description: '무선 게이밍 마우스',
        isAvailable: true,
      ),
    ];
  }
  
  Future<void> addProduct(Product product) async {
    final currentProducts = state.value ?? [];
    
    // 낙관적 업데이트
    state = AsyncValue.data([...currentProducts, product]);
    
    try {
      await _createProductOnServer(product);
    } catch (e) {
      // 실패 시 원래 상태로 복구
      state = AsyncValue.data(currentProducts);
      rethrow;
    }
  }
  
  Future<void> updateProduct(Product updatedProduct) async {
    final currentProducts = state.value ?? [];
    
    // 낙관적 업데이트
    final updatedList = currentProducts.map((product) {
      return product.id == updatedProduct.id ? updatedProduct : product;
    }).toList();
    
    state = AsyncValue.data(updatedList);
    
    try {
      await _updateProductOnServer(updatedProduct);
    } catch (e) {
      // 실패 시 원래 상태로 복구
      state = AsyncValue.data(currentProducts);
      rethrow;
    }
  }
  
  Future<void> deleteProduct(String productId) async {
    final currentProducts = state.value ?? [];
    
    // 낙관적 업데이트
    final updatedList = currentProducts.where((p) => p.id != productId).toList();
    state = AsyncValue.data(updatedList);
    
    try {
      await _deleteProductOnServer(productId);
    } catch (e) {
      // 실패 시 원래 상태로 복구
      state = AsyncValue.data(currentProducts);
      rethrow;
    }
  }
  
  Future<void> toggleAvailability(String productId) async {
    final currentProducts = state.value ?? [];
    
    final updatedList = currentProducts.map((product) {
      if (product.id == productId) {
        return product.copyWith(isAvailable: !product.isAvailable);
      }
      return product;
    }).toList();
    
    state = AsyncValue.data(updatedList);
    
    try {
      final updatedProduct = updatedList.firstWhere((p) => p.id == productId);
      await _updateProductOnServer(updatedProduct);
    } catch (e) {
      state = AsyncValue.data(currentProducts);
      rethrow;
    }
  }
  
  // 서버 통신 메소드들
  Future<void> _createProductOnServer(Product product) async {
    await Future.delayed(const Duration(milliseconds: 500));
    // 실제 POST 요청
  }
  
  Future<void> _updateProductOnServer(Product product) async {
    await Future.delayed(const Duration(milliseconds: 500));
    // 실제 PUT 요청
  }
  
  Future<void> _deleteProductOnServer(String productId) async {
    await Future.delayed(const Duration(milliseconds: 500));
    // 실제 DELETE 요청
  }
}

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