social-app/apps/lib/core/api/api_client.dart

import 'dart:convert';
import 'package:dio/dio.dart';
import 'api_exception.dart';
import 'api_interceptor.dart';
import 'i_api_client.dart';
import '../storage/token_storage.dart';

class ApiClient implements IApiClient {
  final Dio _dio;
  final TokenStorage _tokenStorage;
  final ApiInterceptor _interceptor;

  factory ApiClient({
    required String baseUrl,
    required TokenStorage tokenStorage,
    Dio? dio,
  }) {
    final effectiveDio =
        dio ??
        Dio(
          BaseOptions(
            baseUrl: baseUrl,
            connectTimeout: const Duration(seconds: 10),
            receiveTimeout: const Duration(seconds: 20),
            sendTimeout: const Duration(seconds: 20),
          ),
        );
    final interceptor = ApiInterceptor(
      tokenStorage: tokenStorage,
      dio: effectiveDio,
    );
    effectiveDio.interceptors.add(interceptor);
    return ApiClient._(
      dio: effectiveDio,
      tokenStorage: tokenStorage,
      interceptor: interceptor,
    );
  }

  ApiClient._({
    required Dio dio,
    required TokenStorage tokenStorage,
    required ApiInterceptor interceptor,
  }) : _dio = dio,
       _tokenStorage = tokenStorage,
       _interceptor = interceptor;

  Dio get dio => _dio;

  void resetInterceptor() {
    _interceptor.reset();
  }

  void setRefreshCallback(Future<bool> Function(String) refresh) {
    _interceptor.onTokenRefresh = () async {
      final token = await _tokenStorage.getRefreshToken();
      if (token == null) return false;
      return refresh(token);
    };
  }

  void setAuthFailureCallback(Future<void> Function() onAuthFailure) {
    _interceptor.onAuthFailure = onAuthFailure;
  }

  @override
  Future<Response<T>> get<T>(String path, {Options? options}) async {
    try {
      return await _dio.get<T>(path, options: options);
    } on DioException catch (e) {
      throw ApiException.fromDioError(e);
    }
  }

  @override
  Future<Response<T>> post<T>(
    String path, {
    dynamic data,
    Options? options,
  }) async {
    try {
      return await _dio.post<T>(path, data: data, options: options);
    } on DioException catch (e) {
      throw ApiException.fromDioError(e);
    }
  }

  @override
  Future<Response<T>> patch<T>(
    String path, {
    dynamic data,
    Options? options,
  }) async {
    try {
      return await _dio.patch<T>(path, data: data, options: options);
    } on DioException catch (e) {
      throw ApiException.fromDioError(e);
    }
  }

  @override
  Future<Response<T>> delete<T>(
    String path, {
    dynamic data,
    Options? options,
  }) async {
    try {
      return await _dio.delete<T>(path, data: data, options: options);
    } on DioException catch (e) {
      throw ApiException.fromDioError(e);
    }
  }

  @override
  Future<Stream<String>> getSseLines(
    String path, {
    Map<String, String>? headers,
  }) async {
    try {
      final response = await _dio.get<ResponseBody>(
        path,
        options: Options(responseType: ResponseType.stream, headers: headers),
      );
      final responseBody = response.data;
      if (responseBody == null) {
        return const Stream<String>.empty();
      }
      return responseBody.stream
          .cast<List<int>>()
          .transform(utf8.decoder)
          .transform(const LineSplitter());
    } on DioException catch (e) {
      throw ApiException.fromDioError(e);
    }
  }
}