import 'dart:async';
import 'package:flutter/widgets.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:geolocator/geolocator.dart';
import '../auth/auth_providers.dart';
import '../location_service.dart';
import 'group_ride_models.dart';
import 'group_ride_providers.dart';
import 'group_ride_service.dart';

/// State of the local rider's live presence broadcast for a specific Group Ride.
@immutable
class LiveBroadcastState {
  final bool isOptedIn;
  final bool isMasterAllowed;
  final bool isEligible;
  final bool isBroadcasting;
  final bool isPaused;
  final int retryCount;
  final bool isBackground;
  final LivePresenceStatus status;
  final Position? lastPosition;
  final DateTime? lastPublishedAt;
  final String? errorMessage;
  final bool isRegroupActive;

  const LiveBroadcastState({
    this.isOptedIn = false,
    this.isMasterAllowed = false,
    this.isEligible = false,
    this.isBroadcasting = false,
    this.isPaused = false,
    this.retryCount = 0,
    this.isBackground = false,
    this.status = LivePresenceStatus.riding,
    this.lastPosition,
    this.lastPublishedAt,
    this.errorMessage,
    this.isRegroupActive = false,
  });

  LiveBroadcastState copyWith({
    bool? isOptedIn,
    bool? isMasterAllowed,
    bool? isEligible,
    bool? isBroadcasting,
    bool? isPaused,
    int? retryCount,
    bool? isBackground,
    LivePresenceStatus? status,
    Position? lastPosition,
    DateTime? lastPublishedAt,
    String? errorMessage,
    bool? isRegroupActive,
  }) {
    return LiveBroadcastState(
      isOptedIn: isOptedIn ?? this.isOptedIn,
      isMasterAllowed: isMasterAllowed ?? this.isMasterAllowed,
      isEligible: isEligible ?? this.isEligible,
      isBroadcasting: isBroadcasting ?? this.isBroadcasting,
      isPaused: isPaused ?? this.isPaused,
      retryCount: retryCount ?? this.retryCount,
      isBackground: isBackground ?? this.isBackground,
      status: status ?? this.status,
      lastPosition: lastPosition ?? this.lastPosition,
      lastPublishedAt: lastPublishedAt ?? this.lastPublishedAt,
      errorMessage: errorMessage,
      isRegroupActive: isRegroupActive ?? this.isRegroupActive,
    );
  }
}

/// Controller responsible for ephemeral live location broadcasts in an active Group Ride.
///
/// Implements dual-gate privacy (global + per-ride), 5s moving / 30s stopped heartbeat,
/// 30m accuracy filtering, and immediate termination on authorization loss.
class LiveBroadcastController extends StateNotifier<LiveBroadcastState> {
  static final Set<String> _persistedOptedInRideIds = <String>{};

  final String rideId;
  final String callerUid;
  final GroupRideService service;
  final Stream<Position>? positionStream;
  final Stream<GroupRide?>? rideStream;
  final Stream<List<GroupRideParticipant>>? participantsStream;
  final Stream<List<LiveGroupPresence>>? presenceStream;

  StreamSubscription<Position>? _positionSub;
  StreamSubscription<GroupRide?>? _rideSub;
  StreamSubscription<List<GroupRideParticipant>>? _participantsSub;
  StreamSubscription<List<LiveGroupPresence>>? _presenceSub;
  Timer? _heartbeatTimer;

  DateTime? _nextRetryTime;
  int _consecutiveErrors = 0;

  Position? _lastBroadcastPosition;
  DateTime? _lastBroadcastTime;
  bool _isDisposed = false;

  final DateTime Function() _now;

  LiveBroadcastController({
    required this.rideId,
    required this.callerUid,
    required this.service,
    this.positionStream,
    this.rideStream,
    this.participantsStream,
    this.presenceStream,
    bool initialMasterAllowed = false,
    bool? initialOptIn,
    DateTime Function()? now,
  })  : _now = now ?? DateTime.now,
        super(LiveBroadcastState(
          isMasterAllowed: initialMasterAllowed,
          isOptedIn: initialOptIn ?? _persistedOptedInRideIds.contains(rideId),
        )) {
    _initSubscriptions();
  }

