analytics_manager.dart

import 'dart:async';
import 'dart:convert';

import 'package:crypto/crypto.dart';
import 'package:flutter/foundation.dart';
import 'package:package_info_plus/package_info_plus.dart';

import 'package:omi/backend/preferences.dart';
import 'package:omi/backend/schema/bt_device/bt_device.dart';
import 'package:omi/backend/schema/conversation.dart';
import 'package:omi/backend/schema/memory.dart';
import 'package:omi/env/env.dart';
import 'package:omi/utils/analytics/adapters/posthog_adapter.dart';
import 'package:omi/utils/analytics/analytics_adapter.dart';
import 'package:omi/utils/analytics/intercom.dart';
import 'package:omi/utils/device.dart';
import 'package:omi/utils/platform/platform_service.dart';
import 'package:shared_preferences/shared_preferences.dart';

class AnalyticsManager {
  static final AnalyticsManager _instance = AnalyticsManager._internal();
  static AnalyticsAdapter? _adapter;
  static bool _initStarted = false;
  static final SharedPreferencesUtil _preferences = SharedPreferencesUtil();
  static final Map<String, DateTime> _pendingTimedEvents = {};
  static const Duration _pendingTimedEventTtl = Duration(hours: 1);
  static const Duration _initTimeout = Duration(seconds: 2);
  static const int _maxQueuedEvents = 200;
  static const int _flushBatchSize = 20;
  static const int _maxDeliveryAttempts = 3;
  static const List<Duration> _retryDelays = [Duration(seconds: 1), Duration(seconds: 5), Duration(seconds: 30)];
  static final List<_QueuedAnalyticsEvent> _queuedEvents = [];
  static bool _flushScheduled = false;
  static bool _flushInProgress = false;
  static Timer? _retryTimer;
  static int _droppedEvents = 0;
  static Map<String, Object> _globalEventProperties = {'app_platform': _mobilePlatformName};
  static bool _analyticsReady = false;

  /// Inject the analytics adapter at boot. Must be called before [init].
  /// Calling without ever configuring leaves every method as a no-op, which
  /// is the right behavior for environments without an analytics key (e.g.
  /// local dev with no PostHog token).
  static void configure(AnalyticsAdapter adapter) {
    assert(!_initStarted, 'AnalyticsManager.configure() must be called before init().');
    _adapter = adapter;
  }

  static Future<void> init({Duration timeout = _initTimeout}) async {
    _initStarted = true;
    if (_adapter == null && Env.posthogApiKey != null) {
      _adapter = PostHogAnalyticsAdapter(apiKey: Env.posthogApiKey!);
    }
    final adapter = _adapter;
    if (adapter == null) return;
    try {
      await PlatformService.executeIfSupportedAsync(
        PlatformService.isAnalyticsSupported,
        adapter.init,
      ).timeout(timeout);
      await _loadGlobalEventProperties(timeout: timeout);
      await _loadPersonPropertyCache();
      _analyticsReady = true;
      _retryTimer?.cancel();
      _retryTimer = null;
      _scheduleFlush();
    } catch (_) {}
  }

  static Future<void> flushPending({bool force = false}) => _flushQueuedEvents(force: force);

  @visibleForTesting
  static int get queuedEventCountForTesting => _queuedEvents.length;

  @visibleForTesting
  static int get droppedEventCountForTesting => _droppedEvents;

  @visibleForTesting
  static Duration retryDelayForTesting(int attempts) => _retryDelayForAttempt(attempts);

  @visibleForTesting
  static void resetForTesting() {
    _adapter = null;
    _initStarted = false;
    _pendingTimedEvents.clear();
    _lastSentPersonProperty.clear();
    _personPropertyCacheLoaded = false;
    _queuedEvents.clear();
    _flushScheduled = false;
    _flushInProgress = false;
    _retryTimer?.cancel();
    _retryTimer = null;
    _droppedEvents = 0;
    _globalEventProperties = {'app_platform': _mobilePlatformName};
    _analyticsReady = false;
  }

  factory AnalyticsManager() {
    return _instance;
  }

  AnalyticsManager._internal();

  void setUserAttribute(String key, dynamic value) {
    setUserProperty(key, value);
    PlatformService.executeIfSupported(PlatformService.isIntercomSupported, () {
      IntercomManager.instance.updateCustomAttributes({key: value});
    });
  }

  void setUserAttributes() {
    setPeopleValues();
    PlatformService.executeIfSupported(PlatformService.isIntercomSupported, () {
      IntercomManager.instance.setUserAttributes();
    });
  }

  void trackEvent(String eventName, {Map<String, dynamic>? properties}) {
    track(eventName, properties: properties);
  }

  void setInteractionContext({String? screenName, required String target}) =>
      PlatformService.executeIfSupported(PlatformService.isAnalyticsSupported, () {
        final adapter = _adapter;
        if (adapter == null || !adapter.isInitialized) return;
        try {
          adapter.setInteractionContext(screenName: screenName, target: target);
        } catch (_) {}
      });

  setPeopleValues() {
    _setUserPropertiesBatch({
      'Notifications Enabled': _preferences.notificationsEnabled,
      'Location Enabled': _preferences.locationEnabled,
      'Apps Enabled Count': _preferences.enabledAppsCount,
      'Apps Integrations Enabled Count': _preferences.enabledAppsIntegrationsCount,
      'Speaker Profile': _preferences.hasSpeakerProfile,
      'Calendar Enabled': _preferences.calendarEnabled,
      'Primary Language': _preferences.userPrimaryLanguage,
      'Authorized Storing Recordings': _preferences.permissionStoreRecordingsEnabled,
    });
  }

  void setSubscriptionTier(String tier) => setUserProperty('Subscription Tier', tier);

  setUserProperty(String key, dynamic value) => _setUserPropertiesBatch({key: value});

  void _setUserPropertiesBatch(Map<String, dynamic> properties) =>
      PlatformService.executeIfSupported(PlatformService.isAnalyticsSupported, () {
        final adapter = _adapter;
        if (adapter == null) return;
        // If the SDK silently drops the identify call we must not cache it as
        // sent — that would suppress every retry once the SDK is ready.
        if (!adapter.isInitialized) return;
        final uid = _preferences.uid;
        if (uid.isEmpty) return;
        final coerced = <String, Object>{};
        properties.forEach((k, v) {
          final c = _coerceProperty(v);
          if (c != null) coerced[k] = c;
        });
        if (coerced.isEmpty) return;
        final fresh = <String, Object>{};
        final pending = <String, String>{};
        coerced.forEach((k, v) {
          final cacheKey = '$uid:$k';
          final serialized = _serializePersonPropertyValue(v);
          if (_lastSentPersonProperty[cacheKey] == serialized) return;
          fresh[k] = v;
          pending[cacheKey] = serialized;
        });
        if (fresh.isEmpty) return;
        try {
          adapter.identify(userId: uid, userProperties: fresh);
          pending.forEach((cacheKey, serialized) {
            _lastSentPersonProperty[cacheKey] = serialized;
            _persistPersonPropertyCacheEntry(cacheKey, serialized);
          });
        } catch (_) {}
      });

  static const String _personPropertyCachePrefix = '_ph_lastset_';
  static final Map<String, String> _lastSentPersonProperty = {};
  static bool _personPropertyCacheLoaded = false;

  static Future<void> _loadPersonPropertyCache() async {
    if (_personPropertyCacheLoaded) return;
    try {
      final prefs = await SharedPreferences.getInstance();
      for (final key in prefs.getKeys()) {
        if (!key.startsWith(_personPropertyCachePrefix)) continue;
        final v = prefs.getString(key);
        if (v == null) continue;
        _lastSentPersonProperty[key.substring(_personPropertyCachePrefix.length)] = v;
      }
    } catch (_) {}
    _personPropertyCacheLoaded = true;
  }

  static Future<void> _persistPersonPropertyCacheEntry(String cacheKey, String value) async {
    try {
      final prefs = await SharedPreferences.getInstance();
      await prefs.setString('$_personPropertyCachePrefix$cacheKey', value);
    } catch (_) {}
  }

  // Tagged so the bool `true` doesn't collide with the string `"true"`.
  static String _serializePersonPropertyValue(Object value) {
    if (value is bool) return 'b:$value';
    if (value is num) return 'n:$value';
    if (value is String) return 's:$value';
    return 'x:${value.runtimeType}:$value';
  }

  static Future<void> _clearPersonPropertyCache() async {
    _lastSentPersonProperty.clear();
    _personPropertyCacheLoaded = false;
    try {
      final prefs = await SharedPreferences.getInstance();
      final keys = prefs.getKeys().where((k) => k.startsWith(_personPropertyCachePrefix)).toList();
      for (final k in keys) {
        await prefs.remove(k);
      }
    } catch (_) {}
  }

  void optInTracking() {
    PlatformService.executeIfSupported(PlatformService.isAnalyticsSupported, () {
      final adapter = _adapter;
      if (adapter == null) return;
      try {
        adapter.enable();
      } catch (_) {}
      identify();
    });
  }

  void optOutTracking() {
    PlatformService.executeIfSupported(PlatformService.isAnalyticsSupported, () {
      final adapter = _adapter;
      if (adapter == null) return;
      try {
        adapter.disable();
        adapter.reset();
      } catch (_) {}
      unawaited(_clearPersonPropertyCache());
    });
  }

