halkyon/halkyon_learn_flutter/lib/src/app/app_router.dart

import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:go_router/go_router.dart';
import 'package:halkyon_learn_flutter/src/core/dependencies/person_scope.dart';
import 'package:halkyon_learn_flutter/src/core/router/app_shell.dart';
import 'package:halkyon_learn_flutter/src/core/router/route_paths.dart';
import 'package:halkyon_learn_flutter/src/core/router/tab_visibility.dart';
import 'package:halkyon_learn_flutter/src/core/widget/found_by_id.dart';
import 'package:halkyon_learn_flutter/src/feature/auth/widget/profile_screen.dart';
import 'package:halkyon_learn_flutter/src/feature/card/bloc/card_composer_bloc.dart';
import 'package:halkyon_learn_flutter/src/feature/card/widget/composer/card_composer_screen.dart';
import 'package:halkyon_learn_flutter/src/feature/explore/widget/explore_screen.dart';
import 'package:halkyon_learn_flutter/src/feature/home/widget/home_screen.dart';
import 'package:halkyon_learn_flutter/src/feature/note/bloc/note_editor_bloc.dart';
import 'package:halkyon_learn_flutter/src/feature/note/widget/note_editor_screen.dart';
import 'package:halkyon_learn_flutter/src/feature/settings/widget/settings_screen.dart';
import 'package:halkyon_learn_flutter/src/feature/study/bloc/study_session_bloc.dart';
import 'package:halkyon_learn_flutter/src/feature/study/widget/study_screen.dart';
import 'package:halkyon_learn_flutter/src/feature/studyset/model/studyset.dart';
import 'package:halkyon_learn_flutter/src/feature/studyset/widget/library_screen.dart';
import 'package:halkyon_learn_flutter/src/feature/studyset/widget/studyset_screen.dart';
import 'package:material_ui/material_ui.dart';

/// The router of one person's app: the four tabs in a shell, each with its own
/// stack of screens, and the focused surfaces over them. Every route is built
/// inside the person's scope, so screens read their repositories from
/// [PersonScope]. The app opens at [initialLocation].
GoRouter buildRouter({String initialLocation = RoutePaths.home}) => GoRouter(
  initialLocation: initialLocation,
  routes: [
    StatefulShellRoute(
      builder: (context, state, navigationShell) =>
          AppShell(navigationShell: navigationShell),
      navigatorContainerBuilder: tabsContainer,
      // In the order of the shell's destinations.
      branches: [
        StatefulShellBranch(
          routes: [
            GoRoute(
              path: RoutePaths.home,
              builder: (context, state) => const HomeScreen(),
            ),
          ],
        ),
        StatefulShellBranch(
          routes: [
            GoRoute(
              path: RoutePaths.library,
              builder: (context, state) => const LibraryScreen(),
              // Nested, so a studyset's screen sits above the library in the
              // tab's stack.
              routes: [
                GoRoute(
                  path: 'studysets/:id',
                  // Keyed by the id: several studysets' screens can be on
                  // the stack at once, and must not share one page.
                  pageBuilder: (context, state) {
                    final id = state.pathParameters['id']!;
                    return MaterialPage<void>(
                      key: ValueKey('studyset-$id'),
                      child: _studysetScreen(context, id),
                    );
                  },
                ),
              ],
            ),
          ],
        ),
        StatefulShellBranch(
          routes: [
            GoRoute(
              path: RoutePaths.explore,
              builder: (context, state) => const ExploreScreen(),
            ),
          ],
        ),
        StatefulShellBranch(
          routes: [
            GoRoute(
              path: RoutePaths.profile,
              builder: (context, state) => const ProfileScreen(),
            ),
          ],
        ),
      ],
    ),
    // Over the tabs: they need the whole window.
    GoRoute(
      path: '/study/:studysetId',
      builder: (context, state) {
        final person = PersonScope.of(context);
        final studysetId = state.pathParameters['studysetId']!;
        return FoundById<Studyset>(
          id: studysetId,
          items: person.studysets.watchAll,
          idOf: (studyset) => studyset.id,
          builder: (studyset, _) => BlocProvider(
            create: (context) => StudySessionBloc(
              person.studysets,
              person.cards,
              person.reviews,
              person.tags,
              person.settings,
              studysetId,
            )..add(const StudySessionEventStarted()),
            child: StudyScreen(
              studysetId: studysetId,
              title: studyset.content.title,
            ),
          ),
        );
      },
    ),
    // The composer: writing a studyset's cards, opened on a new card or on
    // one of them. Before the card route: its `new` would otherwise read as
    // a card's id.
    GoRoute(
      path: '/studysets/:studysetId/cards/new',
      builder: (context, state) =>
          _composer(context, state.pathParameters['studysetId']!),
    ),
    GoRoute(
      path: '/studysets/:studysetId/cards/:cardId',
      builder: (context, state) => _composer(
        context,
        state.pathParameters['studysetId']!,
        cardId: state.pathParameters['cardId'],
      ),
    ),
    // A note, new or stored; the new one's route first, as for cards.
    GoRoute(
      path: '/studysets/:studysetId/notes/new',
      builder: (context, state) =>
          _noteEditor(context, state.pathParameters['studysetId']!),
    ),
    GoRoute(
      path: '/studysets/:studysetId/notes/:noteId',
      builder: (context, state) => _noteEditor(
        context,
        state.pathParameters['studysetId']!,
        noteId: state.pathParameters['noteId'],
      ),
    ),
    GoRoute(
      path: RoutePaths.settings,
      builder: (context, state) => const SettingsScreen(),
    ),
  ],
);

Widget _studysetScreen(BuildContext context, String id) => FoundById<Studyset>(
  id: id,
  items: PersonScope.of(context).studysets.watchAll,
  idOf: (studyset) => studyset.id,
  builder: (studyset, all) => StudysetScreen(studyset: studyset, all: all),
);

/// The note [noteId] of the studyset [studysetId], or a new one without; a
/// studyset gone (deleted, or an old link) says so. Leaving the note closes
/// its bloc, which saves what is unsaved.
Widget _noteEditor(BuildContext context, String studysetId, {String? noteId}) {
  final person = PersonScope.of(context);
  return FoundById<Studyset>(
    id: studysetId,
    items: person.studysets.watchAll,
    idOf: (studyset) => studyset.id,
    builder: (studyset, _) => BlocProvider(
      create: (context) =>
          NoteEditorBloc(person.notes, person.tags, studysetId, noteId: noteId)
            ..add(const NoteEditorEventStarted()),
      child: NoteEditorScreen(studysetTitle: studyset.content.title),
    ),
  );
}

/// The composer of the studyset [studysetId]'s cards, opened on [cardId] if
/// given; a studyset gone (deleted, or an old link) says so.
Widget _composer(BuildContext context, String studysetId, {String? cardId}) {
  final person = PersonScope.of(context);
  return FoundById<Studyset>(
    id: studysetId,
    items: person.studysets.watchAll,
    idOf: (studyset) => studyset.id,
    builder: (studyset, _) => BlocProvider(
      create: (context) =>
          CardComposerBloc(person.cards, person.tags, studysetId)
            ..add(const CardComposerEventStarted()),
      child: CardComposerScreen(
        studysetTitle: studyset.content.title,
        initialCardId: cardId,
      ),
    ),
  );
}