  void _initSubscriptions() {
    // 1. Listen to Ride Lifecycle
    final activeRideStream = rideStream ?? service.groupRideStream(rideId);
    _rideSub = activeRideStream.listen(_handleRideUpdate, onError: (e) {
      debugPrint('[LiveBroadcastController] Ride stream error: $e');
    });

    // 2. Listen to Participants (authorization check)
    // Uses caller point-listener instead of broad collection query to adhere to allow list: if false security rule
    final activeParticipantsStream = participantsStream ??
        (callerUid.isNotEmpty
            ? service
                .participantDocStream(
                    groupRideId: rideId,
                    participantUid: callerUid,
                )
                .map((p) => p != null ? [p] : <GroupRideParticipant>[])
            : const Stream<List<GroupRideParticipant>>.empty());
    _participantsSub =
        activeParticipantsStream.listen(_handleParticipantsUpdate, onError: (e) {
      debugPrint('[LiveBroadcastController] Participants stream error: $e');
    });

    // 3. Listen to Live Presence (for regroup awareness)
    final activePresenceStream =
        presenceStream ?? const Stream<List<LiveGroupPresence>>.empty();
    _presenceSub = activePresenceStream.listen(_handlePresenceUpdate, onError: (e) {
      debugPrint('[LiveBroadcastController] Presence stream error: $e');
    });
  }

  void _handleRideUpdate(GroupRide? ride) {
    if (_isDisposed) return;
    if (ride == null) {
      _revokeBroadcasting('Ride not found');
      return;
    }

    // Ride must be live-eligible (scheduled, assembling, or underway)
    final isRideActive = ride.isLiveEligible;

    if (!isRideActive) {
      // Completed or canceled -> stop broadcast
      _revokeBroadcasting('Ride is not in active state (${ride.status.name})');
      return;
    }

    _evaluateEligibility();
  }

  void _handleParticipantsUpdate(List<GroupRideParticipant> participants) {
    if (_isDisposed) return;
    final myParticipant = participants.where((p) => p.userId == callerUid).toList();

    if (myParticipant.isEmpty ||
        myParticipant.first.status != ParticipantStatus.accepted) {
      // User removed, declined, or left -> immediate revocation
      _revokeBroadcasting('Caller is not an accepted participant');
      return;
    }

    _evaluateEligibility(hasAcceptedMembership: true);
  }

  void _handlePresenceUpdate(List<LiveGroupPresence> presences) {
    if (_isDisposed) return;
    final regroupActive = presences.any((p) =>
        p.status == LivePresenceStatus.regrouping && p.isFresh);

    if (regroupActive != state.isRegroupActive) {
      state = state.copyWith(isRegroupActive: regroupActive);
    }
  }

  void _evaluateEligibility({bool? hasAcceptedMembership}) {
    final eligible = hasAcceptedMembership ?? state.isEligible;
    final broadcasting = state.isOptedIn && state.isMasterAllowed && eligible;

    state = state.copyWith(
      isEligible: eligible,
      isBroadcasting: broadcasting,
    );

    if (broadcasting && _positionSub == null) {
      _startBroadcasting();
    } else if (!broadcasting && _positionSub != null) {
      _stopBroadcasting();
    }
  }

  /// Updates the master privacy setting (global app setting).
  void updateMasterAllowed(bool allowed) {
    if (_isDisposed || state.isMasterAllowed == allowed) return;
    state = state.copyWith(isMasterAllowed: allowed);
    _evaluateEligibility();
    if (!allowed) {
      service.clearLivePresence(
        callerUid: callerUid,
        groupRideId: rideId,
      );
    }
  }

  /// Toggles per-ride opt-in for location broadcasting.
  Future<void> setOptIn(bool optIn) async {
    if (_isDisposed) return;
    if (state.isOptedIn == optIn) return;

    _consecutiveErrors = 0;
    _nextRetryTime = null;
    state = state.copyWith(
      isOptedIn: optIn,
      isPaused: false,
      retryCount: 0,
    );
    _evaluateEligibility();

    if (!optIn) {
      _persistedOptedInRideIds.remove(rideId);
      // Immediately clear presence document in Firestore
      await service.clearLivePresence(
        callerUid: callerUid,
        groupRideId: rideId,
      );
    } else {
      _persistedOptedInRideIds.add(rideId);
      if (state.isBroadcasting) {
        if (state.lastPosition != null) {
          // Force immediate publish on opt-in
          await _publishPosition(state.lastPosition!, force: true);
        } else {
          await refreshAndPublishCurrentLocation();
        }
      }
    }
  }