  void identify({String? authMethod, DateTime? userCreatedAt, String userRole = 'member'}) {
    PlatformService.executeIfSupported(PlatformService.isAnalyticsSupported, () {
      final adapter = _adapter;
      if (adapter == null) return;
      final uid = _preferences.uid;
      if (uid.isEmpty) return;
      try {
        adapter.identify(userId: uid);
      } catch (_) {
        return;
      }
      _instance.setPeopleValues();
      _setUserPropertiesBatch({
        if (authMethod != null) 'auth_method': authMethod,
        if (userCreatedAt != null) 'user_created_at': userCreatedAt.toUtc().toIso8601String(),
        'user_role': userRole,
      });
      setNameAndEmail();
    });
  }

  void accountCreated({required String authProvider, String acquisitionSource = 'mobile_oauth'}) {
    track(
      'Account Created',
      properties: {'is_first_auth': true, 'auth_provider': authProvider, 'acquisition_source': acquisitionSource},
    );
  }

  void migrateUser(String newUid) {
    PlatformService.executeIfSupported(PlatformService.isAnalyticsSupported, () {
      final adapter = _adapter;
      if (adapter == null) return;
      unawaited(_clearPersonPropertyCache());
      try {
        adapter.alias(newUserId: newUid);
        adapter.identify(userId: newUid);
      } catch (_) {
        return;
      }
      setNameAndEmail();
    });
  }

  void setNameAndEmail() {
    _setUserPropertiesBatch({'\$name': SharedPreferencesUtil().fullName, '\$email': SharedPreferencesUtil().email});
  }

  void track(String eventName, {Map<String, dynamic>? properties}) =>
      PlatformService.executeIfSupported(PlatformService.isAnalyticsSupported, () {
        final adapter = _adapter;
        if (adapter == null) return;
        final props = <String, Object>{};
        if (properties != null) {
          properties.forEach((k, v) {
            final coerced = _coerceProperty(v);
            if (coerced != null) props[k] = coerced;
          });
        }
        _evictStaleTimedEvents();
        final start = _pendingTimedEvents.remove(eventName);
        if (start != null) {
          props['\$duration'] = DateTime.now().difference(start).inMilliseconds / 1000.0;
        }
        _enqueueEvent(_QueuedAnalyticsEvent(eventName: eventName, properties: props));
      });

  static void _enqueueEvent(_QueuedAnalyticsEvent event) {
    while (_queuedEvents.length >= _maxQueuedEvents) {
      _queuedEvents.removeAt(0);
      _droppedEvents++;
    }
    _queuedEvents.add(event);
    _scheduleFlush();
  }

  static void _scheduleFlush() {
    if (_flushScheduled || _flushInProgress || (_retryTimer?.isActive ?? false)) return;
    _flushScheduled = true;
    unawaited(
      Future<void>.microtask(() async {
        _flushScheduled = false;
        await _flushQueuedEvents();
      }),
    );
  }

  static Future<void> _flushQueuedEvents({bool force = false}) async {
    if (_flushInProgress) return;
    if (force) {
      _retryTimer?.cancel();
      _retryTimer = null;
    } else if (_retryTimer?.isActive ?? false) {
      return;
    }
    var retryLater = false;
    var flushAgain = false;
    var retryDelay = _retryDelays.last;
    _flushInProgress = true;
    try {
      final adapter = _adapter;
      if (adapter == null || !adapter.isInitialized || !_analyticsReady) {
        retryLater = _queuedEvents.isNotEmpty;
        retryDelay = _retryDelays.last;
        return;
      }

      var delivered = 0;
      while (_queuedEvents.isNotEmpty && delivered < _flushBatchSize) {
        final event = _queuedEvents.removeAt(0);
        try {
          adapter.track(eventName: event.eventName, properties: {...event.properties, ..._globalEventProperties});
          delivered++;
        } catch (_) {
          final retriedEvent = event.nextAttempt();
          _requeueOrDrop(retriedEvent);
          retryLater = _queuedEvents.isNotEmpty;
          retryDelay = _retryDelayForAttempt(event.attempts);
          return;
        }
      }
      flushAgain = _queuedEvents.isNotEmpty;
    } finally {
      _flushInProgress = false;
      if (retryLater) {
        _scheduleRetry(retryDelay);
      } else if (flushAgain) {
        _scheduleFlush();
      }
    }
  }

  static void _requeueOrDrop(_QueuedAnalyticsEvent event) {
    if (event.attempts >= _maxDeliveryAttempts) {
      _droppedEvents++;
      return;
    }
    _queuedEvents.insert(0, event);
  }

  static Duration _retryDelayForAttempt(int attempts) {
    final delayIndex = attempts <= 0 ? 0 : attempts;
    if (delayIndex >= _retryDelays.length) return _retryDelays.last;
    return _retryDelays[delayIndex];
  }

  static void _scheduleRetry(Duration delay) {
    if (_retryTimer?.isActive ?? false) return;
    _retryTimer = Timer(delay, _scheduleFlush);
  }

  void startTimingEvent(String eventName) =>
      PlatformService.executeIfSupported(PlatformService.isAnalyticsSupported, () {
        if (_adapter == null) return;
        _evictStaleTimedEvents();
        _pendingTimedEvents[eventName] = DateTime.now();
      });

  // Drop pending starts that exceeded the TTL — guards against unbounded growth
  // when a startTimingEvent has no matching track() (navigation away, crash, short-circuit).
  static void _evictStaleTimedEvents() {
    if (_pendingTimedEvents.isEmpty) return;
    final cutoff = DateTime.now().subtract(_pendingTimedEventTtl);
    _pendingTimedEvents.removeWhere((_, started) => started.isBefore(cutoff));
  }

  void onboardingCompleted() => track('Onboarding Completed');

  void onboardingStepCompleted(String step) => track('Onboarding Step $step Completed');

  void onboardingUserAcquisitionSource(String source) =>
      track('User Acquisition Source', properties: {'source': source});

  // Interactive device onboarding
  void deviceOnboardingStarted({String source = 'auto'}) =>
      track('Device Onboarding Started', properties: {'source': source});

  void deviceOnboardingStepCompleted(String step) =>
      track('Device Onboarding Step Completed', properties: {'step': step});

  void deviceOnboardingCompleted() => track('Device Onboarding Completed');

  void deviceOnboardingAbandoned(int step) => track('Device Onboarding Abandoned', properties: {'step': step});

  void deviceOnboardingDoubleTapConfigured(int action) =>
      track('Device Onboarding Double Tap Configured', properties: {'action': action});

  void settingsSaved({bool hasWebhookConversationCreated = false, bool hasWebhookTranscriptReceived = false}) => track(
        'Developer Settings Saved',
        properties: {
          'has_webhook_memory_created': hasWebhookConversationCreated,
          'has_webhook_transcript_received': hasWebhookTranscriptReceived,
        },
      );

  void pageOpened(String name) {
    setInteractionContext(screenName: name, target: 'screen');
    track('$name Opened');
  }

  void appEnabled(String appId) {
    track('App Enabled', properties: {'app_id': appId});
    setUserProperty('Apps Enabled Count', _preferences.enabledAppsCount);
  }

  void appPurchaseStarted(String appId) => track('App Purchase Started', properties: {'app_id': appId});

  void appPurchaseCompleted(String appId) => track('App Purchase Completed', properties: {'app_id': appId});

  void privateAppSubmitted(Map<String, dynamic> properties) => track('Private App Submitted', properties: properties);

  void publicAppSubmitted(Map<String, dynamic> properties) => track('Public App Submitted', properties: properties);

  void appDisabled(String appId) {
    track('App Disabled', properties: {'app_id': appId});
    setUserProperty('Apps Enabled Count', _preferences.enabledAppsCount);
  }

  void appRated(String appId, double rating) {
    track('App Rated', properties: {'app_id': appId, 'rating': rating});
  }

  void phoneMicRecordingStarted() => track('Phone Mic Recording Started');

  void phoneMicRecordingStopped() => track('Phone Mic Recording Stopped');

  void recordingUploadStarted({
    required String attemptId,
    required int fileCount,
    required int totalBytes,
    required bool claimsLiveCapture,
    String? recordingId,
  }) =>
      track(
        'Recording Upload Started',
        properties: {
          'upload_attempt_id': attemptId,
          if (recordingId != null) 'recording_id': recordingId,
          'file_count': fileCount,
          'total_bytes': totalBytes,
          'claims_live_capture': claimsLiveCapture,
          'upload_source': 'offline_audio_queue',
        },
      );

  void recordingUploadCompleted({
    required String attemptId,
    required int fileCount,
    required int totalBytes,
    required bool claimsLiveCapture,
    required double durationSeconds,
    required String result,
    String? recordingId,
  }) =>
      track(
        'Recording Upload Completed',
        properties: {
          'upload_attempt_id': attemptId,
          if (recordingId != null) 'recording_id': recordingId,
          'file_count': fileCount,
          'total_bytes': totalBytes,
          'claims_live_capture': claimsLiveCapture,
          'upload_source': 'offline_audio_queue',
          'duration_seconds': durationSeconds,
          'result': result,
        },
      );

  void recordingUploadFailed({
    required String attemptId,
    required int fileCount,
    required int totalBytes,
    required bool claimsLiveCapture,
    required double durationSeconds,
    required String failureClass,
    String? recordingId,
  }) =>
      track(
        'Recording Upload Failed',
        properties: {
          'upload_attempt_id': attemptId,
          if (recordingId != null) 'recording_id': recordingId,
          'file_count': fileCount,
          'total_bytes': totalBytes,
          'claims_live_capture': claimsLiveCapture,
          'upload_source': 'offline_audio_queue',
          'duration_seconds': durationSeconds,
          'failure_class': failureClass,
        },
      );

