import 'package:dio/dio.dart';
import '../../core/constants/app_constants.dart';
import '../../features/routes/data/models/route_model.dart';
import '../../features/routes/data/models/stop_model.dart';

class RouteApiService {
  static final RouteApiService _instance = RouteApiService._internal();
  factory RouteApiService() => _instance;
  RouteApiService._internal();

  late final Dio _dio;

  void initialize({String? authToken}) {
    _dio = Dio(
      BaseOptions(
        baseUrl: AppConstants.baseApiUrl,
        connectTimeout: Duration(seconds: AppConstants.apiTimeout),
        receiveTimeout: Duration(seconds: AppConstants.apiTimeout),
        headers: {
          'Content-Type': 'application/json',
          if (authToken != null) 'Authorization': 'Bearer $authToken',
        },
      ),
    );

    // Add interceptors for logging
    _dio.interceptors.add(
      LogInterceptor(
        requestBody: true,
        responseBody: true,
        error: true,
      ),
    );
  }

  Future<List<RouteModel>> getDriverRoutes(String driverId) async {
    try {
      final response = await _dio.get(
        '${AppConstants.routesEndpoint}/$driverId',
      );

      if (response.statusCode == 200) {
        final List<dynamic> data = response.data as List<dynamic>;
        return data
            .map((json) => RouteModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      return [];
    } catch (e) {
      print('Error fetching routes: $e');
      rethrow;
    }
  }

  Future<RouteModel?> getRouteById(String routeId) async {
    try {
      final response = await _dio.get(
        '${AppConstants.routesEndpoint}/detail/$routeId',
      );

      if (response.statusCode == 200) {
        return RouteModel.fromJson(response.data as Map<String, dynamic>);
      }

      return null;
    } catch (e) {
      print('Error fetching route: $e');
      rethrow;
    }
  }

  Future<bool> updateRouteStatus(String routeId, RouteStatus status) async {
    try {
      final response = await _dio.put(
        '${AppConstants.routesEndpoint}/$routeId/status',
        data: {
          'status': status.toString().split('.').last,
          'timestamp': DateTime.now().toIso8601String(),
        },
      );

      return response.statusCode == 200;
    } catch (e) {
      print('Error updating route status: $e');
      return false;
    }
  }

  Future<bool> updateStopStatus(
    String routeId,
    String stopId,
    StopStatus status, {
    String? signature,
    String? photo,
    String? notes,
  }) async {
    try {
      final response = await _dio.put(
        '${AppConstants.stopsEndpoint}/$stopId/status',
        data: {
          'routeId': routeId,
          'status': status.toString().split('.').last,
          'timestamp': DateTime.now().toIso8601String(),
          if (signature != null) 'signature': signature,
          if (photo != null) 'photo': photo,
          if (notes != null) 'notes': notes,
        },
      );

      return response.statusCode == 200;
    } catch (e) {
      print('Error updating stop status: $e');
      return false;
    }
  }

  Future<bool> reportIssue(String routeId, String stopId, String issue) async {
    try {
      final response = await _dio.post(
        '${AppConstants.stopsEndpoint}/$stopId/issue',
        data: {
          'routeId': routeId,
          'issue': issue,
          'timestamp': DateTime.now().toIso8601String(),
        },
      );

      return response.statusCode == 200;
    } catch (e) {
      print('Error reporting issue: $e');
      return false;
    }
  }
}