  /// Forces an immediate location sample and presence publish if broadcasting.
  Future<void> refreshAndPublishCurrentLocation() async {
    if (_isDisposed) return;
    try {
      Position? pos;
      try {
        pos = await Geolocator.getLastKnownPosition();
        pos ??= await Geolocator.getCurrentPosition(
          locationSettings: const LocationSettings(
            accuracy: LocationAccuracy.high,
            timeLimit: Duration(seconds: 4),
          ),
        );
      } catch (_) {
        // Fallback or ignore in headless test environments
      }
      if (pos != null && !_isDisposed) {
        _onPositionUpdate(pos);
        if (state.isBroadcasting) {
          await _publishPosition(pos, force: true);
        }
      }
    } catch (e) {
      debugPrint('[LiveBroadcastController] refreshAndPublishCurrentLocation error: $e');
    }
  }

  /// Updates rider quick status (e.g. riding, needFuel, regrouping, stopped, arrived).
  Future<void> setStatus(LivePresenceStatus newStatus) async {
    if (_isDisposed || state.status == newStatus) return;
    state = state.copyWith(status: newStatus);

    if (state.isBroadcasting && state.lastPosition != null) {
      await _publishPosition(state.lastPosition!, force: true);
    }
  }

  /// Calls for a group regroup.
  Future<void> triggerRegroup() async {
    await setStatus(LivePresenceStatus.regrouping);
  }

  /// Clears regroup call by switching back to riding.
  Future<void> clearRegroup() async {
    await setStatus(LivePresenceStatus.riding);
  }

  /// Updates app lifecycle state (e.g. background vs foreground).
  void updateAppLifecycle(AppLifecycleState lifecycle) {
    if (_isDisposed) return;
    final isBg = lifecycle == AppLifecycleState.paused ||
        lifecycle == AppLifecycleState.hidden;
    if (state.isBackground != isBg) {
      state = state.copyWith(isBackground: isBg);
    }
  }

  void _startBroadcasting() {
    _positionSub?.cancel();
    final stream = positionStream ?? Geolocator.getPositionStream(
      locationSettings: const LocationSettings(
        accuracy: LocationAccuracy.high,
        distanceFilter: 5,
      ),
    );

    _positionSub = stream.listen(
      _onPositionUpdate,
      onError: (e) {
        state = state.copyWith(errorMessage: 'Location stream error: $e');
      },
    );

    _heartbeatTimer?.cancel();
    _heartbeatTimer = Timer.periodic(const Duration(seconds: 10), (_) {
      _checkHeartbeat();
    });
  }

  void _stopBroadcasting() {
    _positionSub?.cancel();
    _positionSub = null;
    _heartbeatTimer?.cancel();
    _heartbeatTimer = null;
  }

  void _onPositionUpdate(Position position) {
    if (_isDisposed || !state.isBroadcasting) return;

    // Reject invalid coordinates, out of bounds, or Null Island (0,0)
    if (position.latitude.isNaN ||
        position.longitude.isNaN ||
        position.latitude < -90.0 ||
        position.latitude > 90.0 ||
        position.longitude < -180.0 ||
        position.longitude > 180.0 ||
        (position.latitude == 0.0 && position.longitude == 0.0)) {
      return;
    }

    // Filter accuracy: reject fixes with accuracy > 30m
    if (position.accuracy > 30.0) {
      return;
    }

    state = state.copyWith(lastPosition: position);

    final now = _now();

    // Respect exponential backoff throttle during transient errors
    if (_nextRetryTime != null && now.isBefore(_nextRetryTime!)) {
      return;
    }

    final speedMph = position.speed * 2.23694;
    final isMoving = speedMph > 3.0;

    final lastTime = _lastBroadcastTime;

    if (lastTime == null) {
      _publishPosition(position, force: true);
      return;
    }

    final elapsedSeconds = now.difference(lastTime).inSeconds;

    if (isMoving) {
      // Moving cadence: 5 seconds with displacement > 15m or >= 10 seconds interval
      if (elapsedSeconds >= 5) {
        double displacement = 0;
        if (_lastBroadcastPosition != null) {
          displacement = Geolocator.distanceBetween(
            _lastBroadcastPosition!.latitude,
            _lastBroadcastPosition!.longitude,
            position.latitude,
            position.longitude,
          );
        }
        if (displacement >= 15.0 || elapsedSeconds >= 10) {
          _publishPosition(position);
        }
      }
    } else {
      // Stopped cadence: 30-second heartbeat
      if (elapsedSeconds >= 30) {
        _publishPosition(position);
      }
    }
  }