  // Transcribe Later (batch / offline capture)
  void transcribeLaterToggled({required bool enabled}) =>
      track('Transcribe Later Toggled', properties: {'enabled': enabled});

  void transcribeLaterRecordingCaptured({int? durationSeconds}) =>
      track('Transcribe Later Recording Captured', properties: {'duration_seconds': durationSeconds});

  void transcribeLaterRecordingProcessed() => track('Transcribe Later Recording Processed');

  // Phone Calls (VoIP)
  void phoneCallPageOpened() => track('Phone Call Page Opened');

  void phoneCallVerificationStarted() => track('Phone Call Verification Started');

  void phoneCallVerificationCompleted() => track('Phone Call Verification Completed');

  void phoneCallStarted({String? contactName}) =>
      track('Phone Call Started', properties: {'has_contact_name': contactName != null});

  void phoneCallConnected() => track('Phone Call Connected');

  void phoneCallEnded({required int durationSeconds}) =>
      track('Phone Call Ended', properties: {'duration_seconds': durationSeconds});

  /// End-of-call (or stall) snapshot of the live-transcript session.
  /// Aggregate counts and closed status strings only — no raw audio samples,
  /// contact/phone numbers, transcripts, or ids are tracked.
  void phoneCallTranscriptSession({
    required bool wsAccepted,
    required int audioFramesSent,
    required int audioBytesSent,
    required int audioChannel1Frames,
    required int audioChannel2Frames,
    required int eventChannelErrors,
    required int eventChannelCoerced,
    required String transcriptionStatusFinal,
    required int durationSeconds,
    String? reason,
  }) =>
      track(
        'Phone Call Transcript Session',
        properties: {
          'ws_accepted': wsAccepted,
          'audio_frames_sent': audioFramesSent,
          'audio_bytes_sent': audioBytesSent,
          'audio_channel_1_frames': audioChannel1Frames,
          'audio_channel_2_frames': audioChannel2Frames,
          'event_channel_errors': eventChannelErrors,
          'event_channel_coerced': eventChannelCoerced,
          'transcription_status_final': transcriptionStatusFinal,
          'duration_seconds': durationSeconds,
          if (reason != null) 'reason': reason,
        },
      );

  void phoneCallFailed({String? error}) => track('Phone Call Failed', properties: {'error': error ?? 'unknown'});

  // Phone Calls Dialpad
  void phoneCallDialpadOpened() => track('Phone Call Dialpad Opened');

  void phoneCallDialpadDigitPressed(String digit) =>
      track('Phone Call Dialpad Digit Pressed', properties: {'digit': digit});

  // Phone Calls Upsell
  void phoneCallUpsellShown({required String source}) =>
      track('Phone Call Upsell Shown', properties: {'source': source});

  void phoneCallUpsellUpgradeTapped() => track('Phone Call Upsell Upgrade Tapped');

  void phoneCallUpsellDismissed() => track('Phone Call Upsell Dismissed');

  void appResultExpanded(ServerConversation conversation, String appId) {
    track('App Result Expanded', properties: getConversationEventProperties(conversation)..['app_id'] = appId);
  }

  void languageChanged(String language) {
    track('App Language Changed', properties: {'language': language});
    setUserProperty('App Primary Language', language);
  }

  void recordingLanguageChanged(String language) {
    track('Recording Language Changed', properties: {'language': language});
    setUserProperty('Recordings Language', language);
  }

  void calendarEnabled() {
    track('Calendar Enabled');
    setUserProperty('Calendar Enabled', true);
  }

  void calendarDisabled() {
    track('Calendar Disabled');
    setUserProperty('Calendar Enabled', false);
  }

  void calendarModePressed(String mode) => track('Calendar Mode $mode Pressed');

  void calendarSelected() => track('Calendar Selected');

  void bottomNavigationTabClicked(String tab) {
    setInteractionContext(screenName: tab, target: 'bottom_navigation');
    track('Bottom Navigation Tab Clicked', properties: {'tab': tab});
  }

  void deviceConnected(BtDevice device) {
    final vendor = device.type.analyticsVendor;
    final hardwareFamily = DeviceUtils.analyticsHardwareFamily(device);
    track(
      'Device Connected',
      properties: {
        ...device.toJson(),
        'type': device.type.name,
        'device_vendor': vendor,
        'hardware_family': hardwareFamily,
        ..._deviceIdentityProperties(device),
      },
    );
    setUserProperty('device_vendor', vendor);
    setUserProperty('hardware_family', hardwareFamily);
  }

  void devicePaired(String firstPairedAt) {
    final device = _preferences.btDevice;
    final hardwareFamily = DeviceUtils.analyticsHardwareFamily(device);
    track(
      'Device Paired',
      properties: {
        ...device.toJson(),
        'type': device.type.name,
        'device_vendor': device.type.analyticsVendor,
        'hardware_family': hardwareFamily,
        ..._deviceIdentityProperties(device),
      },
    );
    _setUserPropertiesBatch({
      'has_paired_device': true,
      'first_paired_at': firstPairedAt,
      'device_vendor': device.type.analyticsVendor,
      'hardware_family': hardwareFamily,
    });
  }

  void deviceDisconnected() => track('Device Disconnected');

  void deviceSessionEnded({required BtDevice device, required Duration duration, String? reason, int? hciReasonCode}) {
    final properties = <String, Object>{
      'duration_seconds': duration.inMilliseconds / Duration.millisecondsPerSecond,
      'reason': _knownDeviceValue(reason ?? ''),
      'device_vendor': device.type.analyticsVendor,
      'hardware_family': DeviceUtils.analyticsHardwareFamily(device),
      'model': _knownDeviceValue(device.modelNumber),
      'firmware_revision': _knownDeviceValue(device.firmwareRevision),
    };
    if (hciReasonCode != null && hciReasonCode >= 0) {
      properties['hci_reason_code'] = hciReasonCode;
    }
    track('Device Session Ended', properties: properties);
  }

  static String _knownDeviceValue(String value) => value.isEmpty || value == 'Unknown' ? 'unknown' : value;

  static Map<String, Object> _deviceIdentityProperties(BtDevice device) {
    final serial = device.serialNumber?.trim();
    String hash(String value) => sha256.convert(utf8.encode(value)).toString().substring(0, 16);
    final transportIdKind = switch (device.type) {
      DeviceType.appleWatch => 'watch_identifier',
      DeviceType.limitless => 'limitless_identifier',
      DeviceType.raybanMeta => 'rayban_identifier',
      _ => 'ble_identifier',
    };
    return {
      'transport_device_id': hash(device.id),
      'transport_id_kind': transportIdKind,
      'transport_id_stability': 'platform_dependent',
      if (serial != null && serial.isNotEmpty && serial != 'Unknown') ...{
        'hardware_id': hash(serial),
        'hardware_id_kind': 'manufacturer_serial',
        'hardware_id_stable': true,
      } else ...{
        'hardware_id_kind': 'unavailable',
        'hardware_id_stable': false,
      },
    };
  }

  void memoriesPageCategoryOpened(MemoryCategory category) =>
      track('Fact Page Category Opened', properties: {'category': category.toString().split('.').last});

  void memoriesPageDeletedMemory(Memory memory) =>
      track('Fact Page Deleted Fact', properties: {'fact_category': memory.category.toString().split('.').last});

  void memoriesPageEditedMemory() => track('Fact Page Edited Fact');

  void memoriesPageCreateMemoryBtn() => track('Fact Page Create Fact Button Pressed');

  void memoriesPageCreatedMemory(MemoryCategory category) =>
      track('Fact Page Created Fact', properties: {'fact_category': category.toString().split('.').last});

  void memorySearched(String query, int resultsCount) {
    track(
      'Fact Searched',
      properties: _searchProperties(query: query, resultsCount: resultsCount, surface: 'facts'),
    );
  }

  void memorySearchCleared(int totalFactsCount) {
    track('Fact Search Cleared', properties: {'total_facts_count': totalFactsCount});
  }

  void memoryListItemClicked(Memory memory) {
    track(
      'Fact List Item Clicked',
      properties: {'fact_id': memory.id, 'fact_category': memory.category.toString().split('.').last},
    );
  }

  void memoryVisibilityChanged(Memory memory, MemoryVisibility newVisibility) {
    track(
      'Fact Visibility Changed',
      properties: {
        'fact_id': memory.id,
        'fact_category': memory.category.toString().split('.').last,
        'new_visibility': newVisibility.name,
      },
    );
  }

  /// "Things I learned today" card became visible. Counts only — the card's
  /// content and memory ids never leave the device through analytics.
  void memoryReviewCardShown({required int itemCount, required String source}) {
    track('memory_review_card_shown', properties: {'item_count': itemCount, 'source': source});
  }

  /// One accept / reject / edit verdict on a learned memory.
  ///
  /// [action] is accept|reject|edit, [outcome] is ok|error, [source] is
  /// chat_block|daily_summary_detail. `memory_category` is the coarse category
  /// label; no memory content and no raw memory id are ever attached.
  void memoryReviewAction({
    required String source,
    required String action,
    required String outcome,
    required String memoryCategory,
  }) {
    track(
      'memory_review_action',
      properties: {'source': source, 'action': action, 'outcome': outcome, 'memory_category': memoryCategory},
    );
  }

  /// The one grounded follow-up chip under an answer was tapped.
  ///
  /// Mobile has no `question_asked` event to attribute to, so the origin is
  /// carried by this event instead of as a property on a send event.
  void followUpChipTapped({required String source}) {
    track('followup_chip_tapped', properties: {'source': source});
  }

  void memoriesAllVisibilityChanged(MemoryVisibility newVisibility, int count) {
    track('All Facts Visibility Changed', properties: {'new_visibility': newVisibility.name, 'facts_count': count});
  }

