part of 'pickups.dart';

// -------------------------------------------------------------------------
// SCREEN 1: PICKUP MAP PREVIEW — CORPORATE REDESIGN
// -------------------------------------------------------------------------
class _PickupMapScreen extends StatefulWidget {
  final Map<String, dynamic> pickup;
  final _MyPickupsState? parentState;
  const _PickupMapScreen({required this.pickup, this.parentState});

  @override
  State<_PickupMapScreen> createState() => _PickupMapScreenState();
}

class _PickupMapScreenState extends State<_PickupMapScreen>
    with TickerProviderStateMixin, WidgetsBindingObserver {
  final MapController _mapController = MapController();

  /// Eased camera moves. `flutter_map`'s controller only teleports; the route
  /// choreography here depends on the camera landing before the line draws.
  late final MilerMapCamera _camera;
  late LatLng _pickupLocation, _dropLocation;

  /// The ends of the line currently drawn. See [_routeOrigin].
  late LatLng _routeStart, _routeEnd;

  /// True once the drawn route starts from the rider rather than from the stop.
  bool _routedFromRider = false;
  final List<Marker> _markers = <Marker>[];

  // ── Four named lines, not a set keyed by id ──
  //
  // Google Maps took a `Set<Polyline>` and sorted it by `zIndex`, so the layers
  // were addressed by string ids — 'route_casing', 'route_pulse_glow' — and
  // every frame did a `removeWhere` over the set to replace one of them.
  // `flutter_map` draws a list in order, so the order *is* the z-order and the
  // ids have nothing left to do. Naming the four layers says what the screen is
  // made of, and swapping one is an assignment rather than a search.
  Polyline? _casingLine; // the whole route, faint underneath
  Polyline? _progressLine; // the bright line, drawing itself in
  Polyline? _flowHalo; // the flow's soft halo
  Polyline? _flowCore; // the flow's bright core

  List<Polyline> get _routeLayers => <Polyline>[
    if (_casingLine != null) _casingLine!,
    if (_progressLine != null) _progressLine!,
    if (_flowHalo != null) _flowHalo!,
    if (_flowCore != null) _flowCore!,
  ];

  /// Bumped whenever a route layer changes during an animation, so that only the
  /// map is rebuilt.
  ///
  /// Calling `setState` for this instead rebuilt the entire screen sixty times a
  /// second — the header, the draggable sheet and every row inside it — to move
  /// one line on the map. On a mid-range phone that alone missed frames, and a
  /// travelling highlight that misses frames is exactly what "stuck" looks like.
  final ValueNotifier<int> _mapRepaint = ValueNotifier<int>(0);
  bool _isLoadingRoute = true;
  bool _isNavigating = false;
  bool _handlingArrival = false;

  /// Clears the in-flight flag **and rebuilds**.
  ///
  /// `_buildSwipeButton` renders a spinner in place of Navigate / I've arrived
  /// while this is true, and every exit from `_startPickupNavigation` except
  /// the happy one used to clear it with a bare assignment. No rebuild followed,
  /// so the map sat there spinning with no buttons — a screen that looks hung
  /// is indistinguishable from a confirm that did nothing.
  void _endNavigating() {
    if (!mounted) {
      _isNavigating = false;
      return;
    }
    setState(() => _isNavigating = false);
  }

  bool _hasOpenedNavigation = false;

  // Uber-style route reveal: the full route sits as a faint "casing" and the
  // bright line draws itself in from origin to destination.
  List<LatLng> _routePoints = <LatLng>[];

  /// Distance from the route's start to each point, in the same arbitrary unit.
  ///
  /// Both animations are parameterised by *distance* along this table rather
  /// than by point index, and that is the whole difference between the effect
  /// working and not. A routing API returns vertices where the road bends: a
  /// tight corner can carry twenty points across thirty metres while a highway
  /// straight carries two across a kilometre. Stepping by index therefore made
  /// the head crawl through every junction and leap down every straight — which
  /// looks like stuttering, because it is.
  List<double> _cumulative = <double>[];
  late final AnimationController _routeAnim;

  /// ── The route flow ──
  ///
  /// The draw-in happens once and is over. This is what keeps the line reading
  /// as a *direction of travel* rather than as a static shape.
  ///
  /// It used to be a comet: an 18%-of-the-route window sliding from one end to
  /// the other. At any moment the rider saw a short white dash a few hundred
  /// metres long somewhere in the middle of his journey, and a dash moving over
  /// a line reads as a decoration attached to the map rather than as anything
  /// about his trip. On a long route it was worse — 18% of 9 km is a smear that
  /// never visibly connects the two ends.
  ///
  /// Now it is one continuous stream: white grows from the rider's own position,
  /// follows every bend of the real geometry to the stop, holds for a beat, and
  /// then fades from the destination back down the line to him. That is the
  /// shape of the fact the animation is stating — *this route, from you, to
  /// there* — and it is what Uber's own route flow does.
  late final AnimationController _flowAnim;

  /// Where the cycle changes phase, as fractions of [_flowAnim].
  ///
  /// Recomputed with the controller's duration whenever a route arrives, since
  /// the grow phase is timed by distance (see [_restartFlow]) while the hold and
  /// the fade are fixed.
  double _growShare = 0.68;
  double _holdShare = 0.06;

  // ── Live distance / ETA ──
  // The rider is moving while this screen is open, so a distance captured on
  // entry is stale within a block. A position stream keeps the strip honest;
  // `distanceFilter` throttles it to every 15 m so it isn't a per-fix rebuild
  // storm on a phone that is also running Google Maps.
  StreamSubscription<Position>? _positionSub;
  Position? _livePosition;

  // Corporate Red Theme Colors
  static Color get kPrimary => ColorConstants.primary;

  /// The halo around the flowing stroke.
  ///
  /// A dark white, painted wider than the core and underneath it, so the bright
  /// stroke has something to sit in and reads as light falling on the road
  /// rather than as a white sticker laid along it.
  ///
  /// Kept warm rather than neutral grey: the route underneath is red, and a cool
  /// grey over it turns muddy at the alpha the halo runs at.
  static const Color _flowHaloColour = Color(0xFFA89E9E);

  /// How fast the stream travels, in metres of real route per second of
  /// animation. ~1.9 km/s puts an ordinary 3 km leg at a little over a second
  /// and a half, which is a glance rather than something waited out.
  static const double _flowMetresPerSecond = 1900;

  /// Grow-phase bounds. See [_restartFlow] for why the speed is what is held
  /// constant and these are only the extremes.
  ///
  /// Both moved down with the speed. Leaving the floor where it was would have
  /// meant every short leg — the ones a first-mile rider actually runs — pinned
  /// to the clamp and therefore unchanged, which is where the line read slow in
  /// the first place.
  static const double _flowGrowMinMs = 1000;
  static const double _flowGrowMaxMs = 3300;

  /// The beat at the destination before the line drains.
  static const int _flowHoldMs = 220;

  /// How long the stream takes to drain back to the rider. Kept a shade under
  /// the grow floor: a drain slower than the stroke that produced it makes the
  /// whole cycle feel like it is sagging at the end.
  static const int _flowFadeMs = 700;

  /// The bright stroke, at its brightest. 0.62 was why it "looked very lightly"
  /// — over a 6pt brand-red line a 62% white is a pink smear.
  static const double _flowCoreAlpha = 0.96;

  static const double _flowHaloAlpha = 0.42;
  static Color get kBackground => ColorConstants.surfaceContainerLow;
  static Color get kTextPrimary => ColorConstants.onSurface;
  static const Color kCardBg = Colors.white;

  @override
  void initState() {
    super.initState();
    _camera = MilerMapCamera(controller: _mapController, vsync: this);
    _routeAnim =
        AnimationController(
            vsync: this,
            // 1400 → 1800. The line covers the whole journey, and at 1.4s over a 7km
            // route it read as a wipe rather than as something travelling.
            duration: const Duration(milliseconds: 1800),
          )
          ..addListener(_onRouteAnimTick)
          // The pulse only starts once the route has finished drawing — running
          // both at once would put two heads on the same line.
          ..addStatusListener((status) {
            if (status == AnimationStatus.completed && mounted) {
              _restartFlow();
            }
          });
    // Duration is set per route — see [_restartFlow].
    _flowAnim = AnimationController(
      vsync: this,
      duration: const Duration(milliseconds: 2400),
    )..addListener(_onFlowTick);
    WidgetsBinding.instance.addObserver(this);
    _resolveLocations();
    _setMarkers();
    _createRealRoute();
    _startLiveTracking();
    _stampDeparture();
    // NOTE: We intentionally do NOT auto-launch Google Maps here. "Start pickup"
    // opens this preview (map + customer + Navigate / I've arrived). Google Maps
    // only opens when the rider explicitly taps "Navigate".
  }

  /// Records the moment the rider set off for this stop.
  ///
  /// Opening this screen *is* setting off: it is what "Start pickup" leads to,
  /// and from here on he is riding. Paired with the arrival stamp written when
  /// he confirms he is at the door, it is what lets Activity answer "how long
  /// did that stop take me" — a figure the app was measuring nowhere despite
  /// billing per kilometre on the same journey.
  ///
  /// Written once. A rider who backs out to check the list and comes back is on
  /// the same errand, and re-stamping would quietly erase the ride he has
  /// already done.
  Future<void> _stampDeparture() async {
    final pickupId = (widget.pickup['pickupid'] ?? '').toString();
    if (pickupId.isEmpty) return;
    try {
      final prefs = await SharedPreferences.getInstance();
      final key = kStopStartedKey(pickupId);
      if (prefs.getString(key) == null) {
        await prefs.setString(key, DateTime.now().toIso8601String());
      }
    } catch (e) {
      debugPrint('[MAP] Could not stamp departure: $e');
    }
  }

  /// Launches Google Maps turn-by-turn navigation to the pickup location.
  /// Tries the native navigation intent first, then falls back to the web URL.
  Future<bool> _openGoogleMapsNavigation() async {
    if (_hasOpenedNavigation) return true;
    try {
      double? originLat, originLng;
      try {
        final pos = await Geolocator.getCurrentPosition(
          locationSettings: const LocationSettings(
            accuracy: LocationAccuracy.medium,
            timeLimit: Duration(seconds: 3),
          ),
        ).timeout(const Duration(seconds: 3));
        originLat = pos.latitude;
        originLng = pos.longitude;
      } catch (_) {}

      final destLat = _pickupLocation.latitude;
      final destLng = _pickupLocation.longitude;

      final nativeUri = Uri.parse(
        'google.navigation:q=$destLat,$destLng&mode=d',
      );
      final originParam = (originLat != null && originLng != null)
          ? '&origin=$originLat,$originLng'
          : '';
      final webUri = Uri.parse(
        'https://www.google.com/maps/dir/?api=1$originParam'
        '&destination=$destLat,$destLng&travelmode=driving&dir_action=navigate',
      );

      bool launched = false;
      try {
        launched = await launchUrl(
          nativeUri,
          mode: LaunchMode.externalApplication,
        );
      } catch (e) {
        debugPrint('[MAP_NAV] Native intent failed: $e');
      }
      if (!launched) {
        try {
          launched = await launchUrl(
            webUri,
            mode: LaunchMode.externalApplication,
          );
        } catch (e) {
          debugPrint('[MAP_NAV] Web intent failed: $e');
        }
      }
      if (launched && mounted) {
        setState(() => _hasOpenedNavigation = true);
        return true;
      }
    } catch (e) {
      debugPrint('[MAP_NAV] Error opening navigation: $e');
    }
    return false;
  }

  /// Follows the rider while the stop screen is open so the distance and ETA
  /// count down as he rides. Best-effort: if permission or GPS is unavailable
  /// the strip falls back to the last known booking coordinates rather than
  /// disappearing.
  void _startLiveTracking() {
    try {
      _positionSub =
          Geolocator.getPositionStream(
            locationSettings: const LocationSettings(
              accuracy: LocationAccuracy.high,
              distanceFilter: 15,
            ),
          ).listen(
            (pos) {
              if (!mounted) return;
              setState(() => _livePosition = pos);
              // The first fix is what turns "somewhere near the stop" into a
              // route the rider can actually ride — see [_routeOrigin]. Drawn
              // once, not on every fix: re-routing every 15 m would burn
              // Directions quota and make the line twitch under his thumb.
              if (!_routedFromRider) _createRealRoute();
            },
            onError: (e) => debugPrint('[MAP_LIVE] Position stream error: $e'),
          );
    } catch (e) {
      debugPrint('[MAP_LIVE] Could not start position stream: $e');
    }
  }

  /// Where the drawn route starts.
  ///
  /// ── Why this is the rider and not the pickup ──
  ///
  /// The line used to run pickup → drop: the *parcel's* journey, from the
  /// customer's door to wherever it is going afterwards. That is a fact about
  /// the booking, not about the next twenty minutes of the rider's life — and
  /// it contradicted everything else on the screen, because the ETA, the
  /// distance and the Navigate button were all measured rider → stop. He was
  /// shown "8 min · 2.4 km" over a line that went somewhere else entirely, and
  /// on a stop where the drop was miles away the camera framed a route that did
  /// not contain him.
  ///
  /// Falls back to the pickup location when there is no fix yet, so the first
  /// frame still draws something honest; the first real fix re-routes.
  LatLng? get _routeOrigin {
    final live = _livePosition;
    if (live != null) return LatLng(live.latitude, live.longitude);
    final lat = _parseD(widget.pickup['riderslat']);
    final lng = _parseD(widget.pickup['riderslon']);
    if (lat != 0 && lng != 0) return LatLng(lat, lng);
    return null;
  }

  /// Metres from the rider to this stop, live where possible.
  double? get _liveMetersToStop {
    final lat = _livePosition?.latitude;
    final lng = _livePosition?.longitude;
    if (lat != null && lng != null) {
      return RouteMetricsHelper.distanceMeters(
        lat,
        lng,
        _pickupLocation.latitude,
        _pickupLocation.longitude,
      );
    }
    return RouteMetricsHelper.metersToStop(widget.pickup);
  }

  @override
  void dispose() {
    _positionSub?.cancel();
    WidgetsBinding.instance.removeObserver(this);
    _routeAnim.dispose();
    _flowAnim.dispose();
    _mapRepaint.dispose();
    _camera.dispose();
    _mapController.dispose();
    super.dispose();
  }

  void _resolveLocations() {
    final d = widget.pickup;
    final double pickLat = _parseD(d['pickuplat'] ?? d['PickupLat']);
    final double pickLon = _parseD(d['pickuplon'] ?? d['PickupLon']);
    final double dropLat = _parseD(
      d['droplat'] ?? d['DropLat'] ?? d['PickupyLat'],
    );
    final double dropLon = _parseD(
      d['droplon'] ?? d['DropLon'] ?? d['PickupyLong'],
    );
    final double riderLat = _parseD(d['riderslat']);
    final double riderLon = _parseD(d['riderslon']);

    final bool hasPickup = pickLat != 0 && pickLon != 0;
    final bool hasDrop = dropLat != 0 && dropLon != 0;

    _pickupLocation = hasPickup
        ? LatLng(pickLat, pickLon)
        : (riderLat != 0 && riderLon != 0
              ? LatLng(riderLat, riderLon)
              : const LatLng(10.998356, 76.977596));

    _dropLocation = hasDrop
        ? LatLng(dropLat, dropLon)
        : const LatLng(11.004556, 76.967696);

    // Sensible ends before the first route attempt has decided them, so nothing
    // downstream can read them uninitialised.
    _routeStart = _pickupLocation;
    _routeEnd = _dropLocation;
  }

  double _parseD(dynamic v) {
    if (v == null) return 0.0;
    if (v is num) return v.toDouble();
    return double.tryParse(v.toString()) ?? 0.0;
  }

  /// Two plain pins: where the rider is going, and where the parcel ends up.
  ///
  /// The address callouts that briefly lived here are gone. On a screen whose
  /// point is the route, a label large enough to read is also large enough to
  /// cover the line it is anchored to — and the sheet below already carries the
  /// customer, the full address and the live ETA, at a size that does not have
  /// to compete with map tiles. The pins mark the ends; the sheet says what
  /// they are.
  void _setMarkers() {
    final kind = stopKindOf(widget.pickup);
    _markers
      ..clear()
      ..addAll([
        milerMarker(
          point: _pickupLocation,
          width: MilerPin.size + 8,
          height: MilerPin.size + MilerPin.tail,
          // The stop takes the colour its card carried, not a stock hue. A red
          // teardrop and a green one told the rider "map pin" twice; the accent
          // tells him which of the three kinds of stop this is.
          child: MilerPin(
            color: kind.accent,
            icon: kind.icon,
            emphasised: true,
          ),
        ),
        milerMarker(
          point: _dropLocation,
          width: MilerPin.size + 8,
          height: MilerPin.size + MilerPin.tail,
          child: MilerPin(
            color: ColorConstants.acceptGreen,
            icon: Icons.flag_rounded,
          ),
        ),
      ]);
  }

  /// Swaps the stock teardrops for callouts carrying the address.
  ///
  /// ── Why a bitmap and not a widget ──
  ///
  /// Google Maps markers are textures, not part of the Flutter tree, so a label
  /// beside a pin cannot be a `Text`. The alternative the plugin offers is
  /// `InfoWindow`, which only appears on tap and covers the route it is anchored
  /// to — which is why it was doing no work here and has been removed.
  ///
  /// Uber and Rapido both draw the address *into* the marker so it is readable
  /// without touching anything: on a map, the question "which building is this"
  /// is the whole reason the pin exists.
  /// Stops the travelling highlight whenever the screen is not being looked at.
  ///
  /// The pulse repeats for as long as this route is open, and a rider can sit on
  /// this screen for a whole leg. A looping animation is one frame of work every
  /// 16ms — harmless while he is watching it, pure drain the moment he switches
  /// to Google Maps for turn-by-turn, which is exactly what the Navigate button
  /// does. It resumes on return, so he never sees the difference.
  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    if (!mounted) return;
    final visible = state == AppLifecycleState.resumed;

    if (!visible && _flowAnim.isAnimating) {
      _flowAnim.stop();
    } else if (visible &&
        !_flowAnim.isAnimating &&
        _routeAnim.status == AnimationStatus.completed) {
      _restartFlow();
    }
  }

  Future<void> _createRealRoute() async {
    // Rider → stop where we know where he is; the stop's own leg otherwise.
    // Recorded so the first GPS fix knows whether it still owes us a redraw.
    final origin = _routeOrigin;
    _routeStart = origin ?? _pickupLocation;
    _routeEnd = origin != null ? _pickupLocation : _dropLocation;
    _routedFromRider = origin != null;

    // ── No key to be missing ──
    //
    // This used to check `ApiConstants.hasMapsKey` and give up before asking,
    // because the Directions API needed a credential the app did not have. OSRM
    // needs none, so the only question left is whether the network answered.
    try {
      final points = await MilerRouter.route(_routeStart, _routeEnd);
      if (points.isEmpty) {
        _useDirectLine();
        return;
      }

      _routePoints = points;
      _buildDistanceTable();
      if (!mounted) return;

      setState(() {
        // Faint full-route "casing" (same red, low opacity) gives depth so
        // the bright line reads as drawing *over* the known path.
        _casingLine = Polyline(
          points: _routePoints,
          color: kPrimary.withValues(alpha: 0.18),
          strokeWidth: 9,
          strokeCap: StrokeCap.round,
          strokeJoin: StrokeJoin.round,
        );
        _isLoadingRoute = false;
      });

      // ── Camera first, then the line ──
      //
      // These used to fire together, so the route drew itself while the map
      // was still flying to frame it — by the time the camera settled the
      // line was already finished, which is why it looked static. Uber lands
      // the camera, lets it rest for a beat, and only then traces the route.
      unawaited(
        _fitMapToRoute().then((_) async {
          if (!mounted) return;
          await Future<void>.delayed(const Duration(milliseconds: 250));
          if (mounted) _routeAnim.forward(from: 0);
        }),
      );
    } catch (e) {
      debugPrint('[MAP] Route error: $e');
      _useDirectLine();
    }
  }

  /// Draws the straight line between the two ends when the road route cannot
  /// be had.
  ///
  /// ── Why draw anything at all ──
  ///
  /// The route request failing used to clear the spinner and leave the map
  /// bare. That is the worst of both: the screen looks finished, so the rider
  /// reads the absence of a line as "there is no route", and the one thing the
  /// map could still tell him honestly — which direction the stop is in, and
  /// roughly how far — was thrown away with the error.
  ///
  /// Dashed rather than solid, which is the whole of the disclosure: it cannot
  /// be mistaken for turn-by-turn guidance at a glance, and it is the only
  /// signal available now that the screen has no chrome to carry a message.
  /// Navigate still hands off to Google Maps, which routes with its own key and
  /// is unaffected by whatever failed here. The cause is in the log.
  void _useDirectLine() {
    _routePoints = <LatLng>[_routeStart, _routeEnd];
    _buildDistanceTable();
    if (!mounted) {
      _isLoadingRoute = false;
      return;
    }
    setState(() {
      _casingLine = Polyline(
        points: _routePoints,
        color: kPrimary.withValues(alpha: 0.35),
        strokeWidth: 5,
        // Dashed, so it reads as an approximation rather than a road.
        pattern: StrokePattern.dashed(segments: const [24, 14]),
        strokeCap: StrokeCap.round,
      );
      _isLoadingRoute = false;
    });
    _fitMapToRoute();
  }

  /// Measures the route so both animations can move at a constant speed.
  ///
  /// Longitude is scaled by cos(latitude) so a degree east is worth what it is
  /// actually worth at this latitude — without it a north-south leg and an
  /// east-west leg of the same real length would be measured differently, and
  /// the head would change pace when the road turned a corner.
  void _buildDistanceTable() {
    _cumulative = List<double>.filled(_routePoints.length, 0);
    if (_routePoints.length < 2) return;

    final meanLat =
        (_routePoints.first.latitude + _routePoints.last.latitude) / 2;
    final lonScale = math.cos(meanLat * math.pi / 180).abs();

    var run = 0.0;
    for (var i = 1; i < _routePoints.length; i++) {
      final a = _routePoints[i - 1];
      final b = _routePoints[i];
      final dy = b.latitude - a.latitude;
      final dx = (b.longitude - a.longitude) * lonScale;
      run += math.sqrt(dx * dx + dy * dy);
      _cumulative[i] = run;
    }
  }

  /// The segment index and the fraction across it at [f] of the route's LENGTH.
  ///
  /// Binary search rather than a scan: this runs several times a frame, and a
  /// linear walk over a few thousand vertices is exactly the kind of per-frame
  /// cost that shows up as jank on a mid-range phone.
  (int, double) _atDistance(double f) {
    final total = _cumulative.isEmpty ? 0.0 : _cumulative.last;
    if (total <= 0) return (0, 0);
    final target = (f.clamp(0.0, 1.0)) * total;

    var lo = 0, hi = _cumulative.length - 1;
    while (lo < hi) {
      final mid = (lo + hi + 1) >> 1;
      if (_cumulative[mid] <= target) {
        lo = mid;
      } else {
        hi = mid - 1;
      }
    }
    final i = lo.clamp(0, _routePoints.length - 2);
    final span = _cumulative[i + 1] - _cumulative[i];
    return (i, span <= 0 ? 0.0 : (target - _cumulative[i]) / span);
  }

  LatLng _pointOn(int i, double frac) {
    final a = _routePoints[i];
    final b = _routePoints[math.min(i + 1, _routePoints.length - 1)];
    return LatLng(
      a.latitude + (b.latitude - a.latitude) * frac,
      a.longitude + (b.longitude - a.longitude) * frac,
    );
  }

  /// Everything from the rider up to [head] of the route's LENGTH, with the
  /// leading end interpolated between vertices.
  ///
  /// The interpolated tip is what keeps the growing end from snapping vertex to
  /// vertex: without it the head would jump to the nearest recorded point each
  /// frame, which on a dense corner is a visible twitch.
  List<LatLng> _prefixByDistance(double head) {
    if (_routePoints.length < 2) return const <LatLng>[];
    final (idx, frac) = _atDistance(head);
    final out = <LatLng>[..._routePoints.sublist(0, idx + 1)];
    if (idx < _routePoints.length - 1) out.add(_pointOn(idx, frac));
    return out;
  }

  /// Reveals the bright red route line progressively, once, as an entrance.
  ///
  /// Eased, unlike the flow that follows it: this is the line arriving, and an
  /// entrance is allowed to accelerate. See [_onFlowTick] for why travel is not.
  void _onRouteAnimTick() {
    if (!mounted || _routePoints.length < 2) return;
    final double t = Curves.easeInOutCubic.transform(_routeAnim.value);

    _progressLine = Polyline(
      points: _prefixByDistance(t),
      color: kPrimary,
      // Heavier than the 5 it was, so the drawn line reads as the route and
      // the casing beneath it as the ground it covers.
      strokeWidth: 6,
      strokeCap: StrokeCap.round,
      strokeJoin: StrokeJoin.round,
    );

    _mapRepaint.value++;
  }

  /// Total route length in metres.
  ///
  /// [_cumulative] is in latitude-degrees with longitude already scaled by
  /// cos(lat), so one unit is one degree of latitude — 111.32 km — everywhere on
  /// the route. Good to a fraction of a percent at city scale, and free, which
  /// matters because this is only choosing an animation duration.
  double get _routeMetres =>
      _cumulative.isEmpty ? 0 : _cumulative.last * 111320.0;

  /// Starts the flow cycle, timed for this particular route.
  ///
  /// ── Why the duration is not a constant ──
  ///
  /// A fixed grow time makes the stream crawl on a 600 m hop and tear across a
  /// 9 km one — the same animation reading as two different speeds, which is
  /// exactly what "constant speed regardless of route length" rules out. So the
  /// grow phase is timed by distance at [_flowMetresPerSecond] and the stream
  /// moves at one pace on every stop the rider takes all day.
  ///
  /// Clamped at both ends only so the extremes stay watchable: under the floor a
  /// very short leg would flash, and over the ceiling a cross-city route would
  /// hold the rider's eye for longer than a glance at a map is worth. Between
  /// them — which is every ordinary first-mile leg — the speed is genuinely
  /// constant.
  void _restartFlow() {
    if (!mounted || _routePoints.length < 2) return;

    final growMs = (_routeMetres / _flowMetresPerSecond * 1000)
        .clamp(_flowGrowMinMs, _flowGrowMaxMs)
        .round();
    final totalMs = growMs + _flowHoldMs + _flowFadeMs;

    _growShare = growMs / totalMs;
    _holdShare = _flowHoldMs / totalMs;
    _flowAnim
      ..duration = Duration(milliseconds: totalMs)
      ..repeat();
  }

  /// One cycle of the flow: grow → hold → fade.
  ///
  ///   0 ──────────────── grow ────────────────▶ hold ▶─── fade ───▶ 1
  ///   white leaves the rider          reaches the stop        drains back
  ///
  /// **Grow** is linear on purpose, and sliced by *length* rather than by vertex
  /// index. The draw-in is eased because it is an entrance; this is travel, and
  /// an eased stream appears to slow down in the middle of the road for no
  /// reason. Slicing by length is what keeps it at one pace through a dense
  /// junction and a long straight alike — see [_cumulative].
  ///
  /// **Fade** is a gradient, not a uniform alpha. A whole line dimming at once
  /// is a light being switched off; a front travelling back down the route from
  /// the stop to the rider is the stream draining, which is the same motion in
  /// reverse and reads as one continuous idea. `flutter_map` will shade a
  /// polyline between its two endpoints, so the ramp costs nothing but the
  /// stops.
  void _onFlowTick() {
    if (!mounted || _routePoints.length < 2 || _cumulative.isEmpty) return;

    final frame = routeFlowFrame(
      _flowAnim.value,
      growShare: _growShare,
      holdShare: _holdShare,
    );
    final List<LatLng> points;
    final List<Color>? coreShade;
    final List<Color>? haloShade;
    double flatAlpha = 1;

    if (frame.phase == RouteFlowPhase.grow) {
      final head = frame.progress;
      points = _prefixByDistance(head);
      // A short ramp off the rider's pin so the stream starts rather than
      // appears. Without it the first frame is a full-strength stub.
      flatAlpha = (head / 0.06).clamp(0.0, 1.0);
      coreShade = null;
      haloShade = null;
    } else if (frame.phase == RouteFlowPhase.hold) {
      // Arrived. A beat at full strength, so reaching the stop registers as an
      // event instead of being the frame the fade happens to start on.
      points = _routePoints;
      coreShade = null;
      haloShade = null;
    } else {
      final f = frame.progress;
      points = _routePoints;

      coreShade = [
        for (final x in kRouteFlowStops)
          Colors.white.withValues(
            alpha: _flowCoreAlpha * routeFlowFadeAlpha(f, x),
          ),
      ];
      haloShade = [
        for (final x in kRouteFlowStops)
          _flowHaloColour.withValues(
            alpha: _flowHaloAlpha * routeFlowFadeAlpha(f, x),
          ),
      ];

      // Nothing left to draw. Clearing rather than returning early matters: a
      // bail-out leaves the previous frame's geometry on the map, which is what
      // makes a loop look like it freezes before it restarts.
      if (coreShade.every((c) => c.a < 0.01)) {
        if (_flowHalo != null || _flowCore != null) {
          _flowHalo = null;
          _flowCore = null;
          _mapRepaint.value++;
        }
        return;
      }
    }

    if (points.length < 2) {
      if (_flowHalo != null || _flowCore != null) {
        _flowHalo = null;
        _flowCore = null;
        _mapRepaint.value++;
      }
      return;
    }

    // Two concentric strokes on the same geometry — a soft halo and a bright
    // core — rather than a chain of bands at descending widths. Chained bands
    // show their joins as beads, which is the "dotted line" this used to be.
    //
    // The core is deliberately narrower than the red beneath it (4 against 6) so
    // the route stays red at its edges the whole way through. A white line as
    // wide as the route does not flow through it; it replaces it.
    _flowHalo = Polyline(
      points: points,
      color: _flowHaloColour.withValues(alpha: _flowHaloAlpha * flatAlpha),
      gradientColors: haloShade,
      colorsStop: haloShade == null ? null : kRouteFlowStops,
      strokeWidth: 10,
      strokeCap: StrokeCap.round,
      strokeJoin: StrokeJoin.round,
    );
    _flowCore = Polyline(
      points: points,
      color: Colors.white.withValues(alpha: _flowCoreAlpha * flatAlpha),
      gradientColors: coreShade,
      colorsStop: coreShade == null ? null : kRouteFlowStops,
      strokeWidth: 4,
      strokeCap: StrokeCap.round,
      strokeJoin: StrokeJoin.round,
    );

    // Only the map repaints — see [_mapRepaint].
    _mapRepaint.value++;
  }

  /// Frames the leg that is actually drawn.
  ///
  /// Framed on the line the rider is on — his position to the stop once GPS has
  /// a fix, not the booking's pickup → drop pair. The camera used to fit a route
  /// the rider was not on.
  ///
  /// The ten-attempt retry loop this replaces existed because
  /// `GoogleMapController.animateCamera` threw until the platform view had
  /// finished creating itself. `flutter_map` is a Flutter widget: its camera is
  /// available as soon as the map is in the tree, so there is nothing to retry.
  Future<void> _fitMapToRoute() async {
    if (!mounted) return;
    await _camera.fit(
      <LatLng>[_routeStart, _routeEnd],
      // Bottom-heavy: the sheet covers the lower 45% of the screen, so a route
      // centred in the *viewport* would sit centred under the sheet.
      padding: EdgeInsets.fromLTRB(48, 90, 48, 300.h),
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      backgroundColor: kBackground,
      body: Stack(
        children: [
          // Held back until the push has landed — building a Google Maps
          // platform view costs the UI thread enough to eat the slide-in
          // whole. See [AfterEntrance].
          AfterEntrance(
            placeholder: const MapPlaceholder(),
            builder: (context) =>
                // Rebuilt on its own, sixty times a second, without touching
                // the header or the sheet — see [_mapRepaint].
                ValueListenableBuilder<int>(
                  valueListenable: _mapRepaint,
                  builder: (context, _, _) => MilerMap(
                    controller: _mapController,
                    initialCenter: _pickupLocation,
                    initialZoom: 14,
                    polylines: _routeLayers,
                    markers: _markers,
                    onReady: () {
                      if (!_isLoadingRoute && _routeLayers.isNotEmpty) {
                        _fitMapToRoute();
                      }
                    },
                  ),
                ),
          ),
          if (_isLoadingRoute)
            Container(
              color: Colors.black.withValues(alpha: 0.1),
              child: Center(child: CircularProgressIndicator(color: kPrimary)),
            ),
          _buildHeader(),
          _buildDraggableBottomSheet(),
        ],
      ),
    );
  }

  Widget _buildHeader() {
    return Positioned(
      top: MediaQuery.of(context).padding.top + 12,
      left: 16,
      right: 16,
      child: Row(
        mainAxisAlignment: MainAxisAlignment.spaceBetween,
        children: [
          Container(
            decoration: BoxDecoration(
              color: ColorConstants.pureSurface,
              shape: BoxShape.circle,
              boxShadow: [
                BoxShadow(
                  color: Colors.black.withValues(alpha: 0.08),
                  blurRadius: 12,
                  offset: const Offset(0, 4),
                ),
              ],
            ),
            child: IconButton(
              tooltip: 'Back',
              onPressed: () => Navigator.pop(context),
              icon: Icon(
                Icons.arrow_back_ios_new,
                color: kTextPrimary,
                size: 16,
              ),
              padding: const EdgeInsets.all(12),
              constraints: const BoxConstraints(),
            ),
          ),
          // The floating "Pickup Location" / "Delivery Location" pill that used
          // to sit here is gone, along with the 44pt spacer that existed only to
          // centre it against the back button.
          //
          // It was a title for the map rather than information about the stop:
          // the sheet below already names the customer, prints the address and
          // carries the live ETA, and the rider arrived here from a card that
          // told him the stop type. Floating chrome over a map costs the one
          // thing a map screen is for — visible map.
        ],
      ),
    );
  }

  Widget _buildDraggableBottomSheet() {
    return DraggableScrollableSheet(
      initialChildSize: 0.45,
      minChildSize: 0.35,
      maxChildSize: 0.75,
      // ── Frosted, not opaque ──
      //
      // A solid white slab over a map takes away 45% of the one thing this
      // screen exists to show, permanently. Frosted, the rider keeps the block
      // his stop is on in view while he reads the address printed over it. See
      // [milerGlassSheet].
      builder: (context, scrollController) => milerGlassSheet(
        child: Column(
          children: [
            const SizedBox(height: 12),
            Container(
              width: 36,
              height: 4,
              decoration: BoxDecoration(
                color: ColorConstants.borderSubtle,
                borderRadius: BorderRadius.circular(DesignConstants.radiusLg),
              ),
            ),
            Expanded(
              // Content settles in (fade + gentle rise) as the route finishes
              // loading, so the sheet feels alive alongside the drawing line.
              child: AnimatedSlide(
                duration: const Duration(milliseconds: 500),
                curve: Curves.easeOutCubic,
                offset: _isLoadingRoute ? const Offset(0, 0.06) : Offset.zero,
                child: AnimatedOpacity(
                  duration: const Duration(milliseconds: 500),
                  opacity: _isLoadingRoute ? 0.0 : 1.0,
                  // ── One sheet, not a stack of cards ──
                  //
                  // This was two containers: a filled customer card, then an
                  // outlined white one holding the ETA and the address. An
                  // outline drawn around white, on a white sheet, is a line the
                  // rider has to read past to reach the only thing he came here
                  // for — and it is the opposite of what the rest of the app
                  // does, which is to fill a panel and never draw its edge (see
                  // [ColorConstants.cardSurface]).
                  //
                  // A bottom sheet is already a container. Everything inside it
                  // is one column: the ETA leads because it is the live fact,
                  // one hairline separates it from the stop it belongs to, and
                  // the actions close it. This is the shape Uber's arrival sheet
                  // has, and it is why that sheet reads at arm's length.
                  child: ListView(
                    controller: scrollController,
                    padding: EdgeInsets.fromLTRB(20.w, 18.h, 20.w, 8.h),
                    children: [
                      _LiveEtaHeader(
                        meters: _liveMetersToStop,
                        speedMps: _livePosition?.speed,
                        live: _livePosition != null,
                      ),
                      SizedBox(height: 16.h),
                      Divider(
                        height: 1,
                        thickness: 1,
                        color: ColorConstants.borderSubtle,
                      ),
                      SizedBox(height: 16.h),
                      _buildStopBrief(),
                      SizedBox(height: 24.h),
                      _buildSwipeButton(),
                    ],
                  ),
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }

  /// Who the stop is, and where — as rows on the sheet, not as cards on it.
  ///
  /// ── The name used to be printed twice ──
  ///
  /// A filled customer card carried `pickupcustomer` as its title, and the route
  /// node inside the outlined box below carried the same string again as *its*
  /// title. Two boxes, two borders and one fact stated twice, on the screen with
  /// the least room for any of it: the sheet opens at 45% of the height and the
  /// map owns the rest.
  ///
  /// The block itself is [_StopBrief], shared with Update Status and Skip. Only
  /// the status pill is local to this screen.
  Widget _buildStopBrief() {
    final status = (widget.pickup['orderstatus'] ?? '')
        .toString()
        .toUpperCase();

    return _StopBrief(
      pickup: widget.pickup,
      trailing: Flexible(
        child: Container(
          padding: EdgeInsets.symmetric(horizontal: 10.w, vertical: 5.h),
          decoration: BoxDecoration(
            color: ColorConstants.acceptGreen.withValues(alpha: 0.12),
            borderRadius: BorderRadius.circular(DesignConstants.radiusFull),
          ),
          child: Text(
            status.isNotEmpty ? status : 'PENDING',
            maxLines: 1,
            overflow: TextOverflow.ellipsis,
            style: TextStyle(
              fontFamily: FontConstants.fontFamily,
              color: ColorConstants.acceptGreen,
              fontSize: 10.sp,
              fontWeight: FontWeight.w800,
              letterSpacing: 0.3,
            ),
          ),
        ),
      ),
    );
  }

  Widget _buildSwipeButton() {
    if (_isNavigating) {
      return Container(
        height: ButtonSizes.primary,
        decoration: BoxDecoration(
          color: ColorConstants.acceptGreen,
          borderRadius: BorderRadius.circular(ButtonSizes.radius),
        ),
        child: const Center(
          child: SizedBox(
            width: 20,
            height: 20,
            child: CircularProgressIndicator(
              color: Colors.white,
              strokeWidth: 2.5,
            ),
          ),
        ),
      );
    }

    // Two clear actions: re-launch navigation (in case the rider dismissed
    // Google Maps) and confirm arrival. Slides are reserved for money.
    //
    // ── Both green, only one filled ──
    //
    // These were both `kPrimary` — the brand maroon — which put the forward
    // action of the whole flow in the same hue as Reject, Cancel and every
    // destructive confirmation in the app. One rule holds now: green advances
    // the job, maroon is brand and navigation, red destroys.
    //
    // Navigate stays *outlined* because it is the secondary of the pair — a way
    // to re-open Maps, not the thing this screen is for — but it takes the same
    // green so the two read as one family rather than as two unrelated
    // decisions.
    return SizedBox(
      height: ButtonSizes.primary,
      width: double.infinity,
      child: Row(
        children: [
          Expanded(
            flex: 4,
            child: MilerButton(
              label: 'Navigate',
              icon: Icons.navigation_rounded,
              variant: MilerButtonVariant.outlined,
              color: ColorConstants.acceptGreen,
              onPressed: () {
                _hasOpenedNavigation = false;
                _openGoogleMapsNavigation();
              },
            ),
          ),
          const SizedBox(width: 12),
          Expanded(
            flex: 6,
            child: MilerButton(
              label: "I've arrived",
              icon: Icons.check_circle_rounded,
              color: ColorConstants.acceptGreen,
              onPressed: () async {
                debugPrint('[ARRIVED] Tapped "I have arrived" on map screen');
                await _handleArrived();
              },
            ),
          ),
        ],
      ),
    );
  }

  Future<bool> _handleArrived() async {
    if (_handlingArrival || _isNavigating || !mounted) return false;
    _handlingArrival = true;

    try {
      final verifyResult = await openSheet<Map<String, dynamic>>(
        context,
        StopVerificationPage(pickup: widget.pickup),
      );

      if (verifyResult == null ||
          verifyResult['verified'] != true ||
          !mounted) {
        _handlingArrival = false;
        return false;
      }

      await _startPickupNavigation(verifyResult);
    } catch (e) {
      if (mounted) {
        AppFeedback.error(context, 'Could not open that stop — try again');
      }
      _handlingArrival = false;
      return false;
    }
    _handlingArrival = false;
    return true;
  }

  Future<void> _startPickupNavigation(
    Map<String, dynamic> verificationData,
  ) async {
    if (_isNavigating || !mounted) return;
    setState(() => _isNavigating = true);

    try {
      final dc = Get.put(PickupsController(), permanent: true);
      final d = widget.pickup;
      final int pickupId =
          int.tryParse(
            '${d['PickupId'] ?? d['pickupId'] ?? d['pickupid'] ?? 0}',
          ) ??
          0;
      final String orderId = (d['orderid'] ?? d['OrderId'] ?? '').toString();
      final int orderHeaderId =
          int.tryParse('${d['orderheaderid'] ?? d['OrderHeaderId'] ?? 0}') ?? 0;

      if (pickupId > 0) {
        final prefs = await SharedPreferences.getInstance();
        // He is at the door: verification has just passed. Read back at
        // completion — see [addCompletedBookings].
        await prefs.setString(
          kStopArrivedKey(pickupId),
          DateTime.now().toIso8601String(),
        );
        final rawEta = d['eta'];
        int etaMinutes = int.tryParse(rawEta?.toString() ?? '0') ?? 0;
        if (etaMinutes > 0) {
          final now = DateTime.now();
          final endTime =
              now.add(Duration(minutes: etaMinutes)).millisecondsSinceEpoch ~/
              1000;
          await prefs.setInt('eta_endtime_$orderId', endTime);
        }
      }

      String riderLatStr = '0', riderLngStr = '0';
      try {
        final position = await Geolocator.getCurrentPosition(
          locationSettings: const LocationSettings(
            accuracy: LocationAccuracy.medium,
            timeLimit: Duration(seconds: 3),
          ),
        ).timeout(const Duration(seconds: 3));
        riderLatStr = position.latitude.toStringAsFixed(6);
        riderLngStr = position.longitude.toStringAsFixed(6);
      } catch (_) {}

      if (!mounted) {
        _endNavigating();
        return;
      }

      // Mark this pickup active — the rider has arrived and verified the
      // parcel. (Done before the confirm sheet so live tracking / active
      // state is in place while confirming.)
      final _MyPickupsState? parentState =
          widget.parentState ??
          context.findAncestorStateOfType<_MyPickupsState>();
      if (pickupId > 0 && orderId.isNotEmpty) {
        dc.updateActiveStatus(
          pickupId: pickupId,
          orderHeaderId: orderHeaderId,
          ridersLat: riderLatStr,
          ridersLng: riderLngStr,
          orderId: orderId,
        );

        if (parentState != null) {
          parentState._activePickupOrderId = orderId;
          d['orderstatus'] = 'active';
          await parentState._startPickupPosting(d);
          parentState.setState(() {});
        }
      }

      if (!mounted) {
        _endNavigating();
        return;
      }

      // ── Step 2 of the v1 pickup flow: what he actually took ──
      //
      // This is the last moment the parcel's real weight can be recorded.
      // `pickup-complete` (step 4, a few lines below) recomputes the chargeable
      // weight from whatever `parcel` submitted, and once the booking has
      // become a consignment there is nothing left to attach a measurement to.
      // The rider typed it on the verification screen thirty seconds ago and
      // the app used to throw it away.
      //
      // Not fatal if it fails: the stop still completes and bills on the
      // customer's booked estimate instead of the measured figure. Blocking the
      // rider at a doorstep over a billing detail would be the worse trade.
      if (pickupId > 0) {
        final parcelRes = await UpdatePickupProvider().submitParcels(
          pickupId,
          verificationData,
        );
        if (parcelRes?['status'] != true) {
          debugPrint(
            '[PARCEL] booking $pickupId: not recorded — $parcelRes',
          );
        }
      }

      if (!mounted) {
        _endNavigating();
        return;
      }

      // Milk-run model: there is no per-stop drop leg. After verifying the
      // parcel the rider just confirms this pickup and moves to the next
      // stop — so open the confirm/payment sheet directly instead of a
      // redundant "navigate to drop" screen. On completion we return to the
      // pickup list (a confirmed stop drops off; a dismissed one stays for
      // retry).
      final dynamic result = await showModalBottomSheet<dynamic>(
        context: context,
        sheetAnimationStyle: kMilerSheetStyle,
        isScrollControlled: true,
        backgroundColor: Colors.transparent,
        shape: const RoundedRectangleBorder(
          borderRadius: BorderRadius.vertical(top: Radius.circular(24)),
        ),
        builder: (sheetContext) =>
            _PickupBottomSheet(pickup: widget.pickup, parentState: parentState),
      );

      if (!mounted) {
        _endNavigating();
        return;
      }

      // The sheet returns an outcome map on picked-up / cancelled. We (a normal
      // page route) show the success screen with its "Move to next stop"
      // button.
      debugPrint('[CONFIRM] sheet returned: $result');

      if (result is Map &&
          (result['outcome'] == 'completed' ||
              result['outcome'] == 'cancelled')) {
        // ── The bookkeeping must never cost the rider his next stop ──
        //
        // Removing the finished stop from the live list and reading the
        // remainder used to sit inside the same try as the navigation below,
        // so anything that threw in here — a disposed parent, a prefs write —
        // was caught by the outer handler, which logged and set a flag. The
        // stop was completed on the server and the rider was left standing on
        // the map screen with nothing to press, which reads exactly like a
        // dead Confirm button.
        //
        // The stop is finished either way, so the hand-off screen opens either
        // way; a failure here costs at most a stale "next stops" list, which
        // that screen re-fetches for itself.
        final bool cancelled = result['outcome'] == 'cancelled';

        // ── Stamp the compliance while it is still knowable ──
        //
        // The ETA deadline lives in a prefs key the next stop overwrites, and
        // the distance is measured from the previous stop's position, which has
        // also moved on. `PickupsController` has just computed both to decide
        // the bonus; this is the one moment they can be written down. See
        // [StopCompliance].
        try {
          widget.pickup['compliance'] = StopCompliance(
            onTime: dc.lastOnTime.value,
            lateBy: dc.lastLateBy.value,
            actualKm: dc.lastRiderKms.value > 0 ? dc.lastRiderKms.value : null,
            plannedKm: double.tryParse((widget.pickup['kms'] ?? '').toString()),
          ).toJson();

          // ── What was actually handled, and what was actually taken ──
          //
          // The weight the rider measured, the parcels he counted and the money
          // he collected exist only in the two sheets he has just closed. They
          // are the answers to every question asked of a finished stop
          // afterwards — "was that the 4.5 kg one?", "did he take the cash?" —
          // and without this they die with the sheets.
          widget.pickup['proof'] = <String, dynamic>{
            if ((verificationData['weight'] ?? '').toString().trim().isNotEmpty)
              'weight': verificationData['weight'],
            if (verificationData['pickup'] is Map)
              'collected': (verificationData['pickup'] as Map)['collected'],
            if (verificationData['delivery'] is Map)
              'handedover': (verificationData['delivery'] as Map)['handedOver'],
            if (result['paymentMethod'] != null)
              'paymentmethod': result['paymentMethod'],
            if (result['amountCollected'] != null)
              'amountcollected': result['amountCollected'],
          };
        } catch (e) {
          debugPrint('[CONFIRM] could not stamp completion detail: $e');
        }

        List<Map<String, dynamic>>? remaining;
        try {
          if (parentState != null) {
            parentState.markPickupFinished(widget.pickup, cancelled: cancelled);
            remaining = parentState.remainingPickups();
          } else {
            // Reached without the Bookings state behind it — from Home's live
            // banner, or after a rebuild. The stop is still finished, and
            // Activity still has to know.
            await addCompletedBookings([widget.pickup], cancelled: cancelled);
          }
        } catch (e) {
          debugPrint('[CONFIRM] post-completion bookkeeping failed: $e');
        }

        if (!mounted) {
          _endNavigating();
          return;
        }

        replaceWithSheet(
          context,
          PickupsDone(
            isCancelled: cancelled,
            isDelivery: result['isDelivery'] == true,
            bonusPoints: (result['bonusPoints'] as int?) ?? 0,
            paymentMethod: result['paymentMethod'] as String?,
            remainingOrders: remaining,
            parentState: parentState,
          ),
        );
      } else if (result == true) {
        // Skipped. The stop is parked, so leave the map and go back to the list
        // one route at a time rather than unwinding to the app root.
        Navigator.of(context).pop();
      }
      // Dismissed (null): stay on the map. Swiping a sheet away is a change of
      // mind about the sheet, not about the stop — this used to
      // `popUntil(isFirst)`, which threw the rider all the way out to the tab
      // shell and lost the stop he was working.
      _endNavigating();
    } catch (e) {
      debugPrint('[ERROR] _startPickupNavigation: $e');
      _endNavigating();
      // Never fail silently here. Everything in this method sits between the
      // rider pressing a button and the screen changing, so a swallowed
      // exception looks like a dead button and he will press it again.
      if (mounted) {
        AppFeedback.error(context, "Couldn't finish that stop — try again");
      }
    }
  }
}

// ── Live ETA header (Uber-style) ─────────────────────────────────────────────
//
// Previously this was a yellow warning-coloured box. Two things were wrong
// with that: amber is the app's WARNING colour, so a perfectly healthy stop
// looked like a problem; and boxing the number inside a tinted container made
// it compete with the address block underneath instead of leading it.
//
// Uber's pattern, and the one used here: the arrival time is simply the
// biggest thing on the card. No container, no fill, no border — hierarchy is
// carried by type size alone, and a hairline divider separates it from the
// address. The number is the headline; everything else is a caption.
//
//     8 min                                  ● LIVE
//     2.4 km away  ·  Arrive by 4:35 PM
//     ──────────────────────────────────────────────
//     PICKUP LOCATION …
class _LiveEtaHeader extends StatelessWidget {
  final double? meters;
  final double? speedMps;
  final bool live;

  const _LiveEtaHeader({
    required this.meters,
    required this.speedMps,
    required this.live,
  });

  @override
  Widget build(BuildContext context) {
    final travel = RouteMetricsHelper.travelTime(
      meters,
      liveSpeedMps: speedMps,
    );
    final distance = RouteMetricsHelper.formatDistance(meters);
    final arrival = RouteMetricsHelper.formatEta(
      meters,
      liveSpeedMps: speedMps,
    );
    final known = travel > Duration.zero;

    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        Row(
          crossAxisAlignment: CrossAxisAlignment.center,
          children: [
            // The headline: minutes away, at display size.
            //
            // Expanded, not a bare Text with a Spacer after it. At display size
            // "Calculating…" is already 20pt, and the row overflowed from about
            // 1.3x system text upward — striping the sheet's own headline, on
            // the screen a rider reads at arm's length precisely because he has
            // the font turned up.
            Expanded(
              child: Text(
                known
                    ? RouteMetricsHelper.formatDuration(travel)
                    : 'Calculating…',
                maxLines: 1,
                overflow: TextOverflow.ellipsis,
                style: TextStyle(
                  fontSize: known ? 30 : 20,
                  height: 1.05,
                  fontWeight: FontWeight.w800,
                  letterSpacing: -1.0,
                  color: ColorConstants.slateText,
                  fontFamily: FontConstants.fontFamily,
                ),
              ),
            ),
            const SizedBox(width: 10),
            // A live badge only when a position stream is actually feeding
            // this. A stale ETA that looks live is worse than no ETA.
            if (live)
              Row(
                mainAxisSize: MainAxisSize.min,
                children: [
                  Container(
                    width: 7,
                    height: 7,
                    decoration: BoxDecoration(
                      color: ColorConstants.acceptGreen,
                      shape: BoxShape.circle,
                    ),
                  ),
                  const SizedBox(width: 5),
                  Text(
                    'LIVE',
                    style: TextStyle(
                      fontSize: 10,
                      fontWeight: FontWeight.w800,
                      letterSpacing: 0.8,
                      color: ColorConstants.acceptGreen,
                      fontFamily: FontConstants.fontFamily,
                    ),
                  ),
                ],
              ),
          ],
        ),
        const SizedBox(height: 3),
        Text(
          known
              ? '$distance away  ·  Arrive by $arrival'
              : 'Waiting for a GPS fix',
          style: TextStyle(
            fontSize: 13.5,
            fontWeight: FontWeight.w700,
            letterSpacing: -0.1,
            color: ColorConstants.secondaryText,
            fontFamily: FontConstants.fontFamily,
          ),
        ),
      ],
    );
  }
}

/// ── The flow cycle, as arithmetic ──
///
/// Top-level and pure so the behaviour can be asserted directly. The animation
/// itself sits behind a live route, a `TickerProvider` and a map, none of which
/// a widget test can stand up — but "the white line starts at the rider, reaches
/// the stop, then drains back to him" is a claim about numbers, and this is
/// where it is held. See `test/route_flow_test.dart`.

/// Which part of the cycle a frame is in.
enum RouteFlowPhase {
  /// White growing from the rider towards the stop.
  grow,

  /// Arrived, holding at full strength.
  hold,

  /// Draining back from the stop towards the rider.
  fade,
}

/// Where in the cycle [t] falls, and how far through that phase it is.
///
/// [progress] is always 0→1 *within* the phase, so callers never re-derive the
/// phase boundaries — which is how the grow and the fade drifted apart when this
/// was inline.
({RouteFlowPhase phase, double progress}) routeFlowFrame(
  double t, {
  required double growShare,
  required double holdShare,
}) {
  final clamped = t.clamp(0.0, 1.0);
  if (growShare > 0 && clamped <= growShare) {
    return (phase: RouteFlowPhase.grow, progress: clamped / growShare);
  }
  if (clamped <= growShare + holdShare) {
    final span = holdShare;
    return (
      phase: RouteFlowPhase.hold,
      progress: span <= 0 ? 1.0 : (clamped - growShare) / span,
    );
  }
  final span = 1 - growShare - holdShare;
  return (
    phase: RouteFlowPhase.fade,
    progress: span <= 0 ? 1.0 : (clamped - growShare - holdShare) / span,
  );
}

/// Gradient stops the fade is sampled at, along the route.
const List<double> kRouteFlowStops = [0, 0.25, 0.5, 0.75, 1];

/// Softness of the draining front, as a share of the route's length. A hard
/// edge travelling down the line reads as a wipe; this is what makes it a fade.
const double kRouteFlowFadeRamp = 0.35;

/// Opacity multiplier at position [x] along the route (0 = rider, 1 = stop)
/// when the fade is [f] through.
///
/// The front starts just past the stop and travels to just past the rider, so
/// the line is whole at f=0 and gone at f=1 rather than already clipped at
/// either end — which is what made the old loop appear to restart early.
double routeFlowFadeAlpha(
  double f,
  double x, {
  double ramp = kRouteFlowFadeRamp,
}) {
  final front = (1 + ramp) - f.clamp(0.0, 1.0) * (1 + 2 * ramp);
  return ((front - x) / ramp).clamp(0.0, 1.0);
}