بناء طبقة خدمات API متكاملة

import 'package:dio/dio.dart';
import 'package:dio_cache_interceptor/dio_cache_interceptor.dart';
import 'package:dio_smart_retry/dio_smart_retry.dart';

Dio createDio() {
  final options = BaseOptions(
    baseUrl: 'https://api.example.com/v1/',
    connectTimeout: const Duration(seconds: 10),
    receiveTimeout: const Duration(seconds: 15),
    headers: {'Accept': 'application/json'},
  );

  final dio = Dio(options);

  // 1. Auth interceptor — attach Bearer token
  dio.interceptors.add(AuthInterceptor());

  // 2. Cache interceptor — serve stale-while-revalidate
  final cacheOptions = CacheOptions(
    store: MemCacheStore(),
    policy: CachePolicy.refreshForceCache,
    maxStale: const Duration(minutes: 5),
  );
  dio.interceptors.add(DioCacheInterceptor(options: cacheOptions));

  // 3. Retry interceptor — 3 attempts on 5xx / network errors
  dio.interceptors.add(RetryInterceptor(
    dio: dio,
    retries: 3,
    retryDelays: [
      const Duration(seconds: 1),
      const Duration(seconds: 2),
      const Duration(seconds: 4),
    ],
  ));

  // 4. Logger (dev-only, stripped in release builds)
  assert(() {
    dio.interceptors.add(LogInterceptor(responseBody: true));
    return true;
  }());

  return dio;
}

class ApiException implements Exception {
  final String message;
  final int? statusCode;
  const ApiException(this.message, {this.statusCode});

  @override
  String toString() => 'ApiException($statusCode): $message';
}

Future<T> safeCall<T>(Future<T> Function() call) async {
  try {
    return await call();
  } on DioException catch (e) {
    switch (e.type) {
      case DioExceptionType.connectionTimeout:
      case DioExceptionType.receiveTimeout:
        throw const ApiException('Request timed out. Check your connection.');
      case DioExceptionType.badResponse:
        final code = e.response?.statusCode;
        final msg = e.response?.data?['message'] as String? ?? 'Server error';
        throw ApiException(msg, statusCode: code);
      case DioExceptionType.connectionError:
        throw const ApiException('No internet connection.');
      default:
        throw ApiException(e.message ?? 'Unexpected error');
    }
  }
}

class ApiService {
  ApiService({Dio? dio}) : _dio = dio ?? createDio();

  final Dio _dio;

  // --- Users ---

  Future<User> fetchUser(int id) => safeCall(() async {
    final res = await _dio.get('users/$id');
    return User.fromJson(res.data as Map<String, dynamic>);
  });

  Future<List<User>> fetchUsers({int page = 1}) => safeCall(() async {
    final res = await _dio.get('users', queryParameters: {'page': page});
    final list = res.data['data'] as List;
    return list
        .map((e) => User.fromJson(e as Map<String, dynamic>))
        .toList();
  });

  // --- Posts ---

  Future<Post> createPost(Map<String, dynamic> body) => safeCall(() async {
    final res = await _dio.post('posts', data: body);
    return Post.fromJson(res.data as Map<String, dynamic>);
  });

  Future<void> deletePost(int id) => safeCall(() async {
    await _dio.delete('posts/$id');
  });

  // --- Auth ---

  Future<String> login(String email, String password) => safeCall(() async {
    final res = await _dio.post('auth/login', data: {
      'email': email,
      'password': password,
    });
    return res.data['token'] as String;
  });
}

class UserScreen extends StatefulWidget {
  final int userId;
  const UserScreen({super.key, required this.userId});

  @override
  State<UserScreen> createState() => _UserScreenState();
}

class _UserScreenState extends State<UserScreen> {
  late final ApiService _api;
  User? _user;
  String? _error;
  bool _loading = true;

  @override
  void initState() {
    super.initState();
    _api = ApiService(); // استخدم Provider أو get_it في التطبيقات الحقيقية
    _load();
  }

  Future<void> _load() async {
    try {
      final user = await _api.fetchUser(widget.userId);
      if (mounted) setState(() { _user = user; _loading = false; });
    } on ApiException catch (e) {
      if (mounted) setState(() { _error = e.message; _loading = false; });
    }
  }

  @override
  Widget build(BuildContext context) {
    if (_loading) return const CircularProgressIndicator();
    if (_error != null) return Text('Error: $_error');
    return Text(_user!.name);
  }
}