  void memoriesAllDeleted(int countBeforeDeletion) {
    track('All Facts Deleted', properties: {'facts_count_before_deletion': countBeforeDeletion});
  }

  void memoriesFiltered(String filter) => track('Facts Filtered', properties: {'filter': filter});

  void memoriesManagementSheetOpened() => track('Facts Management Sheet Opened');

  Map<String, dynamic> _getTranscriptProperties(String transcript) {
    String transcriptCopy = transcript.substring(0, transcript.length);
    int speakersCount = 0;
    for (int i = 0; i < 5; i++) {
      if (transcriptCopy.contains('Speaker $i:')) speakersCount++;
      transcriptCopy = transcriptCopy.replaceAll('Speaker $i:', '');
    }
    transcriptCopy = transcriptCopy.replaceAll('  ', ' ').trim();
    return {
      'transcript_length': transcriptCopy.length,
      'transcript_word_count': transcriptCopy.split(' ').length,
      'speaker_count': speakersCount,
    };
  }

  Map<String, dynamic> getConversationEventProperties(ServerConversation convo) {
    var properties = _getTranscriptProperties(convo.getTranscript());
    int hoursAgo = DateTime.now().difference(convo.createdAt).inHours;
    properties['memory_hours_since_creation'] = hoursAgo;
    properties['memory_id'] = convo.id;
    properties['memory_discarded'] = convo.discarded;
    return properties;
  }

  void conversationCreated(ServerConversation conversation, {BtDevice? recordingDevice}) {
    var properties = getConversationEventProperties(conversation);
    properties['memory_result'] = conversation.discarded ? 'discarded' : 'saved';
    properties['action_items_count'] = conversation.structured.actionItems.length;
    properties['transcript_language'] = _preferences.userPrimaryLanguage;

    // Additional properties for conversation creation
    properties['conversation_source'] = conversation.source?.toString().split('.').last ?? 'unknown';
    properties['duration_seconds'] = conversation.getDurationInSeconds();
    properties['timestamp'] = conversation.createdAt.toIso8601String();
    properties.addAll(recordingDeviceProperties(recordingDevice));

    // Get the summarized app info if available
    if (conversation.appResults.isNotEmpty) {
      var summarizedApp = conversation.appResults.firstOrNull;
      if (summarizedApp != null && summarizedApp.appId != null) {
        properties['summary_app_id'] = summarizedApp.appId!;
      }
    }

    track('Memory Created', properties: properties);
  }

  @visibleForTesting
  static Map<String, Object> recordingDeviceProperties(BtDevice? device) => {
        'recording_hardware_type': device?.type.name ?? 'phone',
        'recording_firmware_revision': device == null ? 'not_applicable' : _knownDeviceValue(device.firmwareRevision),
      };

  void conversationListItemClicked(ServerConversation conversation, int idx) =>
      track('Memory List Item Clicked', properties: getConversationEventProperties(conversation));

  void conversationShareButtonClick(ServerConversation conversation) =>
      track('Memory Share Button Clicked', properties: getConversationEventProperties(conversation));

  void conversationDeleted(ServerConversation conversation) =>
      track('Memory Deleted', properties: getConversationEventProperties(conversation));

  void chatMessageSent({
    required String message,
    required bool includesFiles,
    required int numberOfFiles,
    required String chatTargetId,
    required bool isPersonaChat,
    required bool isVoiceInput,
  }) =>
      track(
        'Chat Message Sent',
        properties: {
          'message_length': message.length,
          'message_word_count': message.split(' ').length,
          'includes_files': includesFiles,
          'number_of_files': numberOfFiles,
          'chat_target_id': chatTargetId,
          'is_persona_chat': isPersonaChat,
          'is_voice_input': isVoiceInput,
        },
      );

  void chatVoiceInputUsed({required String chatTargetId, required bool isPersonaChat}) {
    track('Chat Voice Input Used', properties: {'chat_target_id': chatTargetId, 'is_persona_chat': isPersonaChat});
  }

  void speechProfileCapturePageClicked() => track('Speech Profile Capture Page Clicked');

  void showDiscardedMemoriesToggled(bool showDiscarded) =>
      track('Show Discarded Memories Toggled', properties: {'show_discarded': showDiscarded});

  // Conversation Display Settings Events
  void conversationDisplaySettingsOpened() => track('Conversation Display Settings Opened');

  void showShortConversationsToggled(bool showShort) =>
      track('Show Short Conversations Toggled', properties: {'show_short': showShort});

  void showDiscardedConversationsToggled(bool showDiscarded) =>
      track('Show Discarded Conversations Toggled', properties: {'show_discarded': showDiscarded});

  void shortConversationThresholdChanged(int thresholdSeconds) => track(
        'Short Conversation Threshold Changed',
        properties: {'threshold_seconds': thresholdSeconds, 'threshold_minutes': thresholdSeconds ~/ 60},
      );

  void voiceResponseToggled(bool enabled) => track('Voice Response Audio Toggled', properties: {'enabled': enabled});

  void voiceResponseModeChanged(int mode) {
    const names = {0: 'off', 1: 'headphones_only', 2: 'always'};
    track('Voice Response Mode Changed', properties: {'mode': names[mode] ?? 'unknown', 'mode_int': mode});
  }

  // Conversation Merge Events
  void conversationMergeSelectionModeEntered() => track('Conversation Merge Selection Mode Entered');

  void conversationMergeSelectionModeExited() => track('Conversation Merge Selection Mode Exited');

  void conversationSelectedForMerge(String conversationId, int totalSelected) => track(
        'Conversation Selected For Merge',
        properties: {'conversation_id': conversationId, 'total_selected': totalSelected},
      );

  void conversationMergeInitiated(List<String> conversationIds) => track(
        'Conversation Merge Initiated',
        properties: {'conversation_count': conversationIds.length, 'conversation_ids': conversationIds},
      );

  void conversationMergeCompleted(String mergedConversationId, List<String> removedConversationIds) => track(
        'Conversation Merge Completed',
        properties: {
          'merged_conversation_id': mergedConversationId,
          'removed_count': removedConversationIds.length,
          'removed_conversation_ids': removedConversationIds,
        },
      );

  void conversationMergeFailed(List<String> conversationIds) => track(
        'Conversation Merge Failed',
        properties: {'conversation_count': conversationIds.length, 'conversation_ids': conversationIds},
      );

  // Important Conversation Share Events
  void importantConversationNotificationReceived(String conversationId) =>
      track('Important Conversation Notification Received', properties: {'conversation_id': conversationId});

  void shareToContactsSheetOpened(String conversationId) =>
      track('Share To Contacts Sheet Opened', properties: {'conversation_id': conversationId});

  void shareToContactsSelected(String conversationId, int contactCount) => track(
        'Share To Contacts Selected',
        properties: {'conversation_id': conversationId, 'contact_count': contactCount},
      );

  void shareToContactsSmsOpened(String conversationId, int contactCount) => track(
        'Share To Contacts SMS Opened',
        properties: {'conversation_id': conversationId, 'contact_count': contactCount},
      );

  void chatMessageConversationClicked(ServerConversation conversation) =>
      track('Chat Message Memory Clicked', properties: getConversationEventProperties(conversation));

  void addManualConversationClicked() => track('Add Manual Memory Clicked');

  void manualConversationCreated(ServerConversation conversation) =>
      track('Manual Memory Created', properties: getConversationEventProperties(conversation));

  void setUserProperties(String whatDoYouDo, String whereDoYouPlanToUseYourFriend, String ageRange) {
    _setUserPropertiesBatch({
      'What the user does': whatDoYouDo,
      'Using Omi At': whereDoYouPlanToUseYourFriend,
      'Age Range': ageRange,
    });
  }

  void reProcessConversation(ServerConversation conversation) =>
      track('Re-process Memory', properties: getConversationEventProperties(conversation));

  void developerModeEnabled() {
    track('Developer Mode Enabled');
    setUserProperty('Dev Mode Enabled', true);
  }

  void developerModeDisabled() {
    track('Developer Mode Disabled');
    setUserProperty('Dev Mode Enabled', false);
  }

  void userIDCopied() => track('User ID Copied');

  void exportMemories() => track('Dev Mode Export Memories');

  void importMemories() => track('Dev Mode Import Memories');

  void importedMemories() => track('Dev Mode Imported Memories');

  void supportContacted() => track('Support Contacted');

  void copiedConversationDetails(ServerConversation conversation, {String source = ''}) =>
      track('Copied Memory Detail $source'.trim(), properties: getConversationEventProperties(conversation));

  void checkedActionItem(ServerConversation conversation, int idx) =>
      track('Checked Action Item', properties: getConversationEventProperties(conversation));

  void uncheckedActionItem(ServerConversation conversation, int idx) =>
      track('Unchecked Action Item', properties: getConversationEventProperties(conversation));

  void deletedActionItem(ServerConversation conversation) =>
      track('Deleted Action Item', properties: getConversationEventProperties(conversation));

  void paywallOpened(String source) => track('Paywall Opened', properties: {'source': source});

  void upgradePlanSelected({required String plan, required String source}) =>
      track('Upgrade Plan Selected', properties: {'plan': plan, 'source': source});

  void upgradeSucceeded({required String previousPlan, required String newPlan, required String billingInterval}) {
    track(
      'Subscription Plan Changed',
      properties: {
        'previous_plan': previousPlan,
        'new_plan': newPlan,
        'billing_interval': billingInterval,
        'change_source': 'mobile_checkout',
      },
    );
    track('Upgrade Succeeded');
  }

  void upgradeCancelled() => track('Upgrade Cancelled');

  void upgradeModalDismissed() => track('Upgrade Modal Dismissed');

  void upgradeModalClicked() => track('Upgrade Modal Clicked');

  void subscriptionCancelFlowStarted() => track('Subscription Cancel Flow Started');

  void subscriptionCancelReasonSelected({required String reason}) =>
      track('Subscription Cancel Reason Selected', properties: {'reason': reason});

  void subscriptionCancelConfirmed({required String reason, String? details}) =>
      track('Subscription Cancel Confirmed', properties: {'reason': reason, 'reason_details': details});

  void subscriptionCancelKeptPlan({required int step, String? reason}) =>
      track('Subscription Cancel Kept Plan', properties: {'step': step, 'reason': reason});

  void subscriptionCancelAbandoned({required int step, String? reason}) =>
      track('Subscription Cancel Abandoned', properties: {'step': step, 'reason': reason});

  void connectFriendClicked() => track('Connect Friend Clicked');

  void disconnectFriendClicked() => track('Disconnect Friend Clicked');

  void batteryIndicatorClicked() => track('Battery Indicator Clicked');

  void useWithoutDeviceOnboardingWelcome() => track('Use Without Device Onboarding Welcome');

  void useWithoutDeviceOnboardingFindDevices() => track('Use Without Device Onboarding Find Devices');

  // void pageViewed(String pageName) => startTimingEvent('Page View $pageName');

  void addedPerson() => track('Added Person');

  void removedPerson() => track('Removed Person');

  void tagSheetOpened() => track('Tag Sheet Opened');

  void taggedSegment(String assignType) => track('Tagged Segment $assignType');

  void untaggedSegment() => track('Untagged Segment');

  void editSegmentTextStarted() => track('Edit Segment Text Started');

  void editSegmentTextSaved() => track('Edit Segment Text Saved');

  void editSegmentTextCancelled() => track('Edit Segment Text Cancelled');

  void editSummaryStarted() => track('Edit Summary Started');

  void editSummarySaved() => track('Edit Summary Saved');

  void editSummaryCancelled() => track('Edit Summary Cancelled');

  void deleteAccountClicked() => track('Delete Account Clicked');

  void deleteAccountConfirmed() => track('Delete Account Confirmed');

  void deleteAccountCancelled() => track('Delete Account Cancelled');

  void deleteAccountFlowStarted() => track('Delete Account Flow Started');

  void deleteAccountReasonSelected({required String reason}) =>
      track('Delete Account Reason Selected', properties: {'reason': reason});

  void deleteAccountFeedbackSubmitted({required String reason, String? details}) =>
      track('Delete Account Feedback Submitted', properties: {'reason': reason, 'reason_details': details});

  void deleteAccountAbandoned({required int step, String? reason}) =>
      track('Delete Account Abandoned', properties: {'step': step, 'reason': reason});

  void deleteAccountKeptAccount({required int step, String? reason}) =>
      track('Delete Account Kept Account', properties: {'step': step, 'reason': reason});

  void deleteUser() => PlatformService.executeIfSupported(PlatformService.isAnalyticsSupported, () {
        final adapter = _adapter;
        if (adapter == null) return;
        adapter.track(eventName: 'User Deleted');
        adapter.reset();
      });

  // Apps Filter
  void appsFilterOpened() => track('Apps Filter Opened');
  void appsFilterApplied() => track('Apps Filter Applied');
  void appsCategoryFilter(String category, bool isSelected) {
    track('Apps Category Filter', properties: {'category': category, 'selected': isSelected});
  }

  void appsTypeFilter(String type, bool isSelected) {
    track('Apps Type Filter', properties: {'type': type, 'selected': isSelected});
  }

  void appsSortFilter(String sortBy, bool isSelected) {
    track('Apps Sort Filter', properties: {'sort_by': sortBy, 'selected': isSelected});
  }

  void appsRatingFilter(String rating, bool isSelected) {
    track('Apps Rating Filter', properties: {'rating': rating, 'selected': isSelected});
  }

  void appsCapabilityFilter(String capability, bool isSelected) {
    track('Apps Capability Filter', properties: {'capability': capability, 'selected': isSelected});
  }

  void appsClearFilters() => track('Apps Clear Filters');

  // Brain Map Events
  void brainMapOpened() => track('Brain Map Opened');

  void brainMapNodeClicked(String nodeId, String label, String type) {
    track('Brain Map Node Clicked', properties: {'node_id': nodeId, 'label': label, 'type': type});
  }

  void brainMapShareClicked() => track('Brain Map Share Clicked');

  // Summarized Apps Sheet Events
  void summarizedAppSheetViewed({required String conversationId, String? currentSummarizedAppId}) {
    track(
      'Summarized App Sheet Viewed',
      properties: {'conversation_id': conversationId, 'current_summarized_app_id': currentSummarizedAppId ?? 'auto'},
    );
  }

  void summarizedAppSelected({required String conversationId, required String selectedAppId, String? previousAppId}) {
    track(
      'Summarized App Selected',
      properties: {
        'conversation_id': conversationId,
        'selected_app_id': selectedAppId,
        'previous_app_id': previousAppId ?? 'auto',
      },
    );
  }

  void summarizedAppEnableAppsClicked({required String conversationId}) {
    track('Summarized App Enable Apps Clicked', properties: {'conversation_id': conversationId});
  }

  void summarizedAppCreateTemplateClicked({required String conversationId}) {
    track('Summarized App Create Template Clicked', properties: {'conversation_id': conversationId});
  }

  void quickTemplateCreated({required String conversationId, required String appName, required bool isPublic}) {
    track(
      'Quick Template Created',
      properties: {'conversation_id': conversationId, 'app_name': appName, 'is_public': isPublic},
    );
  }

  // Action Items Page Events
  void actionItemsPageOpened() => track('Action Items Page Opened');

  void actionItemsViewToggled(bool isGroupedView) {
    track('Action Items View Toggled', properties: {'grouped_view': isGroupedView});
  }

  void actionItemToggledCompletionOnActionItemsPage({
    required String conversationId,
    required String actionItemDescription, // Using description as a pseudo-ID if no stable ID exists
    required bool isCompleted,
  }) {
    track(
      'Action Item Completion Toggled on Action Items Page',
      properties: {
        'conversation_id': conversationId,
        'action_item_description': actionItemDescription,
        'is_completed': isCompleted,
      },
    );
  }

  void actionItemTappedForEditOnActionItemsPage({
    required String conversationId,
    required String actionItemDescription,
  }) {
    track(
      'Action Item Tapped for Edit on Action Items Page',
      properties: {'conversation_id': conversationId, 'action_item_description': actionItemDescription},
    );
  }

  void actionItemsDateFilterApplied(String filterType) {
    track('Action Items Date Filter Applied', properties: {'filter_type': filterType});
  }

  void actionItemsDateFilterCleared() {
    track('Action Items Date Filter Cleared');
  }

  void actionItemTabChanged(String tabName) {
    track('Action Item Tab Changed', properties: {'tab_name': tabName});
  }

  void actionItemCompleted({required String fromTab}) {
    track('Action Item Completed', properties: {'from_tab': fromTab});
  }

  void trainingDataOptInSubmitted() {
    track('Training Data Opt-In Submitted');
    setUserProperty('Training Data Opted In', true);
  }

  void trainingDataOptInApproved() {
    track('Training Data Opt-In Approved');
    setUserProperty('Training Data Status', 'approved');
  }

  // Homepage Events
  void recordingMuteToggled({required bool isMuted, required String recordingType}) {
    track('Recording Mute Toggled', properties: {'is_muted': isMuted, 'recording_type': recordingType});
  }

  void deletedConversationsFilterToggled(bool showDeleted) {
    track('Deleted Conversations Filter Toggled', properties: {'show_deleted': showDeleted});
  }

  void calendarFilterApplied(DateTime startDate, DateTime endDate) {
    track(
      'Calendar Filter Applied',
      properties: {
        'start_date': startDate.toIso8601String(),
        'end_date': endDate.toIso8601String(),
        'range_days': endDate.difference(startDate).inDays,
        'days_ago': DateTime.now().difference(startDate).inDays,
      },
    );
  }

  void calendarFilterCleared() {
    track('Calendar Filter Cleared');
  }

  void searchBarFocused() {
    track('Search Bar Focused');
  }

  void searchQueryEntered(String query, int resultsCount) {
    track(
      'Search Query Entered',
      properties: _searchProperties(query: query, resultsCount: resultsCount, surface: 'conversations'),
    );
  }

  void searchQueryCleared() {
    track('Search Query Cleared');
  }

  void conversationOpenedFromSearch({
    required ServerConversation conversation,
    required String searchQuery,
    required int conversationIndexInResults,
  }) {
    var properties = getConversationEventProperties(conversation);
    properties.addAll(_searchProperties(query: searchQuery, surface: 'conversations'));
    properties['conversation_index_in_results'] = conversationIndexInResults;
    track('Conversation Opened From Search', properties: properties);
  }

  void liveTranscriptCardClicked({
    required bool hasSegments,
    required bool hasPhotos,
    required int segmentCount,
    required int photoCount,
  }) {
    track(
      'Live Transcript Card Clicked',
      properties: {
        'has_segments': hasSegments,
        'has_photos': hasPhotos,
        'segment_count': segmentCount,
        'photo_count': photoCount,
      },
    );
  }

  void conversationListItemClickedWithTimeDifference({
    required ServerConversation conversation,
    required int conversationIndex,
    required int hoursSinceConversation,
  }) {
    var properties = getConversationEventProperties(conversation);
    properties['conversation_index'] = conversationIndex;
    properties['hours_since_conversation'] = hoursSinceConversation;
    track('Conversation List Item Clicked', properties: properties);
  }

  void conversationSwipedToDelete(ServerConversation conversation) {
    var properties = getConversationEventProperties(conversation);
    track('Conversation Swiped To Delete', properties: properties);
  }

  // Conversation Detail Page Events
  void conversationDetailTabChanged(String tabName) {
    track('Conversation Detail Tab Changed', properties: {'tab_name': tabName});
  }

  void speakerEdited({required String conversationId, required int oldSpeakerCount, required int newSpeakerCount}) {
    track(
      'Speaker Edited',
      properties: {
        'conversation_id': conversationId,
        'old_speaker_count': oldSpeakerCount,
        'new_speaker_count': newSpeakerCount,
        'speaker_count_changed': oldSpeakerCount != newSpeakerCount,
      },
    );
  }

  void conversationDetailSearchClicked({required String conversationId}) {
    track('Conversation Detail Search Clicked', properties: {'conversation_id': conversationId});
  }

  void conversationDetailSearchQueryEntered({
    required String conversationId,
    required String query,
    required int resultsCount,
    required String activeTab,
  }) {
    final properties = _searchProperties(query: query, resultsCount: resultsCount, surface: 'conversation_detail');
    properties.addAll({'conversation_id': conversationId, 'active_tab': activeTab});
    track('Conversation Detail Search Query Entered', properties: properties);
  }

  void conversationReprocessedWithApp({
    required String conversationId,
    required String appId,
    required String appName,
    required bool isOwnApp,
    required bool wasAutoSelected,
  }) {
    track(
      'Conversation Reprocessed',
      properties: {
        'conversation_id': conversationId,
        'app_id': appId,
        'app_name': appName,
        'is_own_app': isOwnApp,
        'was_auto_selected': wasAutoSelected,
      },
    );
  }

  void conversationShared({required ServerConversation conversation, required String shareMethod}) {
    var properties = getConversationEventProperties(conversation);
    properties['share_method'] = shareMethod;
    track('Conversation Shared', properties: properties);
  }

  void conversationThreeDotsMenuOpened({required String conversationId}) {
    track('Conversation Three Dots Menu Opened', properties: {'conversation_id': conversationId});
  }

  void conversationThreeDotsMenuActionSelected({required String conversationId, required String action}) {
    track(
      'Conversation Three Dots Menu Action Selected',
      properties: {'conversation_id': conversationId, 'action': action},
    );
  }

  // ============================================================================
  // ACTION ITEMS TRACKING
  // ============================================================================

  void actionItemChecked({required String actionItemId, required bool completed, required DateTime timestamp}) {
    track(
      'Action Item Checked',
      properties: {'action_item_id': actionItemId, 'completed': completed, 'timestamp': timestamp.toIso8601String()},
    );
  }

  void exportTasksBannerClicked() {
    track('Export Tasks Banner Clicked');
  }

  void taskIntegrationEnabled({required String appName, required bool success}) {
    track('Task Integration Enabled', properties: {'app_name': appName, 'success': success});
  }

  void taskIntegrationAuthFailed({required String appName}) {
    track('Task Integration Auth Failed', properties: {'app_name': appName});
  }

  void taskIntegrationSettingsOpened({required String appName}) {
    track('Task Integration Settings Opened', properties: {'app_name': appName});
  }

  // ============================================================================
  // TRANSCRIPTION / CUSTOM STT TRACKING
  // ============================================================================

  void transcriptionSourceSelected({
    required String source, // 'omi' or 'custom'
  }) {
    track('Transcription Source Selected', properties: {'source': source});
  }

  void transcriptionProviderSelected({
    required String provider, // e.g. 'openai', 'deepgram', 'gemini', 'local_whisper', 'custom', 'custom_live'
  }) {
    track('Transcription Provider Selected', properties: {'provider': provider});
  }

  // ============================================================================
  // AUDIO PLAYBACK TRACKING
  // ============================================================================

  void audioPlaybackFailed({required String conversationId, required String reason}) {
    track('Audio Playback Failed', properties: {'conversation_id': conversationId, 'reason': reason});
  }

  void audioPlaybackStarted({required String conversationId, int? durationSeconds}) {
    track(
      'Audio Playback Started',
      properties: {'conversation_id': conversationId, if (durationSeconds != null) 'duration_seconds': durationSeconds},
    );
  }

  void audioPlaybackPaused({required String conversationId, required int positionSeconds, int? durationSeconds}) {
    track(
      'Audio Playback Paused',
      properties: {
        'conversation_id': conversationId,
        'position_seconds': positionSeconds,
        if (durationSeconds != null) 'duration_seconds': durationSeconds,
        if (durationSeconds != null && durationSeconds > 0)
          'completion_percentage': ((positionSeconds / durationSeconds) * 100).round(),
      },
    );
  }

  void audioPlaybackSeeked({required String conversationId, required int toPositionSeconds}) {
    track(
      'Audio Playback Seeked',
      properties: {'conversation_id': conversationId, 'to_position_seconds': toPositionSeconds},
    );
  }

  void transcriptSegmentTapped({
    required String conversationId,
    required double segmentStartSeconds,
    required double seekPositionSeconds,
  }) {
    track(
      'Transcript Segment Tapped',
      properties: {
        'conversation_id': conversationId,
        'segment_start_seconds': segmentStartSeconds,
        'seek_position_seconds': seekPositionSeconds,
      },
    );
  }

  void audioShareStarted({required String conversationId, required int audioFileCount}) {
    track('Audio Share Started', properties: {'conversation_id': conversationId, 'audio_file_count': audioFileCount});
  }

  void audioShareCompleted({
    required String conversationId,
    required int audioFileCount,
    required bool wasCombined,
    required int durationSeconds,
  }) {
    track(
      'Audio Share Completed',
      properties: {
        'conversation_id': conversationId,
        'audio_file_count': audioFileCount,
        'was_combined': wasCombined,
        'duration_seconds': durationSeconds,
      },
    );
  }

  void audioShareFailed({required String conversationId, String? errorMessage}) {
    track(
      'Audio Share Failed',
      properties: {'conversation_id': conversationId, if (errorMessage != null) 'error_message': errorMessage},
    );
  }

  void audioShareCancelled({required String conversationId}) {
    track('Audio Share Cancelled', properties: {'conversation_id': conversationId});
  }

  void actionItemExported({required String actionItemId, required String appName, required DateTime timestamp}) {
    track(
      'Action Item Exported',
      properties: {'action_item_id': actionItemId, 'app_name': appName, 'timestamp': timestamp.toIso8601String()},
    );
  }

  void actionItemManuallyAdded({required String actionItemId, required DateTime timestamp}) {
    track(
      'Action Item Manually Added',
      properties: {'action_item_id': actionItemId, 'timestamp': timestamp.toIso8601String()},
    );
  }

  void actionItemEdited({required String actionItemId, required bool titleChanged, required bool dateChanged}) {
    track(
      'Action Item Edited',
      properties: {'action_item_id': actionItemId, 'title_changed': titleChanged, 'date_changed': dateChanged},
    );
  }

  void appleRemindersSyncCompleted({
    required int pendingExported,
    required int syncedChecked,
    required int completionsPulled,
    required int completionsPushed,
    required int titleDuePulled,
    required int titleDuePushed,
    required int remindersUnlinked,
  }) {
    track(
      'Apple Reminders Sync Completed',
      properties: {
        'pending_exported': pendingExported,
        'synced_checked': syncedChecked,
        'completions_pulled': completionsPulled,
        'completions_pushed': completionsPushed,
        'title_due_pulled': titleDuePulled,
        'title_due_pushed': titleDuePushed,
        'reminders_unlinked': remindersUnlinked,
      },
    );
  }

  void appleReminderDirectSync({required String actionItemId}) {
    track('Apple Reminder Direct Sync', properties: {'action_item_id': actionItemId});
  }

  void appleReminderDeleted({required String actionItemId}) {
    track('Apple Reminder Deleted', properties: {'action_item_id': actionItemId});
  }

  // ============================================================================
  // SETTINGS PAGE TRACKING
  // ============================================================================

  void settingsPageOpened({required String pageName}) {
    track('Settings Page Opened', properties: {'page_name': pageName});
  }

  void usageTabChanged({required String tabName}) {
    track('Usage Tab Changed', properties: {'tab_name': tabName});
  }

  // ============================================================================
  // APPS PAGE TRACKING
  // ============================================================================

  void appsSearched({required String searchTerm, required int resultCount}) {
    track(
      'Apps Searched',
      properties: _searchProperties(query: searchTerm, resultsCount: resultCount, surface: 'apps'),
    );
  }

  void appsFilterMyApps({required bool enabled}) {
    track('Apps Filter My Apps', properties: {'enabled': enabled});
  }

  void appsFilterInstalled({required bool enabled}) {
    track('Apps Filter Installed', properties: {'enabled': enabled});
  }

  void appsFilterRating({required int rating}) {
    track('Apps Filter Rating', properties: {'rating': rating});
  }

  void appsFilterCategory({required String category}) {
    track('Apps Filter Category', properties: {'category': category});
  }

  void appsSortChanged({required String sortOption}) {
    track('Apps Sort Changed', properties: {'sort_option': sortOption});
  }

  void appsFilterCapability({required String capability}) {
    track('Apps Filter Capability', properties: {'capability': capability});
  }

