import 'package:http/http.dart' as http;
Future<List<User>> fetchUsers() async {
  final response = await http.get(
    Uri.parse('https://api.example.com/users'),
    headers: {'Authorization': 'Bearer $token'},
  );

  if (response.statusCode == 200) {
    final List data = jsonDecode(response.body);
    return data.map((json) => User.fromJson(json)).toList();
  } else {
    throw ApiException('Failed: ${response.statusCode}');
  }
}

class ApiClient {
  late final Dio _dio;
  ApiClient({required String baseUrl, String? token}) {
    _dio = Dio(BaseOptions(
      baseUrl: baseUrl,
      connectTimeout: const Duration(seconds: 10),
      receiveTimeout: const Duration(seconds: 10),
      headers: {
        'Content-Type': 'application/json',
        if (token != null) 'Authorization': 'Bearer $token',
      },
    ));
    _dio.interceptors.addAll([
      LogInterceptor(requestBody: true, responseBody: true),
      AuthInterceptor(_dio),
      RetryInterceptor(_dio),
    ]);
  }
  Future<List<User>> getUsers() async {
    final response = await _dio.get('/users');
    return (response.data as List).map((json) => User.fromJson(json)).toList();
  }
}

class LoggingInterceptor extends Interceptor {
  @override
  void onRequest(RequestOptions options, RequestInterceptorHandler handler) {
    print('→ ${options.method} ${options.uri}');
    handler.next(options); // Continue
  }
  @override
  void onResponse(Response response, ResponseInterceptorHandler handler) {
    print('← ${response.statusCode} ${response.requestOptions.uri}');
    handler.next(response);
  }
  @override
  void onError(DioException err, ErrorInterceptorHandler handler) {
    print('✗ ${err.type} ${err.message}');
    handler.next(err); // Pass error along
  }
}

class AuthInterceptor extends Interceptor {
  final Dio dio;
  AuthInterceptor(this.dio);
  @override
  void onError(DioException err, ErrorInterceptorHandler handler) async {
    if (err.response?.statusCode == 401) {
      try {
        final newToken = await _refreshToken();
        // Update stored token
        await SecureStorage.saveToken(newToken);
        // Retry the original request with new token
        err.requestOptions.headers['Authorization'] = 'Bearer $newToken';
        final response = await dio.fetch(err.requestOptions);
        handler.resolve(response);
      } catch (e) { // Refresh failed → logout
        await SecureStorage.clearAll();
        handler.reject(err);
      }
    } else {
      handler.next(err);
    }
  }
}

Future<String> uploadFile(File file) async {
  final formData = FormData.fromMap({
    'file': await MultipartFile.fromFile(
      file.path,
      filename: file.path.split('/').last,
    ),
    'description': 'My upload',
  });

  final response = await _dio.post(
    '/upload',
    data: formData,
    onSendProgress: (sent, total) {
      final progress = (sent / total * 100).toStringAsFixed(0);
      print('Upload: $progress%');
    },
  );
  return response.data['url'];
}

await _dio.download(
  'https://example.com/file.pdf',
  '/save/path.pdf',
  onReceiveProgress: (received, total) {
    print('Download: ${(received / total * 100).toStringAsFixed(0)}%');
  },
);

final Directory tempDir = await getTemporaryDirectory();

final Directory appDocumentsDir = await getApplicationDocumentsDirectory();

final Directory? downloadsDir = await getDownloadsDirectory();

import 'package:web_socket_channel/web_socket_channel.dart';
class ChatService {
  late final WebSocketChannel _channel;
  void connect(String url) {
    _channel = WebSocketChannel.connect(Uri.parse(url));
    _channel.stream.listen( // Listen to incoming messages
      (message) {
        print('Received: $message');
        // Parse and update UI
      },
      onError: (error) => print('WS Error: $error'),
      onDone: () => print('WS Connection closed'),
    );
  }
  void sendMessage(String text) {
    _channel.sink.add(jsonEncode({'type': 'message', 'text': text}));
  }
  void disconnect() {
    _channel.sink.close();
  }
}

// Dio with certificate pinning
final dio = Dio();
dio.httpClientAdapter = IOHttpClientAdapter(
  createHttpClient: () {
    final client = HttpClient();
    client.badCertificateCallback = (cert, host, port) {
      final hash = cert.sha256.toString(); // Compare certificate SHA-256 hash
      return hash == expectedHash;
    };
    return client;
  },
);

abstract class UserRepository {
  Future<List<User>> getAll();
  Future<User> getById(int id);
  Future<User> create(User user);
  Future<void> delete(int id);
}
class ApiUserRepository implements UserRepository {
  final ApiClient _api;
  ApiUserRepository(this._api);
  @override
  Future<List<User>> getAll() async {
    final response = await _api.get('/users');
    return (response.data as List).map((j) => User.fromJson(j)).toList();
  }
  @override
  Future<User> getById(int id) async {
    final response = await _api.get('/users/$id');
    return User.fromJson(response.data);
  }
}