import 'dart:convert';
import 'dart:math' as math;
import 'package:flutter/foundation.dart';
import 'package:http/http.dart' as http;
import 'road_alert_models.dart';
import 'road_alert_provider_interface.dart';

/// Client provider for Zyla Labs Waze Data API #4814 via MotorSignal FastAPI backend.
///
/// Credential isolation: The client NEVER holds or transmits the Zyla API key.
/// All requests route through the MotorSignal backend adapter.
class ZylaRoadAlertProvider implements RoadAlertProvider {
  final http.Client _client;
  final String backendBaseUrl;
  final Future<String?> Function()? getAuthToken;

  ZylaRoadAlertProvider({
    http.Client? client,
    String? backendBaseUrl,
    this.getAuthToken,
  })  : _client = client ?? http.Client(),
        backendBaseUrl = backendBaseUrl ??
            const String.fromEnvironment(
              'MOTORSIGNAL_API_URL',
              defaultValue: 'http://127.0.0.1:8000',
            );

  @override
  String get id => 'zyla_waze_4814';

  @override
  String get name => 'Zyla Waze Data #4814';

  @override
  Set<RoadAlertCategory> get supportedCategories => const {
        RoadAlertCategory.police,
        RoadAlertCategory.accident,
        RoadAlertCategory.hazard,
        RoadAlertCategory.roadClosure,
        RoadAlertCategory.construction,
        RoadAlertCategory.traffic,
        RoadAlertCategory.pothole,
        RoadAlertCategory.debris,
        RoadAlertCategory.weatherHazard,
        RoadAlertCategory.other,
      };

  Future<Map<String, String>> _buildHeaders({String? apiKey}) async {
    final headers = <String, String>{
      'Accept': 'application/json',
    };
    if (getAuthToken != null) {
      try {
        final token = await getAuthToken!();
        if (token != null && token.isNotEmpty) {
          headers['Authorization'] = 'Bearer $token';
          return headers;
        }
      } catch (e) {
        if (kDebugMode) {
          debugPrint('[ZylaRoadAlertProvider] Error resolving auth token: $e');
        }
      }
    }
    if (apiKey != null && apiKey.isNotEmpty) {
      headers['Authorization'] = 'Bearer $apiKey';
    }
    return headers;
  }

  @override
  Future<RoadAlertProviderStatus> testConnection(String apiKey) async {
    try {
      final headers = await _buildHeaders(apiKey: apiKey);
      final uri = Uri.parse('$backendBaseUrl/api/v1/alerts/ops/health');
      final res = await _client.get(uri, headers: headers).timeout(const Duration(seconds: 4));
      if (res.statusCode == 200) {
        final data = json.decode(res.body);
        final providers = data['providers'] as List<dynamic>? ?? [];
        for (final p in providers) {
          if (p['provider_id'] == id) {
            final status = p['status'];
            if (status == 'operational') return RoadAlertProviderStatus.connected;
            if (status == 'circuit_open') return RoadAlertProviderStatus.rateLimited;
            if (status == 'auth_missing') return RoadAlertProviderStatus.authError;
            return RoadAlertProviderStatus.notConfigured;
          }
        }
        return RoadAlertProviderStatus.connected;
      }
      if (res.statusCode == 401 || res.statusCode == 403) {
        return RoadAlertProviderStatus.authError;
      }
      return RoadAlertProviderStatus.networkError;
    } catch (e) {
      if (kDebugMode) {
        debugPrint('[ZylaRoadAlertProvider] testConnection error: $e');
      }
      return RoadAlertProviderStatus.networkError;
    }
  }