  void appsCategoryPageOpened({required String category, required int appCount}) {
    track('Apps Category Page Opened', properties: {'category': category, 'app_count': appCount});
  }

  // ============================================================================
  // APP DETAIL PAGE TRACKING
  // ============================================================================

  void appDetailViewed({
    required String appId,
    required String appName,
    String? category,
    double? rating,
    int? installs,
    bool? isInstalled,
  }) {
    track(
      'App Detail Viewed',
      properties: {
        'app_id': appId,
        'app_name': appName,
        if (category != null) 'category': category,
        if (rating != null) 'rating': rating,
        if (installs != null) 'installs': installs,
        if (isInstalled != null) 'is_installed': isInstalled,
      },
    );
  }

  void appDetailSectionViewed({required String appId, required String sectionName}) {
    track('App Detail Section Viewed', properties: {'app_id': appId, 'section_name': sectionName});
  }

  void appDetailShared({required String appId, required String appName}) {
    track('App Detail Shared', properties: {'app_id': appId, 'app_name': appName});
  }

  void appDetailReviewsOpened({required String appId, required int reviewCount}) {
    track('App Detail Reviews Opened', properties: {'app_id': appId, 'review_count': reviewCount});
  }

  void appDetailReviewAdded({required String appId, required int rating, required bool hasComment}) {
    track('App Detail Review Added', properties: {'app_id': appId, 'rating': rating, 'has_comment': hasComment});
  }

  void appDetailSettingsOpened({required String appId}) {
    track('App Detail Settings Opened', properties: {'app_id': appId});
  }

  void appDetailSubscribeClicked({required String appId, required String appName, double? price}) {
    track(
      'App Detail Subscribe Clicked',
      properties: {'app_id': appId, 'app_name': appName, if (price != null) 'price': price},
    );
  }

  void appDetailSubscriptionCancelled({required String appId, required String appName}) {
    track('App Detail Subscription Cancelled', properties: {'app_id': appId, 'app_name': appName});
  }

  void appDetailPreviewImageViewed({required String appId, required int imageIndex}) {
    track('App Detail Preview Image Viewed', properties: {'app_id': appId, 'image_index': imageIndex});
  }

  void appDetailChatClicked({required String appId, required String appName}) {
    track('App Detail Chat Clicked', properties: {'app_id': appId, 'app_name': appName});
  }

  // ============================================================================
  // FOLDER TRACKING
  // ============================================================================

  void folderCreated({
    required String folderId,
    required String folderName,
    required String icon,
    required String color,
  }) {
    track(
      'Folder Created',
      properties: {'folder_id': folderId, 'folder_name': folderName, 'icon': icon, 'color': color},
    );
  }

  void folderUpdated({required String folderId, required String folderName}) {
    track('Folder Updated', properties: {'folder_id': folderId, 'folder_name': folderName});
  }

  void folderDeleted({
    required String folderId,
    required String folderName,
    required int conversationCount,
    String? moveToFolderId,
  }) {
    track(
      'Folder Deleted',
      properties: {
        'folder_id': folderId,
        'folder_name': folderName,
        'conversation_count': conversationCount,
        if (moveToFolderId != null) 'move_to_folder_id': moveToFolderId,
        'moved_conversations': moveToFolderId != null,
      },
    );
  }

  void folderSelected({String? folderId, String? folderName}) {
    track(
      'Folder Selected',
      properties: {
        if (folderId != null) 'folder_id': folderId,
        if (folderName != null) 'folder_name': folderName,
        'is_all_tab': folderId == null,
      },
    );
  }

  void folderContextMenuOpened({required String folderId, required String folderName}) {
    track('Folder Context Menu Opened', properties: {'folder_id': folderId, 'folder_name': folderName});
  }

  void createFolderButtonClicked() {
    track('Create Folder Button Clicked');
  }

  void conversationDetailFolderChipClicked({required String conversationId, String? currentFolderId}) {
    track(
      'Conversation Detail Folder Chip Clicked',
      properties: {
        'conversation_id': conversationId,
        if (currentFolderId != null) 'current_folder_id': currentFolderId,
        'has_folder': currentFolderId != null,
      },
    );
  }

  void conversationMovedToFolder({
    required String conversationId,
    String? fromFolderId,
    String? toFolderId,
    required String source,
  }) {
    track(
      'Conversation Moved To Folder',
      properties: {
        'conversation_id': conversationId,
        if (fromFolderId != null) 'from_folder_id': fromFolderId,
        if (toFolderId != null) 'to_folder_id': toFolderId,
        'source': source,
        'was_in_folder': fromFolderId != null,
      },
    );
  }

  void conversationVisibilityChanged({
    required String conversationId,
    required String fromVisibility,
    required String toVisibility,
  }) {
    track(
      'Conversation Visibility Changed',
      properties: {'conversation_id': conversationId, 'from_visibility': fromVisibility, 'to_visibility': toVisibility},
    );
  }

  void starredFilterToggled({required bool enabled, String? selectedFolderId}) {
    track(
      'Starred Filter Toggled',
      properties: {
        'enabled': enabled,
        if (selectedFolderId != null) 'selected_folder_id': selectedFolderId,
        'has_folder_filter': selectedFolderId != null,
      },
    );
  }

  void conversationStarToggled({
    required ServerConversation conversation,
    required bool starred,
    required String source,
  }) {
    var properties = getConversationEventProperties(conversation);
    properties['starred'] = starred;
    properties['source'] = source;
    properties['duration_seconds'] = conversation.getDurationInSeconds();

    // Get the summarized app id if available
    if (conversation.appResults.isNotEmpty) {
      var summarizedApp = conversation.appResults.firstOrNull;
      if (summarizedApp != null && summarizedApp.appId != null) {
        properties['summary_app_id'] = summarizedApp.appId!;
      }
    }

    track('Conversation Star Toggled', properties: properties);
  }

  void omiDoubleTap({required String feature, Map<String, dynamic>? additionalProperties}) {
    track(
      'Omi Double Tap',
      properties: {'feature': feature, if (additionalProperties != null) ...additionalProperties},
    );
  }

  // ============================================================================
  // WRAPPED 2025 TRACKING
  // ============================================================================

  void wrappedPageOpened() {
    track('Wrapped Page Opened');
  }

  void wrappedBannerClicked() {
    track('Wrapped Banner Clicked');
  }

  void wrappedGenerationStarted() {
    track('Wrapped Generation Started');
    startTimingEvent('Wrapped Generation Completed');
  }

  void wrappedGenerationCompleted({
    required int totalConversations,
    required int totalMinutes,
    required int daysActive,
  }) {
    track(
      'Wrapped Generation Completed',
      properties: {'total_conversations': totalConversations, 'total_minutes': totalMinutes, 'days_active': daysActive},
    );
  }

  void wrappedGenerationFailed({String? error}) {
    track('Wrapped Generation Failed', properties: {if (error != null) 'error': error});
  }

  void wrappedCardViewed({required String cardName, required int cardIndex}) {
    track('Wrapped Card Viewed', properties: {'card_name': cardName, 'card_index': cardIndex});
  }

  void wrappedShareButtonClicked({required String cardName, required int cardIndex}) {
    track('Wrapped Share Button Clicked', properties: {'card_name': cardName, 'card_index': cardIndex});
    startTimingEvent('Wrapped Shared Successfully');
  }

  void wrappedSharedSuccessfully({required String cardName, required int cardIndex, int? fileSizeBytes}) {
    track(
      'Wrapped Shared Successfully',
      properties: {
        'card_name': cardName,
        'card_index': cardIndex,
        if (fileSizeBytes != null) 'file_size_bytes': fileSizeBytes,
        if (fileSizeBytes != null) 'file_size_kb': (fileSizeBytes / 1024).round(),
        if (fileSizeBytes != null) 'file_size_mb': (fileSizeBytes / (1024 * 1024)).toStringAsFixed(2),
      },
    );
  }

  void wrappedShareFailed({required String cardName, required int cardIndex, String? error}) {
    track(
      'Wrapped Share Failed',
      properties: {'card_name': cardName, 'card_index': cardIndex, if (error != null) 'error': error},
    );
  }

  // ============================================================================
  // DAILY SUMMARY / RECAP TRACKING
  // ============================================================================

  void dailySummarySettingsOpened() => track('Daily Summary Settings Opened');

  // ============================================================================
  // Permissions
  // ============================================================================

  void permissionsSettingsOpened() => track('Permissions Settings Opened');

  void permissionChanged({required String permission, required bool granted}) {
    track('Permission Changed', properties: {'permission': permission, 'granted': granted});
  }

  void permissionsInterstitialShown() => track('Permissions Interstitial Shown');

  void permissionsInterstitialCompleted() => track('Permissions Interstitial Completed');

  void permissionsInterstitialSkipped() => track('Permissions Interstitial Skipped');

  void dailySummaryToggled({required bool enabled}) {
    track('Daily Summary Toggled', properties: {'enabled': enabled});
    setUserProperty('Daily Summary Enabled', enabled);
  }

  void dailySummaryTimeChanged({required int hour}) {
    final hour12 = hour == 0 ? 12 : (hour > 12 ? hour - 12 : hour);
    final period = hour >= 12 ? 'PM' : 'AM';
    track(
      'Daily Summary Time Changed',
      properties: {'hour_24': hour, 'hour_12': hour12, 'period': period, 'display_time': '$hour12:00 $period'},
    );
    setUserProperty('Daily Summary Hour', hour);
  }

  void dailySummaryDetailViewed({required String summaryId, required String date, String? source}) {
    track(
      'Daily Summary Detail Viewed',
      properties: {'summary_id': summaryId, 'date': date, if (source != null) 'source': source},
    );
  }

