Merge pull request 'change a bunch of stuff, seperate tracking for progress, updated custom srs layout' (#6) from seperate_leassons_custom into master

Reviewed-on: #6

.gitignore

@@ -46,3 +46,6 @@ app.*.map.json
 
 *.jks
 gradle.properties
+
+# Environment variables
+.env

android/app/src/main/AndroidManifest.xml

@@ -42,5 +42,8 @@
             <action android:name="android.intent.action.PROCESS_TEXT"/>
             <data android:mimeType="text/plain"/>
         </intent>
+        <intent>
+            <action android:name="android.intent.action.TTS_SERVICE" />
+        </intent>
     </queries>
 </manifest>

android/app/src/main/kotlin/com/crylia/hirameki/MainActivity.kt

@@ -1,4 +1,4 @@
-package com.example.untitled1
+package com.crylia.hirameki
 
 import io.flutter.embedding.android.FlutterActivity
 

lib/main.dart

@@ -1,14 +1,25 @@
 import 'package:flutter/material.dart';
+import 'package:hirameki_srs/src/services/vocab_deck_repository.dart';
 import 'package:provider/provider.dart';
+import 'package:flutter_dotenv/flutter_dotenv.dart';
 import 'src/services/deck_repository.dart';
 import 'src/screens/start_screen.dart';
 
 void main() async {
   WidgetsFlutterBinding.ensureInitialized();
+  try {
+    await dotenv.load(fileName: ".env");
+  } catch (e) {
+    // It's okay if the .env file is not found.
+    // This is expected in release builds.
+  }
 
   runApp(
-    Provider<DeckRepository>(
+    MultiProvider(
-      create: (_) => DeckRepository(),
+      providers: [
+        Provider<DeckRepository>(create: (_) => DeckRepository()),
+        Provider<VocabDeckRepository>(create: (_) => VocabDeckRepository()),
+      ],
       child: const WkApp(),
     ),
   );

lib/src/models/custom_kanji_item.dart

@@ -0,0 +1,97 @@
+
+class CustomKanjiItem {
+  final String characters;
+  final String meaning;
+  final String? kanji;
+  final bool useInterval;
+  SrsData srsData;
+
+  CustomKanjiItem({
+    required this.characters,
+    required this.meaning,
+    this.kanji,
+    this.useInterval = false,
+    SrsData? srsData,
+  }) : srsData = srsData ?? SrsData();
+
+  factory CustomKanjiItem.fromJson(Map<String, dynamic> json) {
+    SrsData srsData;
+    if (json['srsData'] != null) {
+      srsData = SrsData.fromJson(json['srsData']);
+      if (json['nextReview'] != null) {
+        final oldNextReview = DateTime.parse(json['nextReview'] as String);
+        srsData.japaneseToEnglishNextReview ??= oldNextReview;
+        srsData.englishToJapaneseNextReview ??= oldNextReview;
+        srsData.listeningComprehensionNextReview ??= oldNextReview;
+      }
+    } else {
+      DateTime? nextReview = json['nextReview'] != null ? DateTime.parse(json['nextReview'] as String) : null;
+      srsData = SrsData(
+        japaneseToEnglish: json['srsLevel'] as int? ?? 0,
+        japaneseToEnglishNextReview: nextReview,
+        englishToJapanese: json['srsLevel'] as int? ?? 0,
+        englishToJapaneseNextReview: nextReview,
+        listeningComprehension: json['srsLevel'] as int? ?? 0,
+        listeningComprehensionNextReview: nextReview,
+      );
+    }
+
+    return CustomKanjiItem(
+      characters: json['characters'] as String,
+      meaning: json['meaning'] as String,
+      kanji: json['kanji'] as String?,
+      useInterval: json['useInterval'] as bool? ?? false,
+      srsData: srsData,
+    );
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      'characters': characters,
+      'meaning': meaning,
+      'kanji': kanji,
+      'useInterval': useInterval,
+      'srsData': srsData.toJson(),
+    };
+  }
+}
+
+class SrsData {
+  int japaneseToEnglish;
+  DateTime? japaneseToEnglishNextReview;
+  int englishToJapanese;
+  DateTime? englishToJapaneseNextReview;
+  int listeningComprehension;
+  DateTime? listeningComprehensionNextReview;
+
+  SrsData({
+    this.japaneseToEnglish = 0,
+    this.japaneseToEnglishNextReview,
+    this.englishToJapanese = 0,
+    this.englishToJapaneseNextReview,
+    this.listeningComprehension = 0,
+    this.listeningComprehensionNextReview,
+  });
+
+  factory SrsData.fromJson(Map<String, dynamic> json) {
+    return SrsData(
+      japaneseToEnglish: json['japaneseToEnglish'] as int? ?? 0,
+      japaneseToEnglishNextReview: json['japaneseToEnglishNextReview'] != null ? DateTime.parse(json['japaneseToEnglishNextReview'] as String) : null,
+      englishToJapanese: json['englishToJapanese'] as int? ?? 0,
+      englishToJapaneseNextReview: json['englishToJapaneseNextReview'] != null ? DateTime.parse(json['englishToJapaneseNextReview'] as String) : null,
+      listeningComprehension: json['listeningComprehension'] as int? ?? 0,
+      listeningComprehensionNextReview: json['listeningComprehensionNextReview'] != null ? DateTime.parse(json['listeningComprehensionNextReview'] as String) : null,
+    );
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      'japaneseToEnglish': japaneseToEnglish,
+      'japaneseToEnglishNextReview': japaneseToEnglishNextReview?.toIso8601String(),
+      'englishToJapanese': englishToJapanese,
+      'englishToJapaneseNextReview': englishToJapaneseNextReview?.toIso8601String(),
+      'listeningComprehension': listeningComprehension,
+      'listeningComprehensionNextReview': listeningComprehensionNextReview?.toIso8601String(),
+    };
+  }
+}

lib/src/screens/add_card_screen.dart

@@ -0,0 +1,141 @@
+
+import 'package:flutter/material.dart';
+import 'package:kana_kit/kana_kit.dart';
+import '../models/custom_kanji_item.dart';
+import '../services/custom_deck_repository.dart';
+
+class AddCardScreen extends StatefulWidget {
+  const AddCardScreen({super.key});
+
+  @override
+  State<AddCardScreen> createState() => _AddCardScreenState();
+}
+
+class _AddCardScreenState extends State<AddCardScreen> {
+  final _formKey = GlobalKey<FormState>();
+  final _japaneseController = TextEditingController();
+  final _englishController = TextEditingController();
+  final _kanjiController = TextEditingController();
+  final _kanaKit = const KanaKit();
+  final _deckRepository = CustomDeckRepository();
+  bool _useInterval = false;
+
+  @override
+  void initState() {
+    super.initState();
+    _japaneseController.addListener(_convertToKana);
+  }
+
+  @override
+  void dispose() {
+    _japaneseController.removeListener(_convertToKana);
+    _japaneseController.dispose();
+    _englishController.dispose();
+    _kanjiController.dispose();
+    super.dispose();
+  }
+
+  void _convertToKana() {
+    final text = _japaneseController.text;
+    final converted = _kanaKit.toKana(text);
+    if (text != converted) {
+      _japaneseController.value = _japaneseController.value.copyWith(
+        text: converted,
+        selection: TextSelection.fromPosition(
+          TextPosition(offset: converted.length),
+        ),
+      );
+    }
+  }
+
+  void _saveCard() {
+    if (_formKey.currentState!.validate()) {
+      final srsData = _useInterval
+          ? SrsData(
+              japaneseToEnglishNextReview: DateTime.now(),
+              englishToJapaneseNextReview: DateTime.now(),
+              listeningComprehensionNextReview: DateTime.now(),
+            )
+          : SrsData();
+
+      final newItem = CustomKanjiItem(
+        characters: _japaneseController.text,
+        meaning: _englishController.text,
+        kanji: _kanjiController.text.trim().isNotEmpty ? _kanjiController.text.trim() : null,
+        useInterval: _useInterval,
+        srsData: srsData,
+      );
+      _deckRepository.addCard(newItem);
+      Navigator.of(context).pop();
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('Add New Card'),
+      ),
+      body: Padding(
+        padding: const EdgeInsets.all(16.0),
+        child: Form(
+          key: _formKey,
+          child: Column(
+            children: [
+              TextFormField(
+                controller: _japaneseController,
+                decoration: const InputDecoration(
+                  labelText: 'Japanese (Kana)',
+                  hintText: 'Enter Japanese vocabulary or kanji',
+                ),
+                validator: (value) {
+                  if (value == null || value.isEmpty) {
+                    return 'Please enter a Japanese term';
+                  }
+                  return null;
+                },
+              ),
+              const SizedBox(height: 16),
+              TextFormField(
+                controller: _kanjiController,
+                decoration: const InputDecoration(
+                  labelText: 'Japanese (Kanji)',
+                  hintText: 'Enter the kanji (optional)',
+                ),
+              ),
+              const SizedBox(height: 16),
+              TextFormField(
+                controller: _englishController,
+                decoration: const InputDecoration(
+                  labelText: 'English',
+                  hintText: 'Enter the English meaning',
+                ),
+                validator: (value) {
+                  if (value == null || value.isEmpty) {
+                    return 'Please enter an English meaning';
+                  }
+                  return null;
+                },
+              ),
+              const SizedBox(height: 16),
+              SwitchListTile(
+                title: const Text('Use Interval-based SRS'),
+                value: _useInterval,
+                onChanged: (value) {
+                  setState(() {
+                    _useInterval = value;
+                  });
+                },
+              ),
+              const SizedBox(height: 32),
+              ElevatedButton(
+                onPressed: _saveCard,
+                child: const Text('Save Card'),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}

lib/src/screens/browse_screen.dart

@@ -1,7 +1,15 @@
+import 'dart:convert';
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
+import 'package:http/http.dart' as http;
 import '../models/kanji_item.dart';
 import '../services/deck_repository.dart';
+import 'package:hirameki_srs/src/services/vocab_deck_repository.dart';
+import '../services/custom_deck_repository.dart';
+import '../models/custom_kanji_item.dart';
+import 'settings_screen.dart';
+import 'custom_card_details_screen.dart';
+import 'add_card_screen.dart';
 
 class BrowseScreen extends StatefulWidget {
   const BrowseScreen({super.key});
@@ -10,28 +18,34 @@ class BrowseScreen extends StatefulWidget {
   State<BrowseScreen> createState() => _BrowseScreenState();
 }
 
-class _BrowseScreenState extends State<BrowseScreen>
+class _BrowseScreenState extends State<BrowseScreen> with SingleTickerProviderStateMixin {
-    with SingleTickerProviderStateMixin {
   late TabController _tabController;
   late PageController _kanjiPageController;
   late PageController _vocabPageController;
 
   List<KanjiItem> _kanjiDeck = [];
   List<VocabularyItem> _vocabDeck = [];
+  List<CustomKanjiItem> _customDeck = [];
   Map<int, List<KanjiItem>> _kanjiByLevel = {};
   Map<int, List<VocabularyItem>> _vocabByLevel = {};
   List<int> _kanjiSortedLevels = [];
   List<int> _vocabSortedLevels = [];
 
+  final _customDeckRepository = CustomDeckRepository();
+
+  bool _isSelectionMode = false;
+  List<CustomKanjiItem> _selectedItems = [];
+
   bool _loading = true;
   String _status = 'Loading...';
   int _currentKanjiPage = 0;
   int _currentVocabPage = 0;
+  bool _apiKeyMissing = false;
 
   @override
   void initState() {
     super.initState();
-    _tabController = TabController(length: 2, vsync: this);
+    _tabController = TabController(length: 3, vsync: this);
     _kanjiPageController = PageController();
     _vocabPageController = PageController();
 
@@ -56,91 +70,48 @@ class _BrowseScreenState extends State<BrowseScreen>
     });
 
     _loadDecks();
-  }
+    _loadCustomDeck();
-
-  Future<void> _loadDecks() async {
-    setState(() => _loading = true);
-    try {
-      final repo = Provider.of<DeckRepository>(context, listen: false);
-      await repo.loadApiKey();
-      final apiKey = repo.apiKey;
-
-      if (apiKey == null || apiKey.isEmpty) {
-        setState(() {
-          _status = 'API key not set.';
-          _loading = false;
-        });
-        return;
-      }
-
-      var kanji = await repo.loadKanji();
-      if (kanji.isEmpty || kanji.every((k) => k.level == 0)) {
-        setState(() => _status = 'Fetching kanji from WaniKani...');
-        kanji = await repo.fetchAndCacheFromWk(apiKey);
-      }
-
-      var vocab = await repo.loadVocabulary();
-      if (vocab.isEmpty || vocab.every((v) => v.level == 0)) {
-        setState(() => _status = 'Fetching vocabulary from WaniKani...');
-        vocab = await repo.fetchAndCacheVocabularyFromWk(apiKey);
-      }
-
-      _kanjiDeck = kanji;
-      _vocabDeck = vocab;
-      _groupItemsByLevel();
-
-      setState(() {
-        _loading = false;
-        _status =
-            'Loaded ${_kanjiDeck.length} kanji and ${_vocabDeck.length} vocabulary.';
-      });
-    } catch (e) {
-      setState(() {
-        _status = 'Error: $e';
-        _loading = false;
-      });
-    }
-  }
-
-  void _groupItemsByLevel() {
-    _kanjiByLevel = {};
-    for (final item in _kanjiDeck) {
-      if (item.level > 0) {
-        (_kanjiByLevel[item.level] ??= []).add(item);
-      }
-    }
-    _kanjiSortedLevels = _kanjiByLevel.keys.toList()..sort();
-
-    _vocabByLevel = {};
-    for (final item in _vocabDeck) {
-      if (item.level > 0) {
-        (_vocabByLevel[item.level] ??= []).add(item);
-      }
-    }
-    _vocabSortedLevels = _vocabByLevel.keys.toList()..sort();
   }
 
   @override
-  Widget build(BuildContext context) {
+  void dispose() {
-    return Scaffold(
+    _tabController.dispose();
-      backgroundColor: const Color(0xFF121212),
+    _kanjiPageController.dispose();
-      appBar: AppBar(
+    _vocabPageController.dispose();
-        title: const Text('Browse Items'),
+    super.dispose();
-        backgroundColor: const Color(0xFF1F1F1F),
+  }
-        foregroundColor: Colors.white,
+
-        bottom: TabBar(
+  Future<void> _loadCustomDeck() async {
-          controller: _tabController,
+    final customDeck = await _customDeckRepository.getCustomDeck();
-          tabs: const [
+    setState(() {
-            Tab(text: 'Kanji'),
+      _customDeck = customDeck;
-            Tab(text: 'Vocabulary'),
+    });
+  }
+
+  Widget _buildWaniKaniTab(Widget child) {
+    if (_apiKeyMissing) {
+      return Center(
+        child: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            const Text('WaniKani API key is not set.', style: TextStyle(color: Colors.white)),
+            const SizedBox(height: 16),
+            ElevatedButton(
+              onPressed: () async {
+                await Navigator.of(context).push(
+                  MaterialPageRoute(builder: (_) => const SettingsScreen()),
+                );
+                _loadDecks();
+              },
+              child: const Text('Go to Settings'),
+            ),
           ],
-          labelColor: Colors.blueAccent,
-          unselectedLabelColor: Colors.grey,
-          indicatorColor: Colors.blueAccent,
         ),
-      ),
+      );
-      body: _loading
+    }
-          ? Center(
+
+    if (_loading) {
+      return Center(
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
@@ -149,35 +120,21 @@ class _BrowseScreenState extends State<BrowseScreen>
             Text(_status, style: const TextStyle(color: Colors.white)),
           ],
         ),
-            )
-          : Column(
-              children: [
-                Expanded(
-                  child: TabBarView(
-                    controller: _tabController,
-                    children: [
-                      _buildPaginatedView(
-                          _kanjiByLevel,
-                          _kanjiSortedLevels,
-                          _kanjiPageController,
-                          (items) => _buildGridView(items.cast<KanjiItem>())),
-                      _buildPaginatedView(
-                          _vocabByLevel,
-                          _vocabSortedLevels,
-                          _vocabPageController,
-                          (items) => _buildListView(items.cast<VocabularyItem>())),
-                    ],
-                  ),
-                ),
-                SafeArea(
-                  top: false,
-                  child: _buildLevelSelector(),
-                ),
-              ],
-            ),
       );
     }
 
+    return child;
+  }
+
+  Widget _buildCustomSrsTab() {
+    if (_customDeck.isEmpty) {
+      return const Center(
+        child: Text('No custom cards yet.', style: TextStyle(color: Colors.white)),
+      );
+    }
+    return _buildCustomGridView(_customDeck);
+  }
+
   Widget _buildPaginatedView(
       Map<int, List<dynamic>> groupedItems,
       List<int> sortedLevels,
@@ -269,8 +226,7 @@ class _BrowseScreenState extends State<BrowseScreen>
         final item = items[index];
         return GestureDetector(
           onTap: () => _showReadingsDialog(item),
-          child:
+          child: _buildSrsItemCard(item),
-              _buildSrsItemCard(item.characters, item.srsItems.values.toList()),
         );
       },
       padding: const EdgeInsets.all(8),
@@ -288,14 +244,28 @@ class _BrowseScreenState extends State<BrowseScreen>
   }
 
   Widget _buildVocabListTile(VocabularyItem item) {
-    final avgSrsStage = item.srsItems.isNotEmpty
+    final requiredModes = <String>[
-        ? item.srsItems.values
+      VocabQuizMode.vocabToEnglish.toString(),
-                .map((s) => s.srsStage)
+      VocabQuizMode.englishToVocab.toString(),
-                .reduce((a, b) => a + b) /
+      VocabQuizMode.audioToEnglish.toString(),
-            item.srsItems.length
+    ];
-        : 0.0;
 
-    return Card(
+    int minSrsStage = 9;
+
+    for (final mode in requiredModes) {
+      final srsItem = item.srsItems[mode];
+      if (srsItem == null) {
+        minSrsStage = 0;
+        break;
+      }
+      if (srsItem.srsStage < minSrsStage) {
+        minSrsStage = srsItem.srsStage;
+      }
+    }
+
+    return GestureDetector(
+      onTap: () => _showVocabDetailsDialog(context, item),
+      child: Card(
         color: const Color(0xFF1E1E1E),
         margin: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
         child: Padding(
@@ -320,21 +290,41 @@ class _BrowseScreenState extends State<BrowseScreen>
                       overflow: TextOverflow.ellipsis,
                     ),
                     const SizedBox(height: 8),
-                  _buildSrsIndicator(avgSrsStage.round()),
+                    _buildSrsIndicator(minSrsStage),
                   ],
                 ),
               ),
             ],
           ),
         ),
+      ),
     );
   }
 
-  Widget _buildSrsItemCard(String characters, List<dynamic> srsItems) {
+  Widget _buildSrsItemCard(KanjiItem item) {
-    final avgSrsStage = srsItems.isNotEmpty
+    final requiredModes = <String>[
-        ? srsItems.map((s) => s.srsStage).reduce((a, b) => a + b) /
+      QuizMode.kanjiToEnglish.toString(),
-            srsItems.length
+      QuizMode.englishToKanji.toString(),
-        : 0.0;
+    ];
+    if (item.onyomi.isNotEmpty) {
+      requiredModes.add('${QuizMode.reading}onyomi');
+    }
+    if (item.kunyomi.isNotEmpty) {
+      requiredModes.add('${QuizMode.reading}kunyomi');
+    }
+
+    int minSrsStage = 9;
+
+    for (final mode in requiredModes) {
+      final srsItem = item.srsItems[mode];
+      if (srsItem == null) {
+        minSrsStage = 0;
+        break;
+      }
+      if (srsItem.srsStage < minSrsStage) {
+        minSrsStage = srsItem.srsStage;
+      }
+    }
 
     return Card(
       color: const Color(0xFF1E1E1E),
@@ -344,12 +334,12 @@ class _BrowseScreenState extends State<BrowseScreen>
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
             Text(
-              characters,
+              item.characters,
               style: const TextStyle(fontSize: 32, color: Colors.white),
               textAlign: TextAlign.center,
             ),
             const SizedBox(height: 8),
-            _buildSrsIndicator(avgSrsStage.round()),
+            _buildSrsIndicator(minSrsStage),
           ],
         ),
       ),
@@ -386,6 +376,32 @@ class _BrowseScreenState extends State<BrowseScreen>
   }
 
   void _showReadingsDialog(KanjiItem kanji) {
+    final srsScores = <String, int>{
+      'JP -> EN': 0,
+      'EN -> JP': 0,
+      'Reading (onyomi)': 0,
+      'Reading (kunyomi)': 0,
+    };
+
+    for (final entry in kanji.srsItems.entries) {
+      final srsItem = entry.value;
+      switch (srsItem.quizMode) {
+        case QuizMode.kanjiToEnglish:
+          srsScores['JP -> EN'] = srsItem.srsStage;
+          break;
+        case QuizMode.englishToKanji:
+          srsScores['EN -> JP'] = srsItem.srsStage;
+          break;
+        case QuizMode.reading:
+          if (srsItem.readingType == 'onyomi') {
+            srsScores['Reading (onyomi)'] = srsItem.srsStage;
+          } else if (srsItem.readingType == 'kunyomi') {
+            srsScores['Reading (kunyomi)'] = srsItem.srsStage;
+          }
+          break;
+      }
+    }
+
     showDialog(
       context: context,
       builder: (context) {
@@ -395,7 +411,8 @@ class _BrowseScreenState extends State<BrowseScreen>
             'Details for ${kanji.characters}',
             style: const TextStyle(color: Colors.white),
           ),
-          content: Column(
+          content: SingleChildScrollView(
+            child: Column(
               mainAxisSize: MainAxisSize.min,
               crossAxisAlignment: CrossAxisAlignment.start,
               children: [
@@ -425,8 +442,21 @@ class _BrowseScreenState extends State<BrowseScreen>
                     'No readings available.',
                     style: TextStyle(color: Colors.white),
                   ),
+                const SizedBox(height: 16),
+                const Divider(color: Colors.grey),
+                const SizedBox(height: 16),
+                const Text(
+                  'SRS Scores:',
+                  style: TextStyle(
+                      color: Colors.white, fontWeight: FontWeight.bold),
+                ),
+                ...srsScores.entries.map((entry) => Text(
+                      '  ${entry.key}: ${entry.value}',
+                      style: const TextStyle(color: Colors.white),
+                    )),
               ],
             ),
+          ),
           actions: [
             TextButton(
               onPressed: () => Navigator.of(context).pop(),
@@ -439,11 +469,530 @@ class _BrowseScreenState extends State<BrowseScreen>
     );
   }
 
+  Future<void> _loadDecks() async {
+    setState(() => _loading = true);
+    try {
+      final kanjiRepo = Provider.of<DeckRepository>(context, listen: false);
+      final vocabRepo =
+          Provider.of<VocabDeckRepository>(context, listen: false);
+      await kanjiRepo.loadApiKey();
+      final apiKey = kanjiRepo.apiKey;
+
+      if (apiKey == null || apiKey.isEmpty) {
+        setState(() {
+          _apiKeyMissing = true;
+          _loading = false;
+        });
+        return;
+      }
+
+      var kanji = await kanjiRepo.loadKanji();
+      if (kanji.isEmpty || kanji.every((k) => k.level == 0)) {
+        setState(() => _status = 'Fetching kanji from WaniKani...');
+        kanji = await kanjiRepo.fetchAndCacheFromWk(apiKey);
+      }
+
+      var vocab = await vocabRepo.loadVocabulary();
+      if (vocab.isEmpty || vocab.every((v) => v.level == 0)) {
+        setState(() => _status = 'Fetching vocabulary from WaniKani...');
+        vocab = await vocabRepo.fetchAndCacheVocabularyFromWk(apiKey);
+      }
+
+      _kanjiDeck = kanji;
+      _vocabDeck = vocab;
+      _groupItemsByLevel();
+
+      setState(() {
+        _loading = false;
+        _status =
+            'Loaded ${_kanjiDeck.length} kanji and ${_vocabDeck.length} vocabulary.';
+        _apiKeyMissing = false;
+      });
+    } catch (e) {
+      setState(() {
+        _status = 'Error: $e';
+        _loading = false;
+      });
+    }
+  }
+
+  void _groupItemsByLevel() {
+    _kanjiByLevel = {};
+    for (final item in _kanjiDeck) {
+      if (item.level > 0) {
+        (_kanjiByLevel[item.level] ??= []).add(item);
+      }
+    }
+    _kanjiSortedLevels = _kanjiByLevel.keys.toList()..sort();
+
+    _vocabByLevel = {};
+    for (final item in _vocabDeck) {
+      if (item.level > 0) {
+        (_vocabByLevel[item.level] ??= []).add(item);
+      }
+    }
+    _vocabSortedLevels = _vocabByLevel.keys.toList()..sort();
+  }
+
   @override
-  void dispose() {
+  Widget build(BuildContext context) {
-    _tabController.dispose();
+    return Scaffold(
-    _kanjiPageController.dispose();
+      appBar:
-    _vocabPageController.dispose();
+          _isSelectionMode ? _buildSelectionAppBar() : _buildDefaultAppBar(),
-    super.dispose();
+      backgroundColor: const Color(0xFF121212),
+      body: Column(
+        children: [
+          Expanded(
+            child: TabBarView(
+              controller: _tabController,
+              children: [
+                _buildWaniKaniTab(
+                  _buildPaginatedView(
+                      _kanjiByLevel,
+                      _kanjiSortedLevels,
+                      _kanjiPageController,
+                      (items) => _buildGridView(items.cast<KanjiItem>())),
+                ),
+                _buildWaniKaniTab(
+                  _buildPaginatedView(
+                      _vocabByLevel,
+                      _vocabSortedLevels,
+                      _vocabPageController,
+                      (items) =>
+                          _buildListView(items.cast<VocabularyItem>())),
+                ),
+                _buildCustomSrsTab(),
+              ],
+            ),
+          ),
+          if (!_isSelectionMode)
+            SafeArea(
+              top: false,
+              child: _tabController.index < 2
+                  ? _buildLevelSelector()
+                  : const SizedBox.shrink(),
+            ),
+        ],
+      ),
+      floatingActionButton: _tabController.index == 2
+          ? FloatingActionButton(
+              onPressed: () async {
+                await Navigator.of(context).push(
+                  MaterialPageRoute(builder: (_) => AddCardScreen()),
+                );
+                _loadCustomDeck();
+              },
+              child: const Icon(Icons.add),
+            )
+          : null,
+    );
+  }
+
+  AppBar _buildDefaultAppBar() {
+    return AppBar(
+      title: const Text('Browse'),
+      bottom: TabBar(
+        controller: _tabController,
+        tabs: const [
+          Tab(text: 'Kanji'),
+          Tab(text: 'Vocabulary'),
+          Tab(text: 'Custom SRS'),
+        ],
+      ),
+    );
+  }
+
+  AppBar _buildSelectionAppBar() {
+    return AppBar(
+      leading: IconButton(
+        icon: const Icon(Icons.close),
+        onPressed: () {
+          setState(() {
+            _isSelectionMode = false;
+            _selectedItems.clear();
+          });
+        },
+      ),
+      title: Text('${_selectedItems.length} selected'),
+      actions: [
+        IconButton(
+          icon: const Icon(Icons.select_all),
+          onPressed: _selectAll,
+        ),
+        IconButton(
+          icon: const Icon(Icons.delete),
+          onPressed: _deleteSelected,
+        ),
+        IconButton(
+          icon: Icon(_toggleIntervalIcon),
+          onPressed: _toggleIntervalForSelected,
+        ),
+      ],
+    );
+  }
+
+  IconData get _toggleIntervalIcon {
+    if (_selectedItems.isEmpty) {
+      return Icons.timer_off;
+    }
+    final bool willEnable = _selectedItems.any((item) => !item.useInterval);
+    return willEnable ? Icons.timer : Icons.timer_off;
+  }
+
+  void _selectAll() {
+    setState(() {
+      if (_selectedItems.length == _customDeck.length) {
+        _selectedItems.clear();
+      } else {
+        _selectedItems = List.from(_customDeck);
+      }
+    });
+  }
+
+  void _deleteSelected() {
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Delete Selected'),
+        content:
+            Text('Are you sure you want to delete ${_selectedItems.length} cards?'),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(),
+            child: const Text('Cancel'),
+          ),
+          TextButton(
+            onPressed: () async {
+              final navigator = Navigator.of(context);
+              for (final item in _selectedItems) {
+                await _customDeckRepository.deleteCard(item);
+              }
+              setState(() {
+                _isSelectionMode = false;
+                _selectedItems.clear();
+              });
+              await _loadCustomDeck();
+              if (!mounted) return;
+              navigator.pop();
+            },
+            child: const Text('Delete'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Future<void> _toggleIntervalForSelected() async {
+    if (_selectedItems.isEmpty) {
+      return;
+    }
+    final bool targetState = _selectedItems.any((item) => !item.useInterval);
+
+    final selectedCharacters =
+        _selectedItems.map((item) => item.characters).toSet();
+
+    final List<CustomKanjiItem> updatedItems = [];
+    for (final item in _selectedItems) {
+      final updatedItem = CustomKanjiItem(
+        characters: item.characters,
+        meaning: item.meaning,
+        kanji: item.kanji,
+        useInterval: targetState,
+        srsData: item.srsData,
+      );
+      updatedItems.add(updatedItem);
+    }
+
+    await _customDeckRepository.updateCards(updatedItems);
+    await _loadCustomDeck();
+
+    final newSelectedItems = _customDeck
+        .where((item) => selectedCharacters.contains(item.characters))
+        .toList();
+
+    setState(() {
+      _selectedItems = newSelectedItems;
+      if (_selectedItems.isEmpty) {
+        _isSelectionMode = false;
+      }
+    });
+  }
+
+  Widget _buildCustomGridView(List<CustomKanjiItem> items) {
+    return GridView.builder(
+      gridDelegate: const SliverGridDelegateWithMaxCrossAxisExtent(
+        maxCrossAxisExtent: 200,
+        childAspectRatio: 1.2,
+        crossAxisSpacing: 8,
+        mainAxisSpacing: 8,
+      ),
+      itemCount: items.length,
+      itemBuilder: (context, index) {
+        final item = items[index];
+        final isSelected = _selectedItems.contains(item);
+        return GestureDetector(
+          onLongPress: () {
+            setState(() {
+              _isSelectionMode = true;
+              _selectedItems.add(item);
+            });
+          },
+          onTap: () {
+            if (_isSelectionMode) {
+              setState(() {
+                if (isSelected) {
+                  _selectedItems.remove(item);
+                  if (_selectedItems.isEmpty) {
+                    _isSelectionMode = false;
+                  }
+                } else {
+                  _selectedItems.add(item);
+                }
+              });
+            } else {
+              Navigator.of(context)
+                  .push(
+                    MaterialPageRoute(
+                      builder: (_) => CustomCardDetailsScreen(
+                        item: item,
+                        repository: _customDeckRepository,
+                      ),
+                    ),
+                  )
+                  .then((_) => _loadCustomDeck());
+            }
+          },
+          child: Card(
+            shape: RoundedRectangleBorder(
+              side: isSelected
+                  ? const BorderSide(color: Colors.blue, width: 2.0)
+                  : BorderSide.none,
+              borderRadius: BorderRadius.circular(12.0),
+            ),
+            color: isSelected
+                ? Colors.blue.withAlpha((255 * 0.5).round())
+                : const Color(0xFF1E1E1E),
+            child: Stack(
+              children: [
+                Padding(
+                  padding: const EdgeInsets.all(8.0),
+                  child: Column(
+                    mainAxisAlignment: MainAxisAlignment.center,
+                    children: [
+                      FittedBox(
+                        fit: BoxFit.scaleDown,
+                        child: Text(
+                          item.kanji?.isNotEmpty == true
+                              ? item.kanji!
+                              : item.characters,
+                          style:
+                              const TextStyle(fontSize: 32, color: Colors.white),
+                          textAlign: TextAlign.center,
+                        ),
+                      ),
+                      const SizedBox(height: 8),
+                      Text(
+                        item.meaning,
+                        style:
+                            const TextStyle(color: Colors.grey, fontSize: 16),
+                        textAlign: TextAlign.center,
+                        overflow: TextOverflow.ellipsis,
+                      ),
+                      const SizedBox(height: 8),
+                      Builder(builder: (context) {
+                        final avgSrs = (item.srsData.japaneseToEnglish +
+                                item.srsData.englishToJapanese +
+                                item.srsData.listeningComprehension) /
+                            3;
+                        return _buildSrsIndicator(avgSrs.round());
+                      }),
+                    ],
+                  ),
+                ),
+                if (item.useInterval)
+                  Positioned(
+                    top: 4,
+                    right: 4,
+                    child: Icon(
+                      Icons.timer,
+                      color: Colors.green,
+                      size: 16,
+                    ),
+                  ),
+              ],
+            ),
+          ),
+        );
+      },
+      padding: const EdgeInsets.all(8),
+    );
   }
 }
+
+class _VocabDetailsDialog extends StatefulWidget {
+  final VocabularyItem vocab;
+
+  const _VocabDetailsDialog({required this.vocab});
+
+  @override
+  State<_VocabDetailsDialog> createState() => _VocabDetailsDialogState();
+}
+
+class _VocabDetailsDialogState extends State<_VocabDetailsDialog> {
+  List<Widget> _exampleSentences = [const CircularProgressIndicator()];
+
+  @override
+  void initState() {
+    super.initState();
+    _fetchExampleSentences();
+  }
+
+  Future<void> _fetchExampleSentences() async {
+    try {
+      final uri = Uri.parse(
+          'https://jisho.org/api/v1/search/words?keyword=${Uri.encodeComponent(widget.vocab.characters)}');
+      final response = await http.get(uri);
+      if (response.statusCode == 200) {
+        final data = jsonDecode(utf8.decode(response.bodyBytes));
+        final sentences = <Widget>[];
+        if (data['data'] != null && (data['data'] as List).isNotEmpty) {
+          for (final result in data['data']) {
+            if (result['japanese'] != null &&
+                (result['japanese'] as List).isNotEmpty &&
+                result['senses'] != null &&
+                (result['senses'] as List).isNotEmpty) {
+              final japaneseWord = result['japanese'][0]['word'] ?? result['japanese'][0]['reading'];
+              final englishDefinition = result['senses'][0]['english_definitions'].join(', ');
+              if (japaneseWord != null && englishDefinition != null) {
+                sentences.add(
+                  Column(
+                    crossAxisAlignment: CrossAxisAlignment.start,
+                    children: [
+                      Text(japaneseWord, style: const TextStyle(color: Colors.white)),
+                      Text(englishDefinition, style: const TextStyle(color: Colors.grey)),
+                      const SizedBox(height: 8),
+                    ],
+                  ),
+                );
+              }
+            }
+          }
+        }
+        if (sentences.isEmpty) {
+          sentences.add(const Text('No example sentences found.', style: TextStyle(color: Colors.white)));
+        }
+        if (mounted) {
+          setState(() {
+            _exampleSentences = sentences;
+          });
+        }
+      } else {
+        if (mounted) {
+          setState(() {
+            _exampleSentences = [
+              const Text('Failed to load example sentences.', style: TextStyle(color: Colors.red))
+            ];
+          });
+        }
+      }
+    } catch (e) {
+      if (mounted) {
+        setState(() {
+          _exampleSentences = [
+            const Text('Error loading example sentences.', style: TextStyle(color: Colors.red))
+          ];
+        });
+      }
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final srsScores = <String, int>{
+      'JP -> EN': 0,
+      'EN -> JP': 0,
+      'Audio': 0,
+    };
+
+    for (final entry in widget.vocab.srsItems.entries) {
+      final srsItem = entry.value;
+      switch (srsItem.quizMode) {
+        case VocabQuizMode.vocabToEnglish:
+          srsScores['JP -> EN'] = srsItem.srsStage;
+          break;
+        case VocabQuizMode.englishToVocab:
+          srsScores['EN -> JP'] = srsItem.srsStage;
+          break;
+        case VocabQuizMode.audioToEnglish:
+          srsScores['Audio'] = srsItem.srsStage;
+          break;
+      }
+    }
+
+    return SingleChildScrollView(
+      child: Column(
+        mainAxisSize: MainAxisSize.min,
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Text(
+            'Level: ${widget.vocab.level}',
+            style: const TextStyle(color: Colors.white),
+          ),
+          const SizedBox(height: 16),
+          if (widget.vocab.meanings.isNotEmpty)
+            Text(
+              'Meanings: ${widget.vocab.meanings.join(', ')}',
+              style: const TextStyle(color: Colors.white),
+            ),
+          const SizedBox(height: 16),
+          if (widget.vocab.readings.isNotEmpty)
+            Text(
+              'Readings: ${widget.vocab.readings.join(', ')}',
+              style: const TextStyle(color: Colors.white),
+            ),
+          const SizedBox(height: 16),
+          const Divider(color: Colors.grey),
+          const SizedBox(height: 16),
+          const Text(
+            'SRS Scores:',
+            style: TextStyle(color: Colors.white, fontWeight: FontWeight.bold),
+          ),
+          ...srsScores.entries.map((entry) => Text(
+                '  ${entry.key}: ${entry.value}',
+                style: const TextStyle(color: Colors.white),
+              )),
+          const SizedBox(height: 16),
+          const Divider(color: Colors.grey),
+          const SizedBox(height: 16),
+          const Text(
+            'Example Sentences:',
+            style: TextStyle(color: Colors.white, fontWeight: FontWeight.bold),
+          ),
+          ..._exampleSentences,
+        ],
+      ),
+    );
+  }
+}
+
+void _showVocabDetailsDialog(BuildContext context, VocabularyItem vocab) {
+  showDialog(
+    context: context,
+    builder: (context) {
+      return AlertDialog(
+        backgroundColor: const Color(0xFF1E1E1E),
+        title: Text(
+          'Details for ${vocab.characters}',
+          style: const TextStyle(color: Colors.white),
+        ),
+        content: _VocabDetailsDialog(vocab: vocab),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(),
+            child: const Text('Close', style: TextStyle(color: Colors.blueAccent)),
+          ),
+        ],
+      );
+    },
+  );
+}

lib/src/screens/custom_card_details_screen.dart

@@ -0,0 +1,128 @@
+import 'package:flutter/material.dart';
+import '../models/custom_kanji_item.dart';
+import '../services/custom_deck_repository.dart';
+
+class CustomCardDetailsScreen extends StatefulWidget {
+  final CustomKanjiItem item;
+  final CustomDeckRepository repository;
+
+  const CustomCardDetailsScreen(
+      {super.key, required this.item, required this.repository});
+
+  @override
+  State<CustomCardDetailsScreen> createState() =>
+      _CustomCardDetailsScreenState();
+}
+
+class _CustomCardDetailsScreenState extends State<CustomCardDetailsScreen> {
+  late TextEditingController _japaneseController;
+  late TextEditingController _englishController;
+  late TextEditingController _kanjiController;
+  late bool _useInterval;
+
+  @override
+  void initState() {
+    super.initState();
+    _japaneseController = TextEditingController(text: widget.item.characters);
+    _englishController = TextEditingController(text: widget.item.meaning);
+    _kanjiController = TextEditingController(text: widget.item.kanji);
+    _useInterval = widget.item.useInterval;
+  }
+
+  @override
+  void dispose() {
+    _japaneseController.dispose();
+    _englishController.dispose();
+    _kanjiController.dispose();
+    super.dispose();
+  }
+
+  void _saveChanges() {
+    final updatedItem = CustomKanjiItem(
+      characters: _japaneseController.text,
+      meaning: _englishController.text,
+      kanji: _kanjiController.text.trim().isNotEmpty ? _kanjiController.text.trim() : null,
+      useInterval: _useInterval,
+      srsData: widget.item.srsData,
+    );
+    widget.repository.updateCard(updatedItem);
+    Navigator.of(context).pop(true);
+  }
+
+  void _deleteCard() {
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Delete Card'),
+        content: const Text('Are you sure you want to delete this card?'),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(),
+            child: const Text('Cancel'),
+          ),
+          TextButton(
+            onPressed: () {
+              widget.repository.deleteCard(widget.item);
+              Navigator.of(context).pop();
+              Navigator.of(context).pop(true);
+            },
+            child: const Text('Delete'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('Edit Card'),
+        actions: [
+          IconButton(
+            icon: const Icon(Icons.delete),
+            onPressed: _deleteCard,
+          ),
+        ],
+      ),
+      body: Padding(
+        padding: const EdgeInsets.all(16.0),
+        child: Column(
+          children: [
+            TextFormField(
+              controller: _japaneseController,
+              decoration: const InputDecoration(labelText: 'Japanese (Kana)'),
+            ),
+            TextFormField(
+              controller: _kanjiController,
+              decoration: const InputDecoration(labelText: 'Japanese (Kanji)'),
+            ),
+            TextFormField(
+              controller: _englishController,
+              decoration: const InputDecoration(labelText: 'English'),
+            ),
+            SwitchListTile(
+              title: const Text('Use Interval SRS'),
+              value: _useInterval,
+              onChanged: (value) {
+                setState(() {
+                  _useInterval = value;
+                });
+              },
+            ),
+            const SizedBox(height: 20),
+            const Text('SRS Levels', style: TextStyle(fontWeight: FontWeight.bold)),
+            Text('Jpn→Eng: ${widget.item.srsData.japaneseToEnglish} (Next review: ${widget.item.srsData.japaneseToEnglishNextReview?.toString() ?? 'N/A'})'),
+            Text('Eng→Jpn: ${widget.item.srsData.englishToJapanese} (Next review: ${widget.item.srsData.englishToJapaneseNextReview?.toString() ?? 'N/A'})'),
+            Text('Listening: ${widget.item.srsData.listeningComprehension} (Next review: ${widget.item.srsData.listeningComprehensionNextReview?.toString() ?? 'N/A'})'),
+            const SizedBox(height: 20),
+            ElevatedButton(
+              onPressed: _saveChanges,
+              child: const Text('Save Changes'),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}

lib/src/screens/custom_quiz_screen.dart

@@ -0,0 +1,334 @@
+import 'package:flutter/material.dart';
+import 'dart:math';
+import 'package:flutter_tts/flutter_tts.dart';
+import '../models/custom_kanji_item.dart';
+import '../widgets/options_grid.dart';
+import '../widgets/kanji_card.dart';
+
+enum CustomQuizMode { japaneseToEnglish, englishToJapanese, listeningComprehension }
+
+class CustomQuizScreen extends StatefulWidget {
+  final List<CustomKanjiItem> deck;
+  final CustomQuizMode quizMode;
+  final Function(CustomKanjiItem) onCardReviewed;
+  final bool useKanji;
+  final bool isActive;
+
+  const CustomQuizScreen({
+    super.key,
+    required this.deck,
+    required this.quizMode,
+    required this.onCardReviewed,
+    required this.useKanji,
+    required this.isActive,
+  });
+
+  @override
+  State<CustomQuizScreen> createState() => CustomQuizScreenState();
+}
+
+class CustomQuizScreenState extends State<CustomQuizScreen>
+    with TickerProviderStateMixin {
+  int _currentIndex = 0;
+  List<CustomKanjiItem> _shuffledDeck = [];
+  List<String> _options = [];
+  bool _answered = false;
+  bool? _correct;
+  late FlutterTts _flutterTts;
+  late AnimationController _shakeController;
+  late Animation<double> _shakeAnimation;
+  final List<String> _incorrectlyAnsweredItems = [];
+
+  @override
+  void initState() {
+    super.initState();
+    _shuffledDeck = widget.deck.toList()..shuffle();
+    _initTts();
+    if (_shuffledDeck.isNotEmpty) {
+      _generateOptions();
+    }
+
+    _shakeController = AnimationController(
+      duration: const Duration(milliseconds: 500),
+      vsync: this,
+    );
+    _shakeAnimation = Tween<double>(begin: 0, end: 1).animate(
+      CurvedAnimation(
+        parent: _shakeController,
+        curve: Curves.elasticIn,
+      ),
+    );
+  }
+
+  @override
+  void didUpdateWidget(CustomQuizScreen oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (widget.deck != oldWidget.deck && !widget.isActive) {
+      setState(() {
+        _shuffledDeck = widget.deck.toList()..shuffle();
+        _currentIndex = 0;
+        _answered = false;
+        _correct = null;
+        if (_shuffledDeck.isNotEmpty) {
+          _generateOptions();
+        }
+      });
+    }
+    if (widget.useKanji != oldWidget.useKanji) {
+      setState(() {
+        _generateOptions();
+      });
+    }
+  }
+
+  void playAudio() {
+    if (widget.quizMode == CustomQuizMode.listeningComprehension && _currentIndex < _shuffledDeck.length) {
+      _speak(_shuffledDeck[_currentIndex].characters);
+    }
+  }
+
+  void _initTts() async {
+    _flutterTts = FlutterTts();
+    await _flutterTts.setLanguage("ja-JP");
+  }
+
+  @override
+  void dispose() {
+    _flutterTts.stop();
+    _shakeController.dispose();
+    super.dispose();
+  }
+
+  void _generateOptions() {
+    final currentItem = _shuffledDeck[_currentIndex];
+    if (widget.quizMode == CustomQuizMode.listeningComprehension || widget.quizMode == CustomQuizMode.japaneseToEnglish) {
+      _options = [currentItem.meaning];
+    } else {
+      _options = [widget.useKanji && currentItem.kanji != null ? currentItem.kanji! : currentItem.characters];
+    }
+    final otherItems = widget.deck
+        .where((item) => item.characters != currentItem.characters)
+        .toList();
+    otherItems.shuffle();
+    for (var i = 0; i < min(3, otherItems.length); i++) {
+      if (widget.quizMode == CustomQuizMode.listeningComprehension || widget.quizMode == CustomQuizMode.japaneseToEnglish) {
+        _options.add(otherItems[i].meaning);
+      } else {
+        _options.add(widget.useKanji && otherItems[i].kanji != null ? otherItems[i].kanji! : otherItems[i].characters);
+      }
+    }
+    _options.shuffle();
+  }
+
+  void _checkAnswer(String answer) async {
+    final currentItem = _shuffledDeck[_currentIndex];
+    final correctAnswer = (widget.quizMode == CustomQuizMode.englishToJapanese)
+        ? (widget.useKanji && currentItem.kanji != null ? currentItem.kanji! : currentItem.characters)
+        : currentItem.meaning;
+    final isCorrect = answer == correctAnswer;
+
+    if (currentItem.useInterval) {
+      int currentSrsLevel;
+      switch (widget.quizMode) {
+        case CustomQuizMode.japaneseToEnglish:
+          currentSrsLevel = currentItem.srsData.japaneseToEnglish;
+          break;
+        case CustomQuizMode.englishToJapanese:
+          currentSrsLevel = currentItem.srsData.englishToJapanese;
+          break;
+        case CustomQuizMode.listeningComprehension:
+          currentSrsLevel = currentItem.srsData.listeningComprehension;
+          break;
+      }
+
+      if (isCorrect) {
+        if (_incorrectlyAnsweredItems.contains(currentItem.characters)) {
+          _incorrectlyAnsweredItems.remove(currentItem.characters);
+        } else {
+          currentSrsLevel++;
+        }
+        final interval = pow(2, currentSrsLevel).toInt();
+        final newNextReview = DateTime.now().add(Duration(hours: interval));
+        switch (widget.quizMode) {
+          case CustomQuizMode.japaneseToEnglish:
+            currentItem.srsData.japaneseToEnglishNextReview = newNextReview;
+            break;
+          case CustomQuizMode.englishToJapanese:
+            currentItem.srsData.englishToJapaneseNextReview = newNextReview;
+            break;
+          case CustomQuizMode.listeningComprehension:
+            currentItem.srsData.listeningComprehensionNextReview = newNextReview;
+            break;
+        }
+      } else {
+        if (!_incorrectlyAnsweredItems.contains(currentItem.characters)) {
+          _incorrectlyAnsweredItems.add(currentItem.characters);
+        }
+        currentSrsLevel = max(0, currentSrsLevel - 1);
+        final newNextReview = DateTime.now().add(const Duration(hours: 1));
+        switch (widget.quizMode) {
+          case CustomQuizMode.japaneseToEnglish:
+            currentItem.srsData.japaneseToEnglishNextReview = newNextReview;
+            break;
+          case CustomQuizMode.englishToJapanese:
+            currentItem.srsData.englishToJapaneseNextReview = newNextReview;
+            break;
+          case CustomQuizMode.listeningComprehension:
+            currentItem.srsData.listeningComprehensionNextReview = newNextReview;
+            break;
+        }
+      }
+
+      switch (widget.quizMode) {
+        case CustomQuizMode.japaneseToEnglish:
+          currentItem.srsData.japaneseToEnglish = currentSrsLevel;
+          break;
+        case CustomQuizMode.englishToJapanese:
+          currentItem.srsData.englishToJapanese = currentSrsLevel;
+          break;
+        case CustomQuizMode.listeningComprehension:
+          currentItem.srsData.listeningComprehension = currentSrsLevel;
+          break;
+      }
+
+      widget.onCardReviewed(currentItem);
+    }
+
+    // --- SnackBar Logic (new) ---
+    final correctDisplay = (widget.quizMode == CustomQuizMode.englishToJapanese)
+        ? (widget.useKanji && currentItem.kanji != null ? currentItem.kanji! : currentItem.characters)
+        : currentItem.meaning;
+
+    final snack = SnackBar(
+      content: Text(
+        isCorrect ? 'Correct!' : 'Wrong — correct: $correctDisplay',
+        style: TextStyle(
+          color: isCorrect ? Colors.greenAccent : Colors.redAccent,
+          fontWeight: FontWeight.bold,
+        ),
+      ),
+      backgroundColor: const Color(0xFF222222),
+      duration: const Duration(milliseconds: 900),
+    );
+    if (mounted) {
+      ScaffoldMessenger.of(context).showSnackBar(snack);
+    }
+    // --- End SnackBar Logic ---
+
+    if (isCorrect) {
+      if (widget.quizMode == CustomQuizMode.japaneseToEnglish) {
+        await _speak(currentItem.characters);
+      }
+      await Future.delayed(const Duration(milliseconds: 500)); // Small delay after correct answer
+    } else {
+      _shakeController.forward(from: 0);
+      await Future.delayed(const Duration(milliseconds: 900)); // Delay for shake animation
+    }
+
+    _nextQuestion();
+  }
+
+  void _nextQuestion() {
+    setState(() {
+      _currentIndex++;
+      _answered = false;
+      _correct = null;
+      if (_currentIndex < _shuffledDeck.length) {
+        _generateOptions();
+        if (widget.quizMode == CustomQuizMode.listeningComprehension) {
+          _speak(_shuffledDeck[_currentIndex].characters);
+        }
+      }
+    });
+  }
+
+  Future<void> _speak(String text) async {
+    await _flutterTts.speak(text);
+  }
+
+  void _onOptionSelected(String option) {
+    if (!(_answered && _correct!)) {
+      _checkAnswer(option);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    if (_shuffledDeck.isEmpty || _currentIndex >= _shuffledDeck.length) {
+      return const Center(
+        child: Text('Review session complete!'),
+      );
+    }
+
+    final currentItem = _shuffledDeck[_currentIndex];
+    final question = (widget.quizMode == CustomQuizMode.englishToJapanese)
+        ? currentItem.meaning
+        : (widget.useKanji && currentItem.kanji != null ? currentItem.kanji! : currentItem.characters);
+
+    Widget promptWidget;
+    if (widget.quizMode == CustomQuizMode.listeningComprehension) {
+      promptWidget = IconButton(
+        icon: const Icon(Icons.volume_up, size: 64),
+        onPressed: () => _speak(currentItem.characters),
+      );
+    } else {
+      promptWidget = GestureDetector(
+        onTap: () => _speak(question),
+        child: Text(
+          question,
+          style: const TextStyle(fontSize: 48),
+          textAlign: TextAlign.center,
+        ),
+      );
+    }
+
+    return Padding(
+      padding: const EdgeInsets.all(16.0),
+      child: Column(
+        children: [
+          const SizedBox(height: 18),
+          Expanded(
+            flex: 3,
+            child: Center(
+              child: ConstrainedBox(
+                constraints: const BoxConstraints(
+                  minWidth: 0,
+                  maxWidth: 500,
+                  minHeight: 150,
+                ),
+                child: KanjiCard(
+                  characterWidget: promptWidget,
+                  subtitle: '',
+                ),
+              ),
+            ),
+          ),
+          const SizedBox(height: 12),
+          SafeArea(
+            top: false,
+            child: Column(
+              children: [
+                AnimatedBuilder(
+                  animation: _shakeAnimation,
+                  builder: (context, child) {
+                    return Transform.translate(
+                      offset: Offset(_shakeAnimation.value * 10, 0),
+                      child: child,
+                    );
+                  },
+                  child: OptionsGrid(
+                    options: _options,
+                    onSelected: _onOptionSelected,
+                    correctAnswers: [],
+                    showResult: false,
+                    isDisabled: false,
+                  ),
+                ),
+              ],
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}

lib/src/screens/custom_srs_screen.dart

@@ -0,0 +1,149 @@
+import 'package:flutter/material.dart';
+import '../models/custom_kanji_item.dart';
+import '../services/custom_deck_repository.dart';
+import 'custom_quiz_screen.dart';
+
+class CustomSrsScreen extends StatefulWidget {
+  const CustomSrsScreen({super.key});
+
+  @override
+  State<CustomSrsScreen> createState() => _CustomSrsScreenState();
+}
+
+class _CustomSrsScreenState extends State<CustomSrsScreen> with SingleTickerProviderStateMixin {
+  late TabController _tabController;
+  final _deckRepository = CustomDeckRepository();
+  List<CustomKanjiItem> _deck = [];
+  bool _useKanji = false;
+  final _quizScreenKeys = [
+    GlobalKey<CustomQuizScreenState>(),
+    GlobalKey<CustomQuizScreenState>(),
+    GlobalKey<CustomQuizScreenState>(),
+  ];
+
+  @override
+  void initState() {
+    super.initState();
+    _tabController = TabController(length: 3, vsync: this);
+    _tabController.addListener(() {
+      if (_tabController.indexIsChanging) {
+        final key = _quizScreenKeys[_tabController.index];
+        key.currentState?.playAudio();
+      }
+      setState(() {});
+    });
+    _loadDeck();
+  }
+
+  @override
+  void dispose() {
+    _tabController.dispose();
+    super.dispose();
+  }
+
+  Future<void> _loadDeck() async {
+    final deck = await _deckRepository.getCustomDeck();
+    setState(() {
+      _deck = deck;
+    });
+  }
+
+  Future<void> _updateCard(CustomKanjiItem item) async {
+    final index = _deck.indexWhere((element) => element.characters == item.characters);
+    if (index != -1) {
+      setState(() {
+        _deck[index] = item;
+      });
+      await _deckRepository.saveDeck(_deck);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final now = DateTime.now();
+    final jpnToEngReviewDeck = _deck.where((item) {
+      if (!item.useInterval) return true;
+      return item.srsData.japaneseToEnglishNextReview == null ||
+          item.srsData.japaneseToEnglishNextReview!.isBefore(now);
+    }).toList();
+
+    final engToJpnReviewDeck = _deck.where((item) {
+      if (!item.useInterval) return true;
+      return item.srsData.englishToJapaneseNextReview == null ||
+          item.srsData.englishToJapaneseNextReview!.isBefore(now);
+    }).toList();
+
+    final listeningReviewDeck = _deck.where((item) {
+      if (!item.useInterval) return true;
+      return item.srsData.listeningComprehensionNextReview == null ||
+          item.srsData.listeningComprehensionNextReview!.isBefore(now);
+    }).toList();
+
+    final allDecksEmpty = jpnToEngReviewDeck.isEmpty &&
+        engToJpnReviewDeck.isEmpty &&
+        listeningReviewDeck.isEmpty;
+
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('Custom SRS'),
+        actions: [
+          if (_tabController.index != 2)
+            Row(
+              children: [
+                const Text('Kanji'),
+                Switch(
+                  value: _useKanji,
+                  onChanged: (value) {
+                    setState(() {
+                      _useKanji = value;
+                    });
+                  },
+                ),
+              ],
+            ),
+        ],
+        bottom: TabBar(
+          controller: _tabController,
+          tabs: const [
+            Tab(text: 'Jpn→Eng'),
+            Tab(text: 'Eng→Jpn'),
+            Tab(text: 'Listening'),
+          ],
+        ),
+      ),
+      body: _deck.isEmpty
+          ? const Center(child: Text('Add cards to start quizzing!'))
+          : allDecksEmpty
+              ? const Center(child: Text('No cards due for review.'))
+              : TabBarView(
+              controller: _tabController,
+              children: [
+                CustomQuizScreen(
+                  key: _quizScreenKeys[0],
+                  deck: jpnToEngReviewDeck,
+                  quizMode: CustomQuizMode.japaneseToEnglish,
+                  onCardReviewed: _updateCard,
+                  useKanji: _useKanji,
+                  isActive: _tabController.index == 0,
+                ),
+                CustomQuizScreen(
+                  key: _quizScreenKeys[1],
+                  deck: engToJpnReviewDeck,
+                  quizMode: CustomQuizMode.englishToJapanese,
+                  onCardReviewed: _updateCard,
+                  useKanji: _useKanji,
+                  isActive: _tabController.index == 1,
+                ),
+                CustomQuizScreen(
+                  key: _quizScreenKeys[2],
+                  deck: listeningReviewDeck,
+                  quizMode: CustomQuizMode.listeningComprehension,
+                  onCardReviewed: _updateCard,
+                  useKanji: _useKanji,
+                  isActive: _tabController.index == 2,
+                ),
+              ],
+            ),
+    );
+  }
+}

lib/src/screens/home_screen.dart

@@ -18,6 +18,18 @@ class _ReadingInfo {
   _ReadingInfo(this.correctReadings, this.hint);
 }
 
+class _QuizState {
+  KanjiItem? current;
+  List<String> options = [];
+  List<String> correctAnswers = [];
+  String readingHint = '';
+  int score = 0;
+  int asked = 0;
+  Key key = UniqueKey();
+  String? selectedOption;
+  bool showResult = false;
+}
+
 class HomeScreen extends StatefulWidget {
   const HomeScreen({super.key, this.distractorGenerator});
 
@@ -27,31 +39,43 @@ class HomeScreen extends StatefulWidget {
   State<HomeScreen> createState() => _HomeScreenState();
 }
 
-class _HomeScreenState extends State<HomeScreen> {
+class _HomeScreenState extends State<HomeScreen> with SingleTickerProviderStateMixin {
+  late TabController _tabController;
   List<KanjiItem> _deck = [];
   bool _loading = false;
+  bool _isAnswering = false;
   String _status = 'Loading deck...';
   late final DistractorGenerator _dg;
   final Random _random = Random();
   final _audioPlayer = AudioPlayer();
 
-  QuizMode _mode = QuizMode.kanjiToEnglish;
+  final _quizStates = [_QuizState(), _QuizState(), _QuizState()];
-  KanjiItem? _current;
+  _QuizState get _currentQuizState => _quizStates[_tabController.index];
-  List<String> _options = [];
+
-  List<String> _correctAnswers = [];
-  String _readingHint = '';
-  int _score = 0;
-  int _asked = 0;
   bool _playCorrectSound = true;
+  bool _apiKeyMissing = false;
 
   @override
   void initState() {
     super.initState();
+    _tabController = TabController(length: 3, vsync: this);
+    _tabController.addListener(() {
+      if (_tabController.indexIsChanging) {
+        _nextQuestion();
+      }
+      setState(() {});
+    });
     _dg = widget.distractorGenerator ?? DistractorGenerator();
     _loadSettings();
     _loadDeck();
   }
 
+  @override
+  void dispose() {
+    _tabController.dispose();
+    super.dispose();
+  }
+
   Future<void> _loadSettings() async {
     final prefs = await SharedPreferences.getInstance();
     setState(() {
@@ -71,11 +95,10 @@ class _HomeScreenState extends State<HomeScreen> {
       final apiKey = repo.apiKey;
 
       if (apiKey == null || apiKey.isEmpty) {
-        if (mounted) {
+        setState(() {
-          Navigator.of(context).pushReplacement(
+          _apiKeyMissing = true;
-            MaterialPageRoute(builder: (_) => const SettingsScreen()),
+          _loading = false;
-          );
+        });
-        }
         return;
       }
 
@@ -91,9 +114,12 @@ class _HomeScreenState extends State<HomeScreen> {
         _deck = items;
         _status = 'Loaded ${items.length} kanji';
         _loading = false;
+        _apiKeyMissing = false;
       });
 
-      _nextQuestion();
+      for (var i = 0; i < _tabController.length; i++) {
+        _nextQuestion(i);
+      }
     } catch (e) {
       setState(() {
         _status = 'Error: $e';
@@ -123,117 +149,157 @@ class _HomeScreenState extends State<HomeScreen> {
     return _ReadingInfo(readingsList, hint);
   }
 
-  void _nextQuestion() {
+  QuizMode _modeForIndex(int index) {
+    switch (index) {
+      case 0:
+        return QuizMode.kanjiToEnglish;
+      case 1:
+        return QuizMode.englishToKanji;
+      case 2:
+        return QuizMode.reading;
+      default:
+        return QuizMode.kanjiToEnglish;
+    }
+  }
+
+  void _nextQuestion([int? index]) {
     if (_deck.isEmpty) return;
 
+    final quizState = _quizStates[index ?? _tabController.index];
+    final mode = _modeForIndex(index ?? _tabController.index);
+
     _deck.sort((a, b) {
-      String srsKey(KanjiItem item) {
+      int getSrsStage(KanjiItem item) {
-        var key = _mode.toString();
+        if (mode == QuizMode.reading) {
-        if (_mode == QuizMode.reading) {
+          final onyomiStage = item.srsItems['${QuizMode.reading}onyomi']?.srsStage;
-          if (item.onyomi.isNotEmpty && item.kunyomi.isNotEmpty) {
+          final kunyomiStage = item.srsItems['${QuizMode.reading}kunyomi']?.srsStage;
-            key += _random.nextBool() ? 'onyomi' : 'kunyomi';
+
-          } else if (item.onyomi.isNotEmpty) {
+          if (onyomiStage != null && kunyomiStage != null) {
-            key += 'onyomi';
+            return min(onyomiStage, kunyomiStage);
-          } else {
-            key += 'kunyomi';
           }
+          return onyomiStage ?? kunyomiStage ?? 0;
         }
-        return key;
+        return item.srsItems[mode.toString()]?.srsStage ?? 0;
       }
 
-      final aSrsItem = a.srsItems[srsKey(a)];
+      DateTime getLastAsked(KanjiItem item) {
-      final bSrsItem = b.srsItems[srsKey(b)];
+        if (mode == QuizMode.reading) {
+          final onyomiLastAsked = item.srsItems['${QuizMode.reading}onyomi']?.lastAsked;
+          final kunyomiLastAsked = item.srsItems['${QuizMode.reading}kunyomi']?.lastAsked;
 
-      final aStage = aSrsItem?.srsStage ?? 0;
+          if (onyomiLastAsked != null && kunyomiLastAsked != null) {
-      final bStage = bSrsItem?.srsStage ?? 0;
+            return onyomiLastAsked.isBefore(kunyomiLastAsked)
+                ? onyomiLastAsked
+                : kunyomiLastAsked;
+          }
+          return onyomiLastAsked ??
+              kunyomiLastAsked ??
+              DateTime.fromMillisecondsSinceEpoch(0);
+        }
+        return item.srsItems[mode.toString()]?.lastAsked ??
+            DateTime.fromMillisecondsSinceEpoch(0);
+      }
+
+      final aStage = getSrsStage(a);
+      final bStage = getSrsStage(b);
 
       if (aStage != bStage) {
         return aStage.compareTo(bStage);
       }
 
-      final aLastAsked =
+      final aLastAsked = getLastAsked(a);
-          aSrsItem?.lastAsked ?? DateTime.fromMillisecondsSinceEpoch(0);
+      final bLastAsked = getLastAsked(b);
-      final bLastAsked =
-          bSrsItem?.lastAsked ?? DateTime.fromMillisecondsSinceEpoch(0);
 
-      if (aLastAsked != bLastAsked) {
       return aLastAsked.compareTo(bLastAsked);
-      }
-
-      return _random.nextDouble().compareTo(_random.nextDouble());
     });
 
-    _current = _deck.first;
+    quizState.current = _deck.first;
+    quizState.key = UniqueKey();
 
-    _correctAnswers = [];
+    quizState.correctAnswers = [];
-    _options = [];
+    quizState.options = [];
-    _readingHint = '';
+    quizState.readingHint = '';
+    quizState.selectedOption = null;
+    quizState.showResult = false;
 
-    switch (_mode) {
+    switch (mode) {
       case QuizMode.kanjiToEnglish:
-        _correctAnswers = [_current!.meanings.first];
+        quizState.correctAnswers = [quizState.current!.meanings.first];
-        _options = [
+        quizState.options = [
-          _correctAnswers.first,
+          quizState.correctAnswers.first,
-          ..._dg.generateMeanings(_current!, _deck, 3)
+          ..._dg.generateMeanings(quizState.current!, _deck, 3)
         ].map(_toTitleCase).toList()
           ..shuffle();
         break;
 
       case QuizMode.englishToKanji:
-        _correctAnswers = [_current!.characters];
+        quizState.correctAnswers = [quizState.current!.characters];
-        _options = [
+        quizState.options = [
-          _correctAnswers.first,
+          quizState.correctAnswers.first,
-          ..._dg.generateKanji(_current!, _deck, 3)
+          ..._dg.generateKanji(quizState.current!, _deck, 3)
         ]..shuffle();
         break;
 
       case QuizMode.reading:
-        final info = _pickReading(_current!);
+        final info = _pickReading(quizState.current!);
-        _correctAnswers = info.correctReadings;
+        quizState.correctAnswers = info.correctReadings;
-        _readingHint = info.hint;
+        quizState.readingHint = info.hint;
 
-        final readingsSource = _readingHint.contains("on'yomi")
+        final readingsSource = quizState.readingHint.contains("on'yomi")
             ? _deck.expand((k) => k.onyomi)
             : _deck.expand((k) => k.kunyomi);
 
         final distractors = readingsSource
-            .where((r) => !_correctAnswers.contains(r))
+            .where((r) => !quizState.correctAnswers.contains(r))
             .toSet()
             .toList()
               ..shuffle();
-        _options = ([
+        quizState.options = ([
-          _correctAnswers[_random.nextInt(_correctAnswers.length)],
+          quizState.correctAnswers[_random.nextInt(quizState.correctAnswers.length)],
           ...distractors.take(3)
         ])
           ..shuffle();
         break;
     }
 
-    setState(() {});
+    setState(() {
+      _isAnswering = false;
+    });
   }
 
   void _answer(String option) async {
-    final isCorrect = _correctAnswers
+    final quizState = _currentQuizState;
+    final mode = _modeForIndex(_tabController.index);
+    final isCorrect = quizState.correctAnswers
         .map((a) => a.toLowerCase().trim())
         .contains(option.toLowerCase().trim());
 
     final repo = Provider.of<DeckRepository>(context, listen: false);
-    final current = _current!;
+    final current = quizState.current!;
 
     String readingType = '';
-    if (_mode == QuizMode.reading) {
+    if (mode == QuizMode.reading) {
-      readingType = _readingHint.contains("on'yomi") ? 'onyomi' : 'kunyomi';
+      readingType = quizState.readingHint.contains("on'yomi") ? 'onyomi' : 'kunyomi';
     }
-    final srsKey = _mode.toString() + readingType;
+    final srsKey = mode.toString() + readingType;
 
     var srsItem = current.srsItems[srsKey];
     final isNew = srsItem == null;
     final srsItemForUpdate = srsItem ??=
-        SrsItem(kanjiId: current.id, quizMode: _mode, readingType: readingType);
+        SrsItem(kanjiId: current.id, quizMode: mode, readingType: readingType);
-    setState(() {
+    
-      _asked += 1;
+        quizState.asked += 1;
+    
+        quizState.selectedOption = option;
+    
+        quizState.showResult = true;
+    
+        setState(() {}); // Trigger UI rebuild to show selected/correct colors
+    
+    
+    
         if (isCorrect) {
-        _score += 1;
+      quizState.score += 1;
       srsItemForUpdate.srsStage += 1;
       if (_playCorrectSound) {
         _audioPlayer.play(AssetSource('sfx/confirm.mp3'));
@@ -243,7 +309,6 @@ class _HomeScreenState extends State<HomeScreen> {
     }
     srsItemForUpdate.lastAsked = DateTime.now();
     current.srsItems[srsKey] = srsItemForUpdate;
-    });
 
     if (isNew) {
       await repo.insertSrsItem(srsItemForUpdate);
@@ -251,11 +316,11 @@ class _HomeScreenState extends State<HomeScreen> {
       await repo.updateSrsItem(srsItemForUpdate);
     }
 
-    final correctDisplay = (_mode == QuizMode.kanjiToEnglish)
+    final correctDisplay = (mode == QuizMode.kanjiToEnglish)
-        ? _toTitleCase(_correctAnswers.first)
+        ? _toTitleCase(quizState.correctAnswers.first)
-        : (_mode == QuizMode.reading
+        : (mode == QuizMode.reading
-            ? _correctAnswers.join(', ')
+            ? quizState.correctAnswers.join(', ')
-            : _correctAnswers.first);
+            : quizState.correctAnswers.first);
 
     final snack = SnackBar(
       content: Text(
@@ -272,47 +337,87 @@ class _HomeScreenState extends State<HomeScreen> {
       ScaffoldMessenger.of(context).showSnackBar(snack);
     }
 
-    Future.delayed(const Duration(milliseconds: 900), _nextQuestion);
+    setState(() {
+      _isAnswering = true; // Disable input after showing result
+    });
+
+    Future.delayed(const Duration(milliseconds: 900), () => _nextQuestion());
   }
 
   @override
   Widget build(BuildContext context) {
-    String prompt = '';
+    if (_apiKeyMissing) {
-    String subtitle = '';
-
-    switch (_mode) {
-      case QuizMode.kanjiToEnglish:
-        prompt = _current?.characters ?? '';
-        break;
-      case QuizMode.englishToKanji:
-        prompt = _current != null ? _toTitleCase(_current!.meanings.first) : '';
-        break;
-      case QuizMode.reading:
-        prompt = _current?.characters ?? '';
-        subtitle = _readingHint;
-        break;
-    }
-
       return Scaffold(
-      backgroundColor: const Color(0xFF121212),
+        appBar: AppBar(title: const Text('Kanji Quiz')),
-      appBar: AppBar(
+        body: Center(
-        title: const Text('Hirameki SRS - Kanji'),
+          child: Column(
-        backgroundColor: const Color(0xFF1F1F1F),
+            mainAxisAlignment: MainAxisAlignment.center,
-        foregroundColor: Colors.white,
+            children: [
-        elevation: 2,
+              const Text('WaniKani API key is not set.', style: TextStyle(color: Colors.white)),
-        actions: [
+              const SizedBox(height: 16),
-          IconButton(
+              ElevatedButton(
-            icon: const Icon(Icons.settings),
                 onPressed: () async {
                   await Navigator.of(context).push(
                     MaterialPageRoute(builder: (_) => const SettingsScreen()),
                   );
-              _loadSettings();
+                  _loadDeck();
                 },
-          )
+                child: const Text('Go to Settings'),
+              ),
             ],
           ),
-      body: Padding(
+        ),
+      );
+    }
+
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('Kanji Quiz'),
+        bottom: TabBar(
+          controller: _tabController,
+          tabs: const [
+            Tab(text: 'Kanji→English'),
+            Tab(text: 'English→Kanji'),
+            Tab(text: 'Reading'),
+          ],
+        ),
+      ),
+      backgroundColor: const Color(0xFF121212),
+      body: TabBarView(
+        controller: _tabController,
+        children: [
+          _buildQuizPage(0),
+          _buildQuizPage(1),
+          _buildQuizPage(2),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildQuizPage(int index) {
+    final quizState = _quizStates[index];
+    final mode = _modeForIndex(index);
+
+    String prompt = '';
+    String subtitle = '';
+
+    if (quizState.current != null) {
+      switch (mode) {
+        case QuizMode.kanjiToEnglish:
+          prompt = quizState.current!.characters;
+          break;
+        case QuizMode.englishToKanji:
+          prompt = _toTitleCase(quizState.current!.meanings.first);
+          break;
+        case QuizMode.reading:
+          prompt = quizState.current!.characters;
+          subtitle = quizState.readingHint;
+          break;
+      }
+    }
+
+    return Padding(
+      key: quizState.key,
       padding: const EdgeInsets.all(16.0),
       child: Column(
         children: [
@@ -328,17 +433,6 @@ class _HomeScreenState extends State<HomeScreen> {
                 const CircularProgressIndicator(color: Colors.blueAccent),
             ],
           ),
-            const SizedBox(height: 12),
-            Wrap(
-              spacing: 6,
-              runSpacing: 4,
-              alignment: WrapAlignment.center,
-              children: [
-                _buildChoiceChip('Kanji→English', QuizMode.kanjiToEnglish),
-                _buildChoiceChip('English→Kanji', QuizMode.englishToKanji),
-                _buildChoiceChip('Reading', QuizMode.reading),
-              ],
-            ),
           const SizedBox(height: 18),
           Expanded(
             flex: 3,
@@ -364,14 +458,16 @@ class _HomeScreenState extends State<HomeScreen> {
             child: Column(
               children: [
                 OptionsGrid(
-                    options: _options,
+                  options: quizState.options,
-                    onSelected: _answer,
+                  onSelected: _isAnswering ? (option) {} : _answer,
-                    buttonColor: const Color(0xFF1E1E1E),
+                  isDisabled: false,
-                    textColor: Colors.white,
+                  selectedOption: null,
+                  correctAnswers: [],
+                  showResult: false,
                 ),
                 const SizedBox(height: 8),
                 Text(
-                    'Score: $_score / $_asked',
+                  'Score: ${quizState.score} / ${quizState.asked}',
                   style: const TextStyle(color: Colors.white),
                 ),
               ],
@@ -379,24 +475,6 @@ class _HomeScreenState extends State<HomeScreen> {
           ),
         ],
       ),
-      ),
-    );
-  }
-
-  ChoiceChip _buildChoiceChip(String label, QuizMode mode) {
-    final selected = _mode == mode;
-    return ChoiceChip(
-      label: Text(
-        label,
-        style: TextStyle(color: selected ? Colors.white : Colors.grey[400]),
-      ),
-      selected: selected,
-      onSelected: (v) {
-        setState(() => _mode = mode);
-        _nextQuestion();
-      },
-      selectedColor: Colors.blueAccent,
-      backgroundColor: const Color(0xFF1E1E1E),
     );
   }
 }

lib/src/screens/start_screen.dart

@@ -1,133 +1,128 @@
 import 'package:flutter/material.dart';
-import 'package:provider/provider.dart';
+import 'package:hirameki_srs/src/screens/settings_screen.dart';
-import '../services/deck_repository.dart';
 import 'browse_screen.dart';
 import 'home_screen.dart';
 import 'vocab_screen.dart';
+import 'custom_srs_screen.dart';
 
-class StartScreen extends StatefulWidget {
+class StartScreen extends StatelessWidget {
   const StartScreen({super.key});
 
-  @override
-  State<StartScreen> createState() => _StartScreenState();
-}
-
-class _StartScreenState extends State<StartScreen> {
-  bool _loading = true;
-  bool _hasApiKey = false;
-
-  @override
-  void initState() {
-    super.initState();
-    _checkApiKey();
-  }
-
-  Future<void> _checkApiKey() async {
-    final repo = Provider.of<DeckRepository>(context, listen: false);
-    await repo.loadApiKey();
-
-    setState(() {
-      _hasApiKey = repo.apiKey != null && repo.apiKey!.isNotEmpty;
-      _loading = false;
-    });
-  }
-
   @override
   Widget build(BuildContext context) {
-    if (_loading) {
-      return const Scaffold(
-        backgroundColor: Color(0xFF121212),
-        body: Center(
-          child: CircularProgressIndicator(color: Colors.blueAccent),
-        ),
-      );
-    }
-
     return Scaffold(
-      backgroundColor: const Color(0xFF121212),
+      appBar: AppBar(
-      body: Center(
+        title: const Text('Hirameki SRS'),
-        child: Padding(
+        actions: [
-          padding: const EdgeInsets.all(32),
+          IconButton(
-          child: Column(
+            icon: const Icon(Icons.settings),
-            mainAxisAlignment: MainAxisAlignment.center,
-            children: [
-              Text(
-                'Welcome to Hirameki SRS!',
-                style: Theme.of(context)
-                    .textTheme
-                    .headlineMedium
-                    ?.copyWith(fontSize: 28, color: Colors.white),
-                textAlign: TextAlign.center,
-              ),
-              const SizedBox(height: 16),
-              Text(
-                _hasApiKey
-                    ? 'Your API key is set. You can start the quiz!'
-                    : 'Before you start, please set up your WaniKani API key in the settings.',
-                style: Theme.of(context)
-                    .textTheme
-                    .bodyMedium
-                    ?.copyWith(color: Colors.grey[300]),
-                textAlign: TextAlign.center,
-              ),
-              const SizedBox(height: 32),
-              ElevatedButton(
             onPressed: () {
               Navigator.of(context).push(
-                    MaterialPageRoute(builder: (_) => HomeScreen()),
+                MaterialPageRoute(builder: (_) => const SettingsScreen()),
               );
             },
-                style: ElevatedButton.styleFrom(
-                  backgroundColor: Colors.blueAccent,
-                  foregroundColor: Colors.white,
-                  padding:
-                      const EdgeInsets.symmetric(horizontal: 32, vertical: 16),
-                  shape: RoundedRectangleBorder(
-                      borderRadius: BorderRadius.circular(12)),
           ),
-                child: const Text(
+        ],
-                  'Kanji Quiz',
+      ),
-                  style: TextStyle(fontSize: 18),
+      body: Container(
+        decoration: BoxDecoration(
+          gradient: LinearGradient(
+            colors: [
+              const Color(0xFF121212),
+              Colors.grey[900]!,
+            ],
+            begin: Alignment.topLeft,
+            end: Alignment.bottomRight,
           ),
         ),
-              const SizedBox(height: 16),
+        child: GridView.count(
-              ElevatedButton(
+          crossAxisCount: 2,
-                onPressed: () {
+          padding: const EdgeInsets.all(16),
+          crossAxisSpacing: 16,
+          mainAxisSpacing: 16,
+          childAspectRatio: 0.8,
+          children: [
+            _buildModeCard(
+              context,
+              title: 'Kanji Quiz',
+              icon: Icons.extension,
+              description: 'Test your knowledge of kanji characters.',
+              onTap: () {
+                Navigator.of(context).push(
+                  MaterialPageRoute(builder: (_) => const HomeScreen()),
+                );
+              },
+            ),
+            _buildModeCard(
+              context,
+              title: 'Vocabulary Quiz',
+              icon: Icons.school,
+              description: 'Practice vocabulary from your WaniKani deck.',
+              onTap: () {
                 Navigator.of(context).push(
                   MaterialPageRoute(builder: (_) => const VocabScreen()),
                 );
               },
-                style: ElevatedButton.styleFrom(
-                  backgroundColor: Colors.blueAccent,
-                  foregroundColor: Colors.white,
-                  padding:
-                      const EdgeInsets.symmetric(horizontal: 32, vertical: 16),
-                  shape: RoundedRectangleBorder(
-                      borderRadius: BorderRadius.circular(12)),
             ),
-                child: const Text(
+            _buildModeCard(
-                  'Vocabulary Quiz',
+              context,
-                  style: TextStyle(fontSize: 18),
+              title: 'Browse Items',
-                ),
+              icon: Icons.grid_view,
-              ),
+              description: 'Look through your kanji and vocabulary decks.',
-              const SizedBox(height: 16),
+              onTap: () {
-              ElevatedButton(
-                onPressed: () {
                 Navigator.of(context).push(
                   MaterialPageRoute(builder: (_) => const BrowseScreen()),
                 );
               },
-                style: ElevatedButton.styleFrom(
-                  backgroundColor: Colors.deepPurpleAccent,
-                  foregroundColor: Colors.white,
-                  padding:
-                      const EdgeInsets.symmetric(horizontal: 32, vertical: 16),
-                  shape: RoundedRectangleBorder(
-                      borderRadius: BorderRadius.circular(12)),
             ),
-                child: const Text(
+            _buildModeCard(
-                  'Browse Items',
+              context,
-                  style: TextStyle(fontSize: 18),
+              title: 'Custom SRS',
+              icon: Icons.create,
+              description: 'Create and study your own custom flashcards.',
+              onTap: () {
+                Navigator.of(context).push(
+                  MaterialPageRoute(builder: (_) => const CustomSrsScreen()),
+                );
+              },
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildModeCard(BuildContext context, {
+    required String title,
+    required IconData icon,
+    required String description,
+    required VoidCallback onTap,
+  }) {
+    return Card(
+      elevation: 4,
+      shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(12)),
+      child: InkWell(
+        onTap: onTap,
+        borderRadius: BorderRadius.circular(12),
+        child: Padding(
+          padding: const EdgeInsets.all(16.0),
+          child: Column(
+            mainAxisAlignment: MainAxisAlignment.center,
+            children: [
+              Icon(icon, size: 48, color: Theme.of(context).colorScheme.primary),
+              const SizedBox(height: 16),
+              Text(
+                title,
+                style: const TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
+                textAlign: TextAlign.center,
+              ),
+              const SizedBox(height: 8),
+              Expanded(
+                child: Text(
+                  description,
+                  style: const TextStyle(fontSize: 12, color: Colors.grey),
+                  textAlign: TextAlign.center,
+                  softWrap: true,
                 ),
               ),
             ],

lib/src/screens/vocab_screen.dart

@@ -4,13 +4,26 @@ import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 import '../models/kanji_item.dart';
-import '../services/deck_repository.dart';
+import 'package:hirameki_srs/src/services/vocab_deck_repository.dart';
 import '../services/distractor_generator.dart';
 import '../widgets/kanji_card.dart';
 import '../widgets/options_grid.dart';
 import 'package:audioplayers/audioplayers.dart';
 import 'settings_screen.dart';
 
+class _QuizState {
+  VocabularyItem? current;
+  List<String> options = [];
+  List<String> correctAnswers = [];
+  int score = 0;
+  int asked = 0;
+  Key key = UniqueKey();
+  String? selectedOption;
+  bool showResult = false;
+  List<VocabularyItem> shuffledDeck = [];
+  int currentIndex = 0;
+}
+
 class VocabScreen extends StatefulWidget {
   const VocabScreen({super.key});
 
@@ -18,29 +31,42 @@ class VocabScreen extends StatefulWidget {
   State<VocabScreen> createState() => _VocabScreenState();
 }
 
-class _VocabScreenState extends State<VocabScreen> {
+class _VocabScreenState extends State<VocabScreen> with SingleTickerProviderStateMixin {
+  late TabController _tabController;
   List<VocabularyItem> _deck = [];
   bool _loading = false;
+  bool _isAnswering = false;
   String _status = 'Loading deck...';
   final DistractorGenerator _dg = DistractorGenerator();
   final _audioPlayer = AudioPlayer();
 
-  VocabQuizMode _mode = VocabQuizMode.vocabToEnglish;
+  final _quizStates = [_QuizState(), _QuizState(), _QuizState()];
-  VocabularyItem? _current;
+  _QuizState get _currentQuizState => _quizStates[_tabController.index];
-  List<String> _options = [];
+
-  List<String> _correctAnswers = [];
-  int _score = 0;
-  int _asked = 0;
   bool _playAudio = true;
   bool _playCorrectSound = true;
+  bool _apiKeyMissing = false;
 
   @override
   void initState() {
     super.initState();
+    _tabController = TabController(length: 3, vsync: this);
+    _tabController.addListener(() {
+      if (_tabController.indexIsChanging) {
+        _nextQuestion();
+      }
+      setState(() {});
+    });
     _loadSettings();
     _loadDeck();
   }
 
+  @override
+  void dispose() {
+    _tabController.dispose();
+    super.dispose();
+  }
+
   Future<void> _loadSettings() async {
     final prefs = await SharedPreferences.getInstance();
     setState(() {
@@ -56,16 +82,15 @@ class _VocabScreenState extends State<VocabScreen> {
     });
 
     try {
-      final repo = Provider.of<DeckRepository>(context, listen: false);
+      final repo = Provider.of<VocabDeckRepository>(context, listen: false);
       await repo.loadApiKey();
       final apiKey = repo.apiKey;
 
       if (apiKey == null || apiKey.isEmpty) {
-        if (mounted) {
+        setState(() {
-          Navigator.of(context).pushReplacement(
+          _apiKeyMissing = true;
-            MaterialPageRoute(builder: (_) => const SettingsScreen()),
+          _loading = false;
-          );
+        });
-        }
         return;
       }
 
@@ -82,9 +107,12 @@ class _VocabScreenState extends State<VocabScreen> {
         _deck = items;
         _status = 'Loaded ${items.length} vocabulary';
         _loading = false;
+        _apiKeyMissing = false;
       });
 
-      _nextQuestion();
+      for (var i = 0; i < _tabController.length; i++) {
+        _nextQuestion(i);
+      }
     } catch (e) {
       setState(() {
         _status = 'Error: $e';
@@ -101,70 +129,97 @@ class _VocabScreenState extends State<VocabScreen> {
         .join(' ');
   }
 
-  void _nextQuestion() {
+  VocabQuizMode _modeForIndex(int index) {
+    switch (index) {
+      case 0:
+        return VocabQuizMode.vocabToEnglish;
+      case 1:
+        return VocabQuizMode.englishToVocab;
+      case 2:
+        return VocabQuizMode.audioToEnglish;
+      default:
+        return VocabQuizMode.vocabToEnglish;
+    }
+  }
+
+  void _nextQuestion([int? index]) {
     if (_deck.isEmpty) return;
 
-    List<VocabularyItem> deck = _deck;
+    final quizState = _quizStates[index ?? _tabController.index];
-    if (_mode == VocabQuizMode.audioToEnglish) {
+    final mode = _modeForIndex(index ?? _tabController.index);
-      deck = _deck.where((item) => item.pronunciationAudios.isNotEmpty).toList();
+
-      if (deck.isEmpty) {
+    List<VocabularyItem> currentDeckForMode = _deck;
+    if (mode == VocabQuizMode.audioToEnglish) {
+      currentDeckForMode = _deck.where((item) => item.pronunciationAudios.isNotEmpty).toList();
+      if (currentDeckForMode.isEmpty) {
         setState(() {
           _status = 'No vocabulary with audio found.';
-          _current = null;
+          quizState.current = null;
         });
         return;
       }
     }
 
-    deck.sort((a, b) {
+    // If it's a new session or we've gone through all shuffled items, re-shuffle
-      final aSrsItem = a.srsItems[_mode.toString()] ??
+    if (quizState.shuffledDeck.isEmpty || quizState.currentIndex >= quizState.shuffledDeck.length) {
-          VocabSrsItem(vocabId: a.id, quizMode: _mode);
+      quizState.shuffledDeck = currentDeckForMode.toList(); // Start with a fresh copy
-      final bSrsItem = b.srsItems[_mode.toString()] ??
+      // Apply sorting based on SRS stages here, but only once per shuffle
-          VocabSrsItem(vocabId: b.id, quizMode: _mode);
+      quizState.shuffledDeck.sort((a, b) {
-
+        final aSrsItem = a.srsItems[mode.toString()] ?? VocabSrsItem(vocabId: a.id, quizMode: mode);
+        final bSrsItem = b.srsItems[mode.toString()] ?? VocabSrsItem(vocabId: b.id, quizMode: mode);
         final stageComparison = aSrsItem.srsStage.compareTo(bSrsItem.srsStage);
         if (stageComparison != 0) {
           return stageComparison;
         }
         return aSrsItem.lastAsked.compareTo(bSrsItem.lastAsked);
       });
+      quizState.currentIndex = 0;
+    }
 
-    _current = deck.first;
+    quizState.current = quizState.shuffledDeck[quizState.currentIndex]; // Pick from shuffled deck
-    if (_mode == VocabQuizMode.audioToEnglish) {
+    quizState.currentIndex++; // Advance index
+
+    quizState.key = UniqueKey();
+    if (mode == VocabQuizMode.audioToEnglish) {
       _playCurrentAudio();
     }
 
-    _correctAnswers = [];
+    quizState.correctAnswers = [];
-    _options = [];
+    quizState.options = [];
+    quizState.selectedOption = null;
+    quizState.showResult = false;
 
-    switch (_mode) {
+    switch (mode) {
       case VocabQuizMode.vocabToEnglish:
       case VocabQuizMode.audioToEnglish:
-        _correctAnswers = [_current!.meanings.first];
+        quizState.correctAnswers = [quizState.current!.meanings.first];
-        _options = [
+        quizState.options = [
-          _correctAnswers.first,
+          quizState.correctAnswers.first,
-          ..._dg.generateVocabMeanings(_current!, _deck, 3)
+          ..._dg.generateVocabMeanings(quizState.current!, _deck, 3)
         ].map(_toTitleCase).toList()
           ..shuffle();
         break;
 
       case VocabQuizMode.englishToVocab:
-        _correctAnswers = [_current!.characters];
+        quizState.correctAnswers = [quizState.current!.characters];
-        _options = [
+        quizState.options = [
-          _correctAnswers.first,
+          quizState.correctAnswers.first,
-          ..._dg.generateVocab(_current!, _deck, 3)
+          ..._dg.generateVocab(quizState.current!, _deck, 3)
         ]..shuffle();
         break;
     }
 
-    setState(() {});
+    setState(() {
+      _isAnswering = false;
+    });
   }
 
   Future<void> _playCurrentAudio() async {
-    if (_current == null || _current!.pronunciationAudios.isEmpty) return;
+    final current = _currentQuizState.current;
+    if (current == null || current.pronunciationAudios.isEmpty) return;
 
-    final maleAudios = _current!.pronunciationAudios.where((a) => a.gender == 'male');
+    final maleAudios = current.pronunciationAudios.where((a) => a.gender == 'male');
-    final audioUrl = (maleAudios.isNotEmpty ? maleAudios.first.url : _current!.pronunciationAudios.first.url);
+    final audioUrl = (maleAudios.isNotEmpty ? maleAudios.first.url : current.pronunciationAudios.first.url);
 
     try {
       await _audioPlayer.play(UrlSource(audioUrl));
@@ -174,31 +229,35 @@ class _VocabScreenState extends State<VocabScreen> {
   }
 
   void _answer(String option) async {
-    final isCorrect = _correctAnswers
+    final quizState = _currentQuizState;
+    final mode = _modeForIndex(_tabController.index);
+    final isCorrect = quizState.correctAnswers
         .map((a) => a.toLowerCase().trim())
         .contains(option.toLowerCase().trim());
 
-    final repo = Provider.of<DeckRepository>(context, listen: false);
+    final repo = Provider.of<VocabDeckRepository>(context, listen: false);
-    final current = _current!;
+    final current = quizState.current!;
 
-    final srsKey = _mode.toString();
+    final srsKey = mode.toString();
 
     var srsItemNullable = current.srsItems[srsKey];
     final isNew = srsItemNullable == null;
     final srsItem =
-        srsItemNullable ?? VocabSrsItem(vocabId: current.id, quizMode: _mode);
+        srsItemNullable ?? VocabSrsItem(vocabId: current.id, quizMode: mode);
+
+    quizState.asked += 1;
+    quizState.selectedOption = option;
+    quizState.showResult = true;
+    setState(() {}); // Trigger UI rebuild to show selected/correct colors
 
-    setState(() {
-      _asked += 1;
     if (isCorrect) {
-        _score += 1;
+      quizState.score += 1;
       srsItem.srsStage += 1;
     } else {
       srsItem.srsStage = max(0, srsItem.srsStage - 1);
     }
     srsItem.lastAsked = DateTime.now();
     current.srsItems[srsKey] = srsItem;
-    });
 
     if (isNew) {
       await repo.insertVocabSrsItem(srsItem);
@@ -206,9 +265,9 @@ class _VocabScreenState extends State<VocabScreen> {
       await repo.updateVocabSrsItem(srsItem);
     }
 
-    final correctDisplay = (_mode == VocabQuizMode.vocabToEnglish)
+    final correctDisplay = (mode == VocabQuizMode.vocabToEnglish)
-        ? _toTitleCase(_correctAnswers.first)
+        ? _toTitleCase(quizState.correctAnswers.first)
-        : _correctAnswers.first;
+        : quizState.correctAnswers.first;
 
     final snack = SnackBar(
       content: Text(
@@ -229,7 +288,7 @@ class _VocabScreenState extends State<VocabScreen> {
       if (_playCorrectSound) {
         await _audioPlayer.play(AssetSource('sfx/confirm.mp3'));
       }
-      if (_playAudio && _mode != VocabQuizMode.audioToEnglish) {
+      if (_playAudio && mode != VocabQuizMode.audioToEnglish) {
         final maleAudios =
             current.pronunciationAudios.where((a) => a.gender == 'male');
         if (maleAudios.isNotEmpty) {
@@ -249,31 +308,86 @@ class _VocabScreenState extends State<VocabScreen> {
         }
       }
     } else {
-      await Future.delayed(const Duration(milliseconds: 900));
+      // No fixed delay for incorrect answers
     }
 
+    setState(() {
+      _isAnswering = true; // Disable input after showing result
+    });
+
     _nextQuestion();
   }
 
   @override
   Widget build(BuildContext context) {
+    if (_apiKeyMissing) {
+      return Scaffold(
+        appBar: AppBar(title: const Text('Vocabulary Quiz')),
+        body: Center(
+          child: Column(
+            mainAxisAlignment: MainAxisAlignment.center,
+            children: [
+              const Text('WaniKani API key is not set.'),
+              const SizedBox(height: 16),
+              ElevatedButton(
+                onPressed: () async {
+                  await Navigator.of(context).push(
+                    MaterialPageRoute(builder: (_) => const SettingsScreen()),
+                  );
+                  _loadDeck();
+                },
+                child: const Text('Go to Settings'),
+              ),
+            ],
+          ),
+        ),
+      );
+    }
+
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('Vocabulary Quiz'),
+        bottom: TabBar(
+          controller: _tabController,
+          tabs: const [
+            Tab(text: 'Vocab→English'),
+            Tab(text: 'English→Vocab'),
+            Tab(text: 'Listening'),
+          ],
+        ),
+      ),
+      body: TabBarView(
+        controller: _tabController,
+        children: [
+          _buildQuizPage(0),
+          _buildQuizPage(1),
+          _buildQuizPage(2),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildQuizPage(int index) {
+    final quizState = _quizStates[index];
+    final mode = _modeForIndex(index);
+
     Widget promptWidget;
 
-    if (_current == null) {
+    if (quizState.current == null) {
       promptWidget = const SizedBox.shrink();
-    } else if (_mode == VocabQuizMode.audioToEnglish) {
+    } else if (mode == VocabQuizMode.audioToEnglish) {
       promptWidget = IconButton(
         icon: const Icon(Icons.volume_up, color: Colors.white, size: 64),
         onPressed: _playCurrentAudio,
       );
     } else {
       String promptText = '';
-      switch (_mode) {
+      switch (mode) {
         case VocabQuizMode.vocabToEnglish:
-          promptText = _current?.characters ?? '';
+          promptText = quizState.current!.characters;
           break;
         case VocabQuizMode.englishToVocab:
-          promptText = _current != null ? _toTitleCase(_current!.meanings.first) : '';
+          promptText = _toTitleCase(quizState.current!.meanings.first);
           break;
         case VocabQuizMode.audioToEnglish:
           // Handled above
@@ -282,26 +396,8 @@ class _VocabScreenState extends State<VocabScreen> {
       promptWidget = Text(promptText, style: const TextStyle(fontSize: 48, color: Colors.white));
     }
 
-    return Scaffold(
+    return Padding(
-      backgroundColor: const Color(0xFF121212),
+      key: quizState.key,
-      appBar: AppBar(
-        title: const Text('Hirameki SRS - Vocab'),
-        backgroundColor: const Color(0xFF1F1F1F),
-        foregroundColor: Colors.white,
-        elevation: 2,
-        actions: [
-          IconButton(
-            icon: const Icon(Icons.settings),
-            onPressed: () async {
-              await Navigator.of(context).push(
-                MaterialPageRoute(builder: (_) => const SettingsScreen()),
-              );
-              _loadSettings();
-            },
-          )
-        ],
-      ),
-      body: Padding(
       padding: const EdgeInsets.all(16.0),
       child: Column(
         children: [
@@ -310,24 +406,12 @@ class _VocabScreenState extends State<VocabScreen> {
               Expanded(
                 child: Text(
                   _status,
-                    style: const TextStyle(color: Colors.white),
                 ),
               ),
               if (_loading)
                 const CircularProgressIndicator(color: Colors.blueAccent),
             ],
           ),
-            const SizedBox(height: 12),
-            Wrap(
-              spacing: 6,
-              runSpacing: 4,
-              alignment: WrapAlignment.center,
-              children: [
-                _buildChoiceChip('Vocab→English', VocabQuizMode.vocabToEnglish),
-                _buildChoiceChip('English→Vocab', VocabQuizMode.englishToVocab),
-                _buildChoiceChip('Listening', VocabQuizMode.audioToEnglish),
-              ],
-            ),
           const SizedBox(height: 18),
           Expanded(
             flex: 3,
@@ -341,8 +425,6 @@ class _VocabScreenState extends State<VocabScreen> {
                 child: KanjiCard(
                   characterWidget: promptWidget,
                   subtitle: '',
-                    backgroundColor: const Color(0xFF1E1E1E),
-                    textColor: Colors.white,
                 ),
               ),
             ),
@@ -353,14 +435,16 @@ class _VocabScreenState extends State<VocabScreen> {
             child: Column(
               children: [
                 OptionsGrid(
-                    options: _options,
+                  options: quizState.options,
-                    onSelected: _answer,
+                  onSelected: _isAnswering ? (option) {} : _answer,
-                    buttonColor: const Color(0xFF1E1E1E),
+                  isDisabled: false,
-                    textColor: Colors.white,
+                  selectedOption: null,
+                  correctAnswers: [],
+                  showResult: false,
                 ),
                 const SizedBox(height: 8),
                 Text(
-                    'Score: $_score / $_asked',
+                  'Score: ${quizState.score} / ${quizState.asked}',
                   style: const TextStyle(color: Colors.white),
                 ),
               ],
@@ -368,25 +452,6 @@ class _VocabScreenState extends State<VocabScreen> {
           ),
         ],
       ),
-      ),
-    );
-
-  }
-
-  ChoiceChip _buildChoiceChip(String label, VocabQuizMode mode) {
-    final selected = _mode == mode;
-    return ChoiceChip(
-      label: Text(
-        label,
-        style: TextStyle(color: selected ? Colors.white : Colors.grey[400]),
-      ),
-      selected: selected,
-      onSelected: (v) {
-        setState(() => _mode = mode);
-        _nextQuestion();
-      },
-      selectedColor: Colors.blueAccent,
-      backgroundColor: const Color(0xFF1E1E1E),
     );
   }
 }

lib/src/services/custom_deck_repository.dart

@@ -0,0 +1,56 @@
+
+import 'dart:convert';
+import 'package:shared_preferences/shared_preferences.dart';
+import '../models/custom_kanji_item.dart';
+
+class CustomDeckRepository {
+  static const _key = 'custom_deck';
+
+  Future<List<CustomKanjiItem>> getCustomDeck() async {
+    final prefs = await SharedPreferences.getInstance();
+    final jsonString = prefs.getString(_key);
+    if (jsonString != null) {
+      final List<dynamic> jsonList = json.decode(jsonString);
+      return jsonList.map((json) => CustomKanjiItem.fromJson(json)).toList();
+    }
+    return [];
+  }
+
+  Future<void> addCard(CustomKanjiItem item) async {
+    final deck = await getCustomDeck();
+    deck.add(item);
+    await saveDeck(deck);
+  }
+
+  Future<void> updateCard(CustomKanjiItem item) async {
+    final deck = await getCustomDeck();
+    final index = deck.indexWhere((element) => element.characters == item.characters);
+    if (index != -1) {
+      deck[index] = item;
+      await saveDeck(deck);
+    }
+  }
+
+  Future<void> updateCards(List<CustomKanjiItem> itemsToUpdate) async {
+    final deck = await getCustomDeck();
+    for (var item in itemsToUpdate) {
+      final index = deck.indexWhere((element) => element.characters == item.characters);
+      if (index != -1) {
+        deck[index] = item;
+      }
+    }
+    await saveDeck(deck);
+  }
+
+  Future<void> deleteCard(CustomKanjiItem item) async {
+    final deck = await getCustomDeck();
+    deck.removeWhere((element) => element.characters == item.characters);
+    await saveDeck(deck);
+  }
+
+  Future<void> saveDeck(List<CustomKanjiItem> deck) async {
+    final prefs = await SharedPreferences.getInstance();
+    final jsonList = deck.map((item) => item.toJson()).toList();
+    await prefs.setString(_key, json.encode(jsonList));
+  }
+}

lib/src/services/deck_repository.dart

@@ -1,11 +1,12 @@
 import 'dart:async';
-import 'dart:convert';
 import 'package:path/path.dart';
 import 'package:path_provider/path_provider.dart';
 import 'package:sqflite/sqflite.dart';
 import '../models/kanji_item.dart';
 import '../api/wk_client.dart';
 
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+
 class DeckRepository {
   Database? _db;
   String? _apiKey;
@@ -98,6 +99,20 @@ class DeckRepository {
   }
 
   Future<String?> loadApiKey() async {
+    String? envApiKey;
+    try {
+      envApiKey = dotenv.env['WANIKANI_API_KEY'];
+    } catch (e) {
+      // dotenv is not initialized, so we can't get the key.
+      // This is expected in release builds.
+      envApiKey = null;
+    }
+
+    if (envApiKey != null && envApiKey.isNotEmpty) {
+      _apiKey = envApiKey;
+      return _apiKey;
+    }
+
     final db = await _openDb();
     final rows = await db.query(
       'settings',
@@ -247,154 +262,5 @@ class DeckRepository {
     return items;
   }
 
-  Future<List<VocabSrsItem>> getVocabSrsItems(int vocabId) async {
-    final db = await _openDb();
-    final rows = await db.query(
-      'srs_vocab_items',
-      where: 'vocabId = ?',
-      whereArgs: [vocabId],
-    );
-    return rows.map((r) {
-      return VocabSrsItem(
-        vocabId: r['vocabId'] as int,
-        quizMode: VocabQuizMode.values.firstWhere(
-          (e) => e.toString() == r['quizMode'] as String,
-        ),
-        srsStage: r['srsStage'] as int,
-        lastAsked: DateTime.parse(r['lastAsked'] as String),
-      );
-    }).toList();
-  }
 
-  Future<void> updateVocabSrsItem(VocabSrsItem item) async {
-    final db = await _openDb();
-    await db.update(
-      'srs_vocab_items',
-      {
-        'srsStage': item.srsStage,
-        'lastAsked': item.lastAsked.toIso8601String(),
-      },
-      where: 'vocabId = ? AND quizMode = ?',
-      whereArgs: [item.vocabId, item.quizMode.toString()],
-    );
-  }
-
-  Future<void> insertVocabSrsItem(VocabSrsItem item) async {
-    final db = await _openDb();
-    await db.insert('srs_vocab_items', {
-      'vocabId': item.vocabId,
-      'quizMode': item.quizMode.toString(),
-      'srsStage': item.srsStage,
-      'lastAsked': item.lastAsked.toIso8601String(),
-    }, conflictAlgorithm: ConflictAlgorithm.replace);
-  }
-
-  Future<void> saveVocabulary(List<VocabularyItem> items) async {
-    final db = await _openDb();
-    final batch = db.batch();
-    for (final it in items) {
-      final audios = it.pronunciationAudios
-          .map((a) => {'url': a.url, 'gender': a.gender})
-          .toList();
-      batch.insert('vocabulary', {
-        'id': it.id,
-        'level': it.level,
-        'characters': it.characters,
-        'meanings': it.meanings.join('|'),
-        'readings': it.readings.join('|'),
-        'pronunciation_audios': jsonEncode(audios),
-      }, conflictAlgorithm: ConflictAlgorithm.replace);
-    }
-    await batch.commit(noResult: true);
-  }
-
-  Future<List<VocabularyItem>> loadVocabulary() async {
-    final db = await _openDb();
-    final rows = await db.query('vocabulary');
-    final vocabItems = rows.map((r) {
-      final audiosRaw = r['pronunciation_audios'] as String?;
-      final List<PronunciationAudio> audios = [];
-      if (audiosRaw != null && audiosRaw.isNotEmpty) {
-        try {
-          final decoded = jsonDecode(audiosRaw) as List;
-          for (final audioData in decoded) {
-            audios.add(
-              PronunciationAudio(
-                url: audioData['url'] as String,
-                gender: audioData['gender'] as String,
-              ),
-            );
-          }
-        } catch (e) {
-          // Error decoding, so we'll just have no audio for this item
-        }
-      }
-      return VocabularyItem(
-        id: r['id'] as int,
-        level: r['level'] as int? ?? 0,
-        characters: r['characters'] as String,
-        meanings: (r['meanings'] as String)
-            .split('|')
-            .where((s) => s.isNotEmpty)
-            .toList(),
-        readings: (r['readings'] as String)
-            .split('|')
-            .where((s) => s.isNotEmpty)
-            .toList(),
-        pronunciationAudios: audios,
-      );
-    }).toList();
-
-    for (final item in vocabItems) {
-      final srsItems = await getVocabSrsItems(item.id);
-      for (final srsItem in srsItems) {
-        final key = srsItem.quizMode.toString();
-        item.srsItems[key] = srsItem;
-      }
-    }
-
-    return vocabItems;
-  }
-
-  Future<List<VocabularyItem>> fetchAndCacheVocabularyFromWk([
-    String? apiKey,
-  ]) async {
-    final key = apiKey ?? _apiKey;
-    if (key == null) throw Exception('API key not set');
-
-    final client = WkClient(key);
-    final assignments = await client.fetchAllAssignments(
-      subjectTypes: ['vocabulary'],
-    );
-
-    final unlocked = <int>{};
-    for (final a in assignments) {
-      final data = a['data'] as Map<String, dynamic>;
-      final sidRaw = data['subject_id'];
-      if (sidRaw == null) continue;
-      final sid = sidRaw is int ? sidRaw : int.tryParse(sidRaw.toString());
-      if (sid == null) continue;
-      final started = data['started_at'];
-      final srs = data['srs_stage'];
-      final isUnlocked = (started != null) || (srs != null && (srs as int) > 0);
-      if (isUnlocked) unlocked.add(sid);
-    }
-
-    if (unlocked.isEmpty) return [];
-
-    final subjects = await client.fetchSubjectsByIds(unlocked.toList());
-    final items = subjects
-        .where(
-          (s) =>
-              s['object'] == 'vocabulary' ||
-              (s['data'] != null &&
-                  (s['data'] as Map)['object_type'] == 'vocabulary'),
-        )
-        .map((s) => VocabularyItem.fromSubject(s))
-        .where((k) => k.characters.isNotEmpty && k.meanings.isNotEmpty)
-        .toList();
-
-    await saveVocabulary(items);
-    return items;
-  }
 }

lib/src/services/vocab_deck_repository.dart

@@ -0,0 +1,280 @@
+import 'dart:async';
+import 'dart:convert';
+import 'package:path/path.dart';
+import 'package:path_provider/path_provider.dart';
+import 'package:sqflite/sqflite.dart';
+import '../models/kanji_item.dart';
+import '../api/wk_client.dart';
+
+import 'package:flutter_dotenv/flutter_dotenv.dart';
+
+class VocabDeckRepository {
+  Database? _db;
+  String? _apiKey;
+
+  Future<void> setApiKey(String apiKey) async {
+    _apiKey = apiKey;
+    await saveApiKey(apiKey);
+  }
+
+  String? get apiKey => _apiKey;
+
+  Future<Database> _openDb() async {
+    if (_db != null) return _db!;
+    final dir = await getApplicationDocumentsDirectory();
+    final path = join(dir.path, 'wanikani_srs.db');
+
+    _db = await openDatabase(
+      path,
+      version: 7,
+      onCreate: (db, version) async {
+        await db.execute(
+          '''CREATE TABLE kanji (id INTEGER PRIMARY KEY, level INTEGER, characters TEXT, meanings TEXT, onyomi TEXT, kunyomi TEXT)''',
+        );
+        await db.execute(
+          '''CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT)''',
+        );
+        await db.execute(
+          '''CREATE TABLE srs_items (kanjiId INTEGER, quizMode TEXT, readingType TEXT, srsStage INTEGER, lastAsked TEXT, PRIMARY KEY (kanjiId, quizMode, readingType))''',
+        );
+        await db.execute(
+          '''CREATE TABLE vocabulary (id INTEGER PRIMARY KEY, level INTEGER, characters TEXT, meanings TEXT, readings TEXT, pronunciation_audios TEXT)''',
+        );
+        await db.execute(
+          '''CREATE TABLE srs_vocab_items (vocabId INTEGER, quizMode TEXT, srsStage INTEGER, lastAsked TEXT, PRIMARY KEY (vocabId, quizMode))''',
+        );
+      },
+      onUpgrade: (db, oldVersion, newVersion) async {
+        if (oldVersion < 2) {
+          await db.execute(
+            '''CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value TEXT)''',
+          );
+        }
+        if (oldVersion < 3) {
+          // Migration from version 2 to 3 was flawed, so we just drop the columns if they exist
+        }
+        if (oldVersion < 4) {
+          await db.execute(
+            '''CREATE TABLE srs_items (kanjiId INTEGER, quizMode TEXT, readingType TEXT, srsStage INTEGER, lastAsked TEXT, PRIMARY KEY (kanjiId, quizMode, readingType))''',
+          );
+          // We are not migrating the old srs data, as it was not mode-specific.
+          // Old columns will be dropped.
+        }
+        if (oldVersion < 5) {
+          await db.execute(
+            '''CREATE TABLE vocabulary (id INTEGER PRIMARY KEY, characters TEXT, meanings TEXT, readings TEXT)''',
+          );
+          await db.execute(
+            '''CREATE TABLE srs_vocab_items (vocabId INTEGER, quizMode TEXT, srsStage INTEGER, lastAsked TEXT, PRIMARY KEY (vocabId, quizMode))''',
+          );
+        }
+        if (oldVersion < 6) {
+          try {
+            await db.execute(
+              'ALTER TABLE vocabulary ADD COLUMN pronunciation_audios TEXT',
+            );
+          } catch (_) {
+            // Ignore error, column might already exist
+          }
+        }
+        if (oldVersion < 7) {
+          try {
+            await db.execute('ALTER TABLE kanji ADD COLUMN level INTEGER');
+            await db.execute('ALTER TABLE vocabulary ADD COLUMN level INTEGER');
+          } catch (_) {
+            // Ignore error, column might already exist
+          }
+        }
+      },
+    );
+
+    return _db!;
+  }
+
+  Future<void> saveApiKey(String apiKey) async {
+    final db = await _openDb();
+    await db.insert('settings', {
+      'key': 'apiKey',
+      'value': apiKey,
+    }, conflictAlgorithm: ConflictAlgorithm.replace);
+  }
+
+  Future<String?> loadApiKey() async {
+    String? envApiKey;
+    try {
+      envApiKey = dotenv.env['WANIKANI_API_KEY'];
+    } catch (e) {
+      // dotenv is not initialized, so we can't get the key.
+      // This is expected in release builds.
+      envApiKey = null;
+    }
+
+    if (envApiKey != null && envApiKey.isNotEmpty) {
+      _apiKey = envApiKey;
+      return _apiKey;
+    }
+
+    final db = await _openDb();
+    final rows = await db.query(
+      'settings',
+      where: 'key = ?',
+      whereArgs: ['apiKey'],
+    );
+    if (rows.isNotEmpty) {
+      _apiKey = rows.first['value'] as String;
+      return _apiKey;
+    }
+    return null;
+  }
+
+  Future<List<VocabSrsItem>> getVocabSrsItems(int vocabId) async {
+    final db = await _openDb();
+    final rows = await db.query(
+      'srs_vocab_items',
+      where: 'vocabId = ?',
+      whereArgs: [vocabId],
+    );
+    return rows.map((r) {
+      return VocabSrsItem(
+        vocabId: r['vocabId'] as int,
+        quizMode: VocabQuizMode.values.firstWhere(
+          (e) => e.toString() == r['quizMode'] as String,
+        ),
+        srsStage: r['srsStage'] as int,
+        lastAsked: DateTime.parse(r['lastAsked'] as String),
+      );
+    }).toList();
+  }
+
+  Future<void> updateVocabSrsItem(VocabSrsItem item) async {
+    final db = await _openDb();
+    await db.update(
+      'srs_vocab_items',
+      {
+        'srsStage': item.srsStage,
+        'lastAsked': item.lastAsked.toIso8601String(),
+      },
+      where: 'vocabId = ? AND quizMode = ?',
+      whereArgs: [item.vocabId, item.quizMode.toString()],
+    );
+  }
+
+  Future<void> insertVocabSrsItem(VocabSrsItem item) async {
+    final db = await _openDb();
+    await db.insert('srs_vocab_items', {
+      'vocabId': item.vocabId,
+      'quizMode': item.quizMode.toString(),
+      'srsStage': item.srsStage,
+      'lastAsked': item.lastAsked.toIso8601String(),
+    }, conflictAlgorithm: ConflictAlgorithm.replace);
+  }
+
+  Future<void> saveVocabulary(List<VocabularyItem> items) async {
+    final db = await _openDb();
+    final batch = db.batch();
+    for (final it in items) {
+      final audios = it.pronunciationAudios
+          .map((a) => {'url': a.url, 'gender': a.gender})
+          .toList();
+      batch.insert('vocabulary', {
+        'id': it.id,
+        'level': it.level,
+        'characters': it.characters,
+        'meanings': it.meanings.join('|'),
+        'readings': it.readings.join('|'),
+        'pronunciation_audios': jsonEncode(audios),
+      }, conflictAlgorithm: ConflictAlgorithm.replace);
+    }
+    await batch.commit(noResult: true);
+  }
+
+  Future<List<VocabularyItem>> loadVocabulary() async {
+    final db = await _openDb();
+    final rows = await db.query('vocabulary');
+    final vocabItems = rows.map((r) {
+      final audiosRaw = r['pronunciation_audios'] as String?;
+      final List<PronunciationAudio> audios = [];
+      if (audiosRaw != null && audiosRaw.isNotEmpty) {
+        try {
+          final decoded = jsonDecode(audiosRaw) as List;
+          for (final audioData in decoded) {
+            audios.add(
+              PronunciationAudio(
+                url: audioData['url'] as String,
+                gender: audioData['gender'] as String,
+              ),
+            );
+          }
+        } catch (e) {
+          // Error decoding, so we'll just have no audio for this item
+        }
+      }
+      return VocabularyItem(
+        id: r['id'] as int,
+        level: r['level'] as int? ?? 0,
+        characters: r['characters'] as String,
+        meanings: (r['meanings'] as String)
+            .split('|')
+            .where((s) => s.isNotEmpty)
+            .toList(),
+        readings: (r['readings'] as String)
+            .split('|')
+            .where((s) => s.isNotEmpty)
+            .toList(),
+        pronunciationAudios: audios,
+      );
+    }).toList();
+
+    for (final item in vocabItems) {
+      final srsItems = await getVocabSrsItems(item.id);
+      for (final srsItem in srsItems) {
+        final key = srsItem.quizMode.toString();
+        item.srsItems[key] = srsItem;
+      }
+    }
+
+    return vocabItems;
+  }
+
+  Future<List<VocabularyItem>> fetchAndCacheVocabularyFromWk([
+    String? apiKey,
+  ]) async {
+    final key = apiKey ?? _apiKey;
+    if (key == null) throw Exception('API key not set');
+
+    final client = WkClient(key);
+    final assignments = await client.fetchAllAssignments(
+      subjectTypes: ['vocabulary'],
+    );
+
+    final unlocked = <int>{};
+    for (final a in assignments) {
+      final data = a['data'] as Map<String, dynamic>;
+      final sidRaw = data['subject_id'];
+      if (sidRaw == null) continue;
+      final sid = sidRaw is int ? sidRaw : int.tryParse(sidRaw.toString());
+      if (sid == null) continue;
+      final started = data['started_at'];
+      final srs = data['srs_stage'];
+      final isUnlocked = (started != null) || (srs != null && (srs as int) > 0);
+      if (isUnlocked) unlocked.add(sid);
+    }
+
+    if (unlocked.isEmpty) return [];
+
+    final subjects = await client.fetchSubjectsByIds(unlocked.toList());
+    final items = subjects
+        .where(
+          (s) =>
+              s['object'] == 'vocabulary' ||
+              (s['data'] != null &&
+                  (s['data'] as Map)['object_type'] == 'vocabulary'),
+        )
+        .map((s) => VocabularyItem.fromSubject(s))
+        .where((k) => k.characters.isNotEmpty && k.meanings.isNotEmpty)
+        .toList();
+
+    await saveVocabulary(items);
+    return items;
+  }
+}

lib/src/widgets/options_grid.dart

@@ -5,6 +5,10 @@ class OptionsGrid extends StatelessWidget {
   final void Function(String) onSelected;
   final Color? buttonColor;
   final Color? textColor;
+  final bool isDisabled;
+  final String? selectedOption;
+  final List<String>? correctAnswers;
+  final bool showResult;
 
   const OptionsGrid({
     super.key,
@@ -12,6 +16,10 @@ class OptionsGrid extends StatelessWidget {
     required this.onSelected,
     this.buttonColor,
     this.textColor,
+    this.isDisabled = false,
+    this.selectedOption,
+    this.correctAnswers,
+    this.showResult = false,
   });
 
   @override
@@ -27,13 +35,24 @@ class OptionsGrid extends StatelessWidget {
       runSpacing: 10,
       alignment: WrapAlignment.center,
       children: options.map((o) {
+        Color currentButtonColor = bg;
+        Color currentTextColor = fg;
+
+        if (showResult) {
+          if (correctAnswers != null && correctAnswers!.contains(o)) {
+            currentButtonColor = Colors.green;
+          } else if (o == selectedOption) {
+            currentButtonColor = Colors.red;
+          }
+        }
+
         return SizedBox(
           width: 160,
           child: ElevatedButton(
-            onPressed: () => onSelected(o),
+            onPressed: isDisabled ? null : () => onSelected(o),
             style: ElevatedButton.styleFrom(
-              backgroundColor: bg,
+              backgroundColor: currentButtonColor,
-              foregroundColor: fg,
+              foregroundColor: currentTextColor,
               shape: RoundedRectangleBorder(
                 borderRadius: BorderRadius.circular(12),
               ),
@@ -41,7 +60,7 @@ class OptionsGrid extends StatelessWidget {
             ),
             child: Text(
               o,
-              style: TextStyle(fontSize: 20, color: fg),
+              style: TextStyle(fontSize: 20, color: currentTextColor),
               textAlign: TextAlign.center,
             ),
           ),

pubspec.lock

@@ -185,6 +185,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.0.4"
+  checks:
+    dependency: transitive
+    description:
+      name: checks
+      sha256: "016871c84732c1ac9856b8940236d5a5802ba638b3bd3e0ea7027b51a35f7aa7"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.3.1"
   cli_config:
     dependency: transitive
     description:
@@ -294,6 +302,14 @@ packages:
     description: flutter
     source: sdk
     version: "0.0.0"
+  flutter_dotenv:
+    dependency: "direct main"
+    description:
+      name: flutter_dotenv
+      sha256: b7c7be5cd9f6ef7a78429cabd2774d3c4af50e79cb2b7593e3d5d763ef95c61b
+      url: "https://pub.dev"
+    source: hosted
+    version: "5.2.1"
   flutter_launcher_icons:
     dependency: "direct dev"
     description:
@@ -315,6 +331,14 @@ packages:
     description: flutter
     source: sdk
     version: "0.0.0"
+  flutter_tts:
+    dependency: "direct main"
+    description:
+      name: flutter_tts
+      sha256: cbb3fd43b946e62398560235469e6113e4fe26c40eab1b7cb5e7c417503fb3a8
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.8.5"
   flutter_web_plugins:
     dependency: transitive
     description: flutter
@@ -400,6 +424,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "4.9.0"
+  kana_kit:
+    dependency: "direct main"
+    description:
+      name: kana_kit
+      sha256: "4e99cfddae947971c327ef3d8d82d35cf036c046c7f460583785d48c0f777fa3"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.1"
   leak_tracker:
     dependency: transitive
     description:

pubspec.yaml

@@ -8,12 +8,15 @@ dependencies:
   audioplayers: any
   flutter:
     sdk: flutter
-  http: any
+  shared_preferences: ^2.5.3
-  path: any
+  sqflite: ^2.4.2
-  path_provider: any
+  path_provider: ^2.1.5
-  provider: any
+  path: ^1.9.1
-  shared_preferences: any
+  provider: ^6.1.5
-  sqflite: any
+  http: ^1.5.0
+  kana_kit: ^2.1.1
+  flutter_tts: ^3.8.5
+  flutter_dotenv: ^5.1.0
 
 dev_dependencies:
   flutter_test: