Flutter 딥링킹 완벽 가이드 4편: 라우터 상태 관리와 분석

// models/router_state.dart
import 'package:freezed_annotation/freezed_annotation.dart';

part 'router_state.freezed.dart';

@freezed
class RouterState with _$RouterState {
  const factory RouterState({
    required String currentLocation,
    required List<String> history,
    @Default({}) Map<String, String> pathParameters,
    @Default({}) Map<String, String> queryParameters,
    @Default(false) bool canGoBack,
    String? pendingDeepLink,
    DateTime? lastNavigationTime,
  }) = _RouterState;
  
  factory RouterState.initial() => RouterState(
    currentLocation: '/',
    history: ['/'],
    lastNavigationTime: DateTime.now(),
  );
}

// models/navigation_event.dart
enum NavigationType {
  push,
  pop,
  replace,
  deeplink,
  redirect,
}

class NavigationEvent {
  final String from;
  final String to;
  final NavigationType type;
  final DateTime timestamp;
  final Map<String, dynamic>? metadata;

  NavigationEvent({
    required this.from,
    required this.to,
    required this.type,
    DateTime? timestamp,
    this.metadata,
  }) : timestamp = timestamp ?? DateTime.now();
}

// providers/router_provider.dart
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:go_router/go_router.dart';

class RouterNotifier extends StateNotifier<RouterState> {
  final Ref ref;
  late GoRouter _goRouter;
  final List<NavigationEvent> _events = [];

  RouterNotifier(this.ref) : super(RouterState.initial());

  void setRouter(GoRouter router) {
    _goRouter = router;
  }

  void updateLocation(String location, {
    Map<String, String>? pathParams,
    Map<String, String>? queryParams,
  }) {
    final newHistory = [...state.history, location];
    
    // 히스토리 크기 제한 (메모리 관리)
    if (newHistory.length > 50) {
      newHistory.removeAt(0);
    }

    state = state.copyWith(
      currentLocation: location,
      history: newHistory,
      pathParameters: pathParams ?? {},
      queryParameters: queryParams ?? {},
      canGoBack: newHistory.length > 1,
      lastNavigationTime: DateTime.now(),
    );

    // 이벤트 기록
    _recordEvent(
      from: state.currentLocation,
      to: location,
      type: NavigationType.push,
    );
  }

  void navigateTo(String location) {
    _goRouter.go(location);
    updateLocation(location);
  }

  void goBack() {
    if (state.canGoBack && state.history.length > 1) {
      final newHistory = [...state.history]..removeLast();
      final previousLocation = newHistory.last;
      
      _goRouter.go(previousLocation);
      state = state.copyWith(
        currentLocation: previousLocation,
        history: newHistory,
        canGoBack: newHistory.length > 1,
      );
      
      _recordEvent(
        from: state.currentLocation,
        to: previousLocation,
        type: NavigationType.pop,
      );
    }
  }

  void setPendingDeepLink(String deepLink) {
    state = state.copyWith(pendingDeepLink: deepLink);
  }

  void processPendingDeepLink() {
    if (state.pendingDeepLink != null) {
      navigateTo(state.pendingDeepLink!);
      state = state.copyWith(pendingDeepLink: null);
    }
  }

  void _recordEvent({
    required String from,
    required String to,
    required NavigationType type,
  }) {
    _events.add(NavigationEvent(
      from: from,
      to: to,
      type: type,
    ));
  }

  List<NavigationEvent> getRecentEvents([int limit = 10]) {
    final start = _events.length > limit ? _events.length - limit : 0;
    return _events.sublist(start);
  }
}

// Provider 정의
final routerProvider = StateNotifierProvider<RouterNotifier, RouterState>(
  (ref) => RouterNotifier(ref),
);

// services/navigation_analytics.dart
class NavigationAnalytics {
  final List<NavigationEvent> _events = [];
  final Map<String, int> _screenVisits = {};
  final Map<String, Duration> _screenDuration = {};
  final Map<String, DateTime> _screenEnterTime = {};

  void trackNavigation(NavigationEvent event) {
    _events.add(event);
    
    // 화면 방문 횟수 증가
    _screenVisits[event.to] = (_screenVisits[event.to] ?? 0) + 1;
    
    // 이전 화면 체류 시간 계산
    if (_screenEnterTime.containsKey(event.from)) {
      final duration = event.timestamp.difference(
        _screenEnterTime[event.from]!
      );
      _screenDuration[event.from] = 
        (_screenDuration[event.from] ?? Duration.zero) + duration;
    }
    
    // 새 화면 진입 시간 기록
    _screenEnterTime[event.to] = event.timestamp;
  }

  Map<String, dynamic> getAnalytics() {
    return {
      'totalNavigations': _events.length,
      'uniqueScreens': _screenVisits.keys.length,
      'mostVisited': _getMostVisitedScreens(),
      'averageDuration': _getAverageDuration(),
      'userJourneys': _extractUserJourneys(),
      'backtrackingRate': _calculateBacktrackingRate(),
    };
  }

  List<String> _getMostVisitedScreens([int limit = 5]) {
    final sorted = _screenVisits.entries.toList()
      ..sort((a, b) => b.value.compareTo(a.value));
    
    return sorted
        .take(limit)
        .map((e) => e.key)
        .toList();
  }

  Map<String, double> _getAverageDuration() {
    final averages = <String, double>{};
    
    _screenDuration.forEach((screen, totalDuration) {
      final visits = _screenVisits[screen] ?? 1;
      averages[screen] = totalDuration.inSeconds / visits;
    });
    
    return averages;
  }

  List<List<String>> _extractUserJourneys() {
    final journeys = <List<String>>[];
    List<String> currentJourney = [];
    
    for (final event in _events) {
      if (event.type == NavigationType.deeplink ||
          currentJourney.isEmpty) {
        if (currentJourney.isNotEmpty) {
          journeys.add(currentJourney);
        }
        currentJourney = [event.to];
      } else {
        currentJourney.add(event.to);
      }
    }
    
    if (currentJourney.isNotEmpty) {
      journeys.add(currentJourney);
    }
    
    return journeys;
  }

  double _calculateBacktrackingRate() {
    if (_events.isEmpty) return 0.0;
    
    int backtrackCount = 0;
    for (int i = 1; i < _events.length; i++) {
      if (_events[i].type == NavigationType.pop) {
        backtrackCount++;
      }
    }
    
    return backtrackCount / _events.length;
  }
}

// widgets/router_debugger.dart
class RouterDebugger extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final routerState = ref.watch(routerProvider);
    
    if (!kDebugMode) return const SizedBox.shrink();
    
    return DraggableScrollableSheet(
      initialChildSize: 0.1,
      minChildSize: 0.1,
      maxChildSize: 0.8,
      builder: (context, scrollController) {
        return Container(
          color: Colors.black87,
          child: ListView(
            controller: scrollController,
            padding: const EdgeInsets.all(16),
            children: [
              _buildHeader(routerState),
              const SizedBox(height: 16),
              _buildHistory(routerState),
              const SizedBox(height: 16),
              _buildParameters(routerState),
              const SizedBox(height: 16),
              _buildActions(ref),
            ],
          ),
        );
      },
    );
  }
  
  Widget _buildHeader(RouterState state) {
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        Text(
          'Current: ${state.currentLocation}',
          style: const TextStyle(
            color: Colors.white,
            fontSize: 16,
            fontWeight: FontWeight.bold,
          ),
        ),
        Text(
          'Can Go Back: ${state.canGoBack}',
          style: const TextStyle(color: Colors.grey),
        ),
      ],
    );
  }
  
  Widget _buildHistory(RouterState state) {
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        const Text(
          'History:',
          style: TextStyle(
            color: Colors.white,
            fontWeight: FontWeight.bold,
          ),
        ),
        ...state.history.reversed.take(5).map(
          (location) => Text(
            '  • $location',
            style: const TextStyle(color: Colors.white70),
          ),
        ),
      ],
    );
  }
  
  Widget _buildParameters(RouterState state) {
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        const Text(
          'Parameters:',
          style: TextStyle(
            color: Colors.white,
            fontWeight: FontWeight.bold,
          ),
        ),
        if (state.pathParameters.isNotEmpty)
          ...state.pathParameters.entries.map(
            (e) => Text(
              '  ${e.key}: ${e.value}',
              style: const TextStyle(color: Colors.white70),
            ),
          ),
        if (state.queryParameters.isNotEmpty)
          ...state.queryParameters.entries.map(
            (e) => Text(
              '  ?${e.key}=${e.value}',
              style: const TextStyle(color: Colors.white70),
            ),
          ),
      ],
    );
  }
  
  Widget _buildActions(WidgetRef ref) {
    return Row(
      children: [
        ElevatedButton(
          onPressed: () {
            ref.read(routerProvider.notifier).goBack();
          },
          child: const Text('Go Back'),
        ),
        const SizedBox(width: 8),
        ElevatedButton(
          onPressed: () {
            ref.read(routerProvider.notifier).navigateTo('/');
          },
          child: const Text('Go Home'),
        ),
      ],
    );
  }
}