  void dailySummaryTestGenerated({required String date}) {
    track('Daily Summary Test Generated', properties: {'date': date});
  }

  void dailySummaryTestGenerationFailed({required String date, String? error}) {
    track('Daily Summary Test Generation Failed', properties: {'date': date, if (error != null) 'error': error});
  }

  void recapTabOpened() => track('Recap Tab Opened');

  void recapSummaryCardClicked({required String summaryId, required String date, required int cardIndex}) {
    track('Recap Summary Card Clicked', properties: {'summary_id': summaryId, 'date': date, 'card_index': cardIndex});
  }

  void dailySummaryNotificationReceived({required String summaryId, required String date}) {
    track('Daily Summary Notification Received', properties: {'summary_id': summaryId, 'date': date});
  }

  void dailySummaryNotificationOpened({required String summaryId, required String date}) {
    track('Daily Summary Notification Opened', properties: {'summary_id': summaryId, 'date': date});
  }

  void dailySummaryShared({required String summaryId, required String date}) {
    track('Daily Summary Shared', properties: {'summary_id': summaryId, 'date': date});
  }

  void dailySummaryConversationClicked({
    required String summaryId,
    required String conversationId,
    required String source,
  }) {
    track(
      'Daily Summary Conversation Clicked',
      properties: {'summary_id': summaryId, 'conversation_id': conversationId, 'source': source},
    );
  }

  void dailySummarySectionViewed({required String summaryId, required String sectionName}) {
    track('Daily Summary Section Viewed', properties: {'summary_id': summaryId, 'section_name': sectionName});
  }

  /// Recap deletion. ``source`` distinguishes the entry point so we can tell if
  /// users prefer the swipe gesture on the list vs the menu on the detail page.
  void dailySummaryDeleted({required String summaryId, required String date, required String source}) {
    track('Daily Summary Deleted', properties: {'summary_id': summaryId, 'date': date, 'source': source});
  }

  void dailySummaryDeleteFailed({required String summaryId, required String date, required String source}) {
    track('Daily Summary Delete Failed', properties: {'summary_id': summaryId, 'date': date, 'source': source});
  }

  // ============================================================================
  // ANNOUNCEMENT TRACKING
  // ============================================================================

  void announcementShown({required String announcementId, required String type, String? trigger, int? priority}) {
    track(
      'Announcement Shown',
      properties: {
        'announcement_id': announcementId,
        'type': type,
        if (trigger != null) 'trigger': trigger,
        if (priority != null) 'priority': priority,
      },
    );
  }

  void announcementDismissed({required String announcementId, required String type, required bool ctaClicked}) {
    track(
      'Announcement Dismissed',
      properties: {'announcement_id': announcementId, 'type': type, 'cta_clicked': ctaClicked},
    );
  }

  void changelogShown({required int changelogCount, required String fromVersion, required String toVersion}) {
    track(
      'Changelog Shown',
      properties: {'changelog_count': changelogCount, 'from_version': fromVersion, 'to_version': toVersion},
    );
  }

  void changelogDismissed({required int changelogCount}) {
    track('Changelog Dismissed', properties: {'changelog_count': changelogCount});
  }

  void whatsNewOpened() => track('Whats New Opened');

  // ============================================================================
  // GOALS TRACKING
  // ============================================================================

  void goalAddButtonTapped({required String source}) {
    track('Goal Add Button Tapped', properties: {'source': source});
  }

  void goalCreated({
    required String goalId,
    required int titleLength,
    required double targetValue,
    required String source,
  }) {
    track(
      'Goal Created',
      properties: {'goal_id': goalId, 'title_length': titleLength, 'target_value': targetValue, 'source': source},
    );
  }

  void goalUpdated({required String goalId, required String source}) {
    track('Goal Updated', properties: {'goal_id': goalId, 'source': source});
  }

  void goalDeleted({required String goalId, required String source, required String method}) {
    track('Goal Deleted', properties: {'goal_id': goalId, 'source': source, 'method': method});
  }

  void goalItemTappedForEdit({required String goalId, required String source}) {
    track('Goal Item Tapped For Edit', properties: {'goal_id': goalId, 'source': source});
  }

  void goalEmojiSelected({required String emoji}) {
    track('Goal Emoji Selected', properties: {'emoji': emoji});
  }

  void goalProgressChanged({
    required String goalId,
    required double oldValue,
    required double newValue,
    required double targetValue,
  }) {
    track(
      'Goal Progress Changed',
      properties: {
        'goal_id': goalId,
        'old_value': oldValue,
        'new_value': newValue,
        'target_value': targetValue,
        'progress_percentage': targetValue > 0 ? (newValue / targetValue * 100).round() : 0,
      },
    );
  }

  void taskDraggedToGoal({required String taskId, required String goalId}) {
    track('Task Dragged To Goal', properties: {'task_id': taskId, 'goal_id': goalId});
  }

  void dailyScoreCtaTapped({required String ctaType}) {
    track('Daily Score CTA Tapped', properties: {'cta_type': ctaType});
  }

  void dailyScoreHelpTapped() => track('Daily Score Help Tapped');

  // ============================================================================
  // INTEGRATIONS PAGE TRACKING
  // ============================================================================

  void integrationsPageOpened() => track('Integrations Page Opened');

  void integrationConnectAttempted({required String integrationName}) {
    track('Integration Connect Attempted', properties: {'integration_name': integrationName});
  }

  void integrationConnectSucceeded({required String integrationName}) {
    track('Integration Connect Succeeded', properties: {'integration_name': integrationName});
  }

  void integrationConnectFailed({required String integrationName}) {
    track('Integration Connect Failed', properties: {'integration_name': integrationName});
  }

  void integrationDisconnected({required String integrationName}) {
    track('Integration Disconnected', properties: {'integration_name': integrationName});
  }

  // ============================================================================
  // PAYMENTS PAGE TRACKING
  // ============================================================================

  void paymentsPageOpened() => track('Payments Page Opened');

  void paymentMethodSelected({required String methodName}) {
    track('Payment Method Selected', properties: {'method_name': methodName});
  }

  // ============================================================================
  // OTHER PAGES TRACKING
  // ============================================================================

  void connectDevicePageOpened() => track('Connect Device Page Opened');

  void getOmiDeviceClicked() => track('Get Omi Device Clicked');

  void connectionGuideOpened() => track('Connection Guide Opened');

  void connectionGuideDeviceTapped(String deviceId) =>
      track('Connection Guide Device Tapped', properties: {'device_id': deviceId});

  void connectionGuideDismissed(String deviceId) =>
      track('Connection Guide Dismissed', properties: {'device_id': deviceId});

  void connectionGuideReportIssue(String deviceId) =>
      track('Connection Guide Report Issue', properties: {'device_id': deviceId});

  void dataPrivacyPageOpened() => track('Data Privacy Page Opened');

  void aiAppGeneratorPageOpened() => track('AI App Generator Page Opened');

  void aiAppGeneratorPromptSubmitted({required int promptLength}) {
    track('AI App Generator Prompt Submitted', properties: {'prompt_length': promptLength});
  }

  void aiAppGeneratorAppGenerated({required bool success}) {
    track('AI App Generator App Generated', properties: {'success': success});
  }

  void importHistoryPageOpened() => track('Import History Page Opened');

  void importStarted({required String source}) {
    track('Import Started', properties: {'source': source});
  }

  void notificationFrequencyChanged({required int oldFrequency, required int newFrequency}) {
    track('Notification Frequency Changed', properties: {'old_frequency': oldFrequency, 'new_frequency': newFrequency});
  }

  static Object? _coerceProperty(dynamic value) {
    if (value == null) return null;
    if (value is bool || value is num || value is String) return value;
    if (value is List) {
      return value.map(_coerceProperty).where((e) => e != null).cast<Object>().toList();
    }
    if (value is Map) {
      final out = <String, Object>{};
      value.forEach((k, v) {
        final coerced = _coerceProperty(v);
        if (coerced != null) out[k.toString()] = coerced;
      });
      return out;
    }
    return value.toString();
  }

  static String get _mobilePlatformName {
    if (PlatformService.isIOS) return 'ios';
    if (PlatformService.isAndroid) return 'android';
    return 'unknown';
  }

  static Future<void> _loadGlobalEventProperties({required Duration timeout}) async {
    var version = 'unknown';
    var build = 'unknown';
    try {
      final packageInfo = await PackageInfo.fromPlatform().timeout(timeout);
      if (packageInfo.version.isNotEmpty) version = packageInfo.version;
      if (packageInfo.buildNumber.isNotEmpty) build = packageInfo.buildNumber;
    } catch (_) {}
    _globalEventProperties = {'app_platform': _mobilePlatformName, 'app_version': version, 'app_build': build};
  }

  static Map<String, dynamic> _searchProperties({required String query, required String surface, int? resultsCount}) {
    final trimmedQuery = query.trim();
    final properties = <String, dynamic>{
      'query_length': query.length,
      'query_word_count': trimmedQuery.isEmpty ? 0 : trimmedQuery.split(RegExp(r'\s+')).length,
      'search_surface': surface,
    };
    if (resultsCount != null) properties['results_count'] = resultsCount;
    return properties;
  }
}

class _QueuedAnalyticsEvent {
  const _QueuedAnalyticsEvent({required this.eventName, required this.properties, this.attempts = 0});

  final String eventName;
  final Map<String, Object> properties;
  final int attempts;

  _QueuedAnalyticsEvent nextAttempt() =>
      _QueuedAnalyticsEvent(eventName: eventName, properties: properties, attempts: attempts + 1);
}