  void _checkHeartbeat() {
    if (_isDisposed || !state.isBroadcasting || state.lastPosition == null) return;
    final lastTime = _lastBroadcastTime;
    if (lastTime == null) return;

    final now = _now();
    if (_nextRetryTime != null && now.isBefore(_nextRetryTime!)) {
      return;
    }

    final elapsed = now.difference(lastTime).inSeconds;
    // If stopped or no fix received, keep heartbeat within 30s
    if (elapsed >= 30) {
      _publishPosition(state.lastPosition!, force: true);
    }
  }

  Future<void> _publishPosition(Position position, {bool force = false}) async {
    if (!state.isBroadcasting && !force) return;

    final speedMph = position.speed * 2.23694;
    final now = _now();

    try {
      await service.publishLivePresence(
        callerUid: callerUid,
        groupRideId: rideId,
        latitude: position.latitude,
        longitude: position.longitude,
        heading: position.heading,
        speedMph: speedMph,
        accuracyMeters: position.accuracy,
        status: state.status,
        sharingEnabled: true,
      );

      _lastBroadcastPosition = position;
      _lastBroadcastTime = now;
      _consecutiveErrors = 0;
      _nextRetryTime = null;
      state = state.copyWith(
        lastPublishedAt: now,
        errorMessage: null,
        isPaused: false,
        retryCount: 0,
      );
    } catch (e) {
      _handlePublishError(e);
    }
  }

  void _handlePublishError(Object error) {
    if (_isDisposed) return;

    final errStr = error.toString().toLowerCase();
    final isPermissionDenied = errStr.contains('permission-denied') ||
        errStr.contains('permission_denied') ||
        errStr.contains('unauthenticated');

    if (isPermissionDenied) {
      // Terminal: user removed, blocked, ride completed, or rules denied write.
      // Immediately stop broadcasting, cancel timers, and do not retry.
      _revokeBroadcasting('Authorization lost: permission denied');
      return;
    }

    // Transient network/offline error:
    _consecutiveErrors++;
    // Exponential backoff capped at 30 seconds
    final backoffSeconds = (5 * (1 << (_consecutiveErrors - 1))).clamp(5, 30);
    _nextRetryTime = _now().add(Duration(seconds: backoffSeconds));

    state = state.copyWith(
      errorMessage: 'Publish failed: $error',
      isPaused: true,
      retryCount: _consecutiveErrors,
    );
  }

  void _revokeBroadcasting(String reason) {
    _persistedOptedInRideIds.remove(rideId);
    state = state.copyWith(
      isEligible: false,
      isBroadcasting: false,
      isOptedIn: false,
      isPaused: false,
      retryCount: 0,
      errorMessage: reason,
    );
    _stopBroadcasting();

    // Clean up presence document
    service.clearLivePresence(
      callerUid: callerUid,
      groupRideId: rideId,
    );
  }

  @override
  void dispose() {
    _isDisposed = true;
    _stopBroadcasting();
    _rideSub?.cancel();
    _participantsSub?.cancel();
    _presenceSub?.cancel();

    // Clean up ephemeral presence on exit
    service.clearLivePresence(
      callerUid: callerUid,
      groupRideId: rideId,
    );
    super.dispose();
  }
}

/// Provider for LiveBroadcastController family parameterized by group ride ID.
final liveBroadcastControllerProvider = StateNotifierProvider
    .family<LiveBroadcastController, LiveBroadcastState, String>(
        (ref, rideId) {
  final user = ref.watch(currentUserProvider);
  final service = ref.watch(groupRideServiceProvider);
  final masterAllowed = ref.watch(groupRideLiveSharingAllowedProvider);
  final locationService = ref.watch(locationServiceProvider);
  final callerUid = user?.uid ?? '';

  final controller = LiveBroadcastController(
    rideId: rideId,
    callerUid: callerUid,
    service: service,
    participantsStream: callerUid.isNotEmpty
        ? service
            .participantDocStream(
                groupRideId: rideId,
                participantUid: callerUid,
            )
            .map((p) => p != null ? [p] : <GroupRideParticipant>[])
        : null,
    positionStream: locationService.getFilteredPositionStream(),
    initialMasterAllowed: masterAllowed,
  );

  // Sync master privacy changes to controller
  ref.listen<bool>(groupRideLiveSharingAllowedProvider, (prev, next) {
    controller.updateMasterAllowed(next);
  });

  return controller;
});