  @override
  Future<List<RoadAlert>> getAlerts({
    required double latitude,
    required double longitude,
    required double radiusMeters,
    String? apiKey,
    String? fixtureOverride,
  }) async {
    // Convert center + radius to bounding box
    const metersPerDegreeLat = 111320.0;
    final latDelta = radiusMeters / metersPerDegreeLat;
    final metersPerDegreeLng = metersPerDegreeLat * math.cos(latitude * math.pi / 180.0).abs();
    final lngDelta = metersPerDegreeLng > 0 ? radiusMeters / metersPerDegreeLng : latDelta;

    final minLat = (latitude - latDelta).clamp(-90.0, 90.0);
    final maxLat = (latitude + latDelta).clamp(-90.0, 90.0);
    final minLng = (longitude - lngDelta).clamp(-180.0, 180.0);
    final maxLng = (longitude + lngDelta).clamp(-180.0, 180.0);

    final queryParams = {
      'min_lat': minLat.toStringAsFixed(4),
      'min_lng': minLng.toStringAsFixed(4),
      'max_lat': maxLat.toStringAsFixed(4),
      'max_lng': maxLng.toStringAsFixed(4),
      'fixture_override': ?fixtureOverride,
    };

    final uri = Uri.parse('$backendBaseUrl/api/v1/alerts/zyla').replace(
      queryParameters: queryParams,
    );

    try {
      final headers = await _buildHeaders(apiKey: apiKey);
      final response = await _client.get(uri, headers: headers).timeout(const Duration(seconds: 5));
      if (response.statusCode == 401 || response.statusCode == 403) {
        if (kDebugMode) {
          debugPrint('[ZylaRoadAlertProvider] Backend rejected request with auth status ${response.statusCode}');
        }
        return [];
      }
      if (response.statusCode != 200) {
        if (kDebugMode) {
          debugPrint('[ZylaRoadAlertProvider] Backend returned status ${response.statusCode}');
        }
        return [];
      }

      final data = json.decode(response.body);
      final rawAlerts = data['alerts'] as List<dynamic>? ?? [];
      final List<RoadAlert> alerts = [];

      for (final raw in rawAlerts) {
        final alert = _parseNormalizedAlert(raw, userLat: latitude, userLng: longitude);
        if (alert != null) {
          alerts.add(alert);
        }
      }

      return alerts;
    } catch (e) {
      if (kDebugMode) {
        debugPrint('[ZylaRoadAlertProvider] Failed to fetch alerts: $e');
      }
      return []; // Graceful degradation
    }
  }

  RoadAlert? _parseNormalizedAlert(
    dynamic raw, {
    required double userLat,
    required double userLng,
  }) {
    if (raw is! Map<String, dynamic>) return null;

    final id = raw['id']?.toString() ?? '';
    final catStr = raw['category']?.toString() ?? 'other';
    final category = RoadAlertCategory.values.firstWhere(
      (c) => c.name.toLowerCase() == catStr.toLowerCase(),
      orElse: () => RoadAlertCategory.other,
    );

    final lat = (raw['latitude'] as num?)?.toDouble() ?? 0.0;
    final lng = (raw['longitude'] as num?)?.toDouble() ?? 0.0;
    if (lat < -90.0 || lat > 90.0 || lng < -180.0 || lng > 180.0) return null;

    final reportedAtStr = raw['reported_at_utc']?.toString();
    final reportedAt = reportedAtStr != null
        ? (DateTime.tryParse(reportedAtStr) ?? DateTime.now())
        : DateTime.now();

    final expiresAtStr = raw['expires_at_utc']?.toString();
    final expiresAt = expiresAtStr != null ? DateTime.tryParse(expiresAtStr) : null;

    final confidence = (raw['confidence'] as num?)?.toDouble();

    // Approximate distance
    final dLat = (lat - userLat) * 111320.0;
    final dLng = (lng - userLng) * 111320.0 * math.cos(userLat * math.pi / 180.0);
    final distance = math.sqrt(dLat * dLat + dLng * dLng);

    return RoadAlert(
      id: id,
      providerId: this.id,
      category: category,
      subtype: raw['subtype']?.toString(),
      latitude: lat,
      longitude: lng,
      roadName: raw['road_name']?.toString(),
      description: raw['description']?.toString() ?? 'Waze Traffic Report',
      reportedAt: reportedAt,
      expiresAt: expiresAt,
      lastUpdated: DateTime.now(),
      confidence: confidence,
      severity: category == RoadAlertCategory.police || category == RoadAlertCategory.accident
          ? RoadAlertSeverity.high
          : RoadAlertSeverity.medium,
      source: raw['source']?.toString() ?? name,
      sourceType: RoadAlertSourceType.providerReported,
      status: RoadAlertStatus.active,
      distanceFromUser: distance,
      confirmations: 1,
      dismissals: 0,
    );
  }
}