muzzle-velocity/lib/note_list.dart

import 'dart:async';
import 'dart:io';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:file_picker/file_picker.dart';
import 'package:flutter_svg/flutter_svg.dart';
import 'package:google_fonts/google_fonts.dart';
import 'package:open_filex/open_filex.dart';
import 'package:path/path.dart' as path;
import 'package:permission_handler/permission_handler.dart';
import 'package:path_provider/path_provider.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'note_editor.dart';
import 'shortcuts.dart';
import 'read_only.dart';
import 'texts.dart';

class NoteListScreen extends StatefulWidget {
  final void Function(bool) toggleTheme;
  final VoidCallback toggleTags;
  final bool isDarkMode;
  final bool showTags;

  NoteListScreen({
    required this.toggleTheme,
    required this.toggleTags,
    required this.isDarkMode,
    required this.showTags,
  });

  @override
  _NoteListScreenState createState() => _NoteListScreenState();
}

class _NoteListScreenState extends State<NoteListScreen> {
  TextEditingController searchController = TextEditingController();
  final FocusNode searchFocusNode = FocusNode();
  List<File> notes = [];
  List<File> filteredNotes = [];
  List<File> _visibleNotes = [];
  int _visibleLimit = 30;
  bool _isLoadingMore = false;
  Map<File, Set<String>> noteTags = {};
  String? notesDirectoryPath;
  String? defaultDir;
  bool _useExternalEditor = false;
  bool _includeFileContent = false;
  bool _includeSubdirectories = true;
  Timer? _debounce;
  int? _highlighted; // Note picked with the arrow keys, opened by Enter.
  final _highlightedKey = GlobalKey();
  final _listFocus = FocusNode();
  final _menuKey = GlobalKey<PopupMenuButtonState<String>>();

  @override
  void initState() {
    super.initState();
    _initializeApp(); // Call an async method to handle initialization
    searchController.addListener(() {
      _debouncedFilterNotes();
    });
    WidgetsBinding.instance.addPostFrameCallback((_) {
      FocusScope.of(context).requestFocus(searchFocusNode);
    });
  }

  void _debouncedFilterNotes() {
    if (_debounce?.isActive ?? false) _debounce?.cancel();
    _debounce = Timer(Duration(milliseconds: 300), () {
      _filterNotes();
    });
  }

  @override
  void dispose() {
    _debounce?.cancel();
    searchController.dispose();
    _listFocus.dispose();
    super.dispose();
  }

  void _toggleIncludeFileContent(bool value) {
    setState(() {
      _includeFileContent = value;
    });

    // ✅ Save preference
    SharedPreferences.getInstance().then((prefs) {
      prefs.setBool('include_file_content', value);
    });

    // ✅ Immediately reapply search filter to update list
    _filterNotes();
  }


  Future<void> _toggleExternalEditor(bool value) async {
    setState(() {
      _useExternalEditor = value;
    });
    SharedPreferences.getInstance().then((prefs) {
      prefs.setBool('use_external_editor', value);
    });
  }

  Future<void> _requestStoragePermission() async {
    if (Platform.isAndroid) {
      if (await Permission.storage.request().isGranted) {
        print("✅ Basic storage permission granted.");
        return;
      }

      if (await Permission.manageExternalStorage.request().isGranted) {
        print("✅ Full file access granted.");
        return;
      }

      print("❌ Storage permission denied. Opening settings...");
      await openAppSettings(); // Open settings if denied
    }
  }

  Future<void> _initializeApp() async {
    final prefs = await SharedPreferences.getInstance();
    final dir = await getApplicationDocumentsDirectory();

    setState(() {
      defaultDir = dir.path;
      _useExternalEditor = prefs.getBool('use_external_editor') ?? false;
      _includeSubdirectories = prefs.getBool('include_subdirectories') ?? true;
    });

    notesDirectoryPath = prefs.getString('notes_directory') ?? defaultDir;

    // 🚀 Check if it's the first start OR if the directory is empty
    final directory = Directory(notesDirectoryPath!);
    if (prefs.getBool('initialized') == null ||
        !directory.listSync().any((entity) => entity is File && entity.path.endsWith('.md'))) {
      await _createDefaultNotes();
      await prefs.setBool('initialized', true);
    }

    await _loadNotes();
  }

  Future<void> _createDefaultNotes() async {
    final quickStartNote = File(path.join(notesDirectoryPath!, "QuickStart.md"));

    if (!quickStartNote.existsSync()) {
      quickStartNote.writeAsStringSync("""
# Quick Start Guide

Welcome to *Muzzle Velocity*.
This is your fast and minimal note-taking app.

1. ✍️ Create Notes quickly: just type a title in the search bar and press enter.
2. 🔍 Type keywords to filter notes instantly.
3. 💻 Type commands like :help to get more information.
4. 🏷️ Use hashtags like #quickstart, context tags like @help, or project tags like +muzzle in your notes for categorization.
5. 🔫 Tap the blaster at the top right for more settings or to clear the search field.

*Muzzle Velocity* is built for speed and simplicity! 🚀

Happy note taking! ✨
    """);
    }
  }


  void _toggleIncludeSubdirectories(bool value) {
    setState(() {
      _includeSubdirectories = value;
    });

    // ✅ Save preference
    SharedPreferences.getInstance().then((prefs) {
      prefs.setBool('include_subdirectories', value);
    });

    // ✅ Reload notes and reapply search immediately
    _loadNotes().then((_) {
      _filterNotes();
    });
  }

  void _showDirectoryChoiceDialog(String defaultPath) {
    showDialog(
      context: context,
      barrierDismissible: false, // Force user to make a choice
      builder: (BuildContext context) {
        return AlertDialog(
          title: Text("Choose Notes Directory"),
          content: Text(
              "Your notes will be saved in:\n\n📂 $defaultPath\n\nWould you like to use a different folder?"),
          actions: [
            TextButton(
              onPressed: () async {
                // Reset to default directory
                final prefs = await SharedPreferences.getInstance();
                await prefs.remove(
                    'notes_directory'); // Remove custom directory from preferences
                setState(() {
                  notesDirectoryPath = defaultDir; // Reset to default directory
                });
                Navigator.pop(context); // Close dialog
                _loadNotes(); // Reload notes from the default directory
              },
              child: Text("Use Default"),
            ),
            TextButton(
              onPressed: () async {
                await _requestStoragePermission();
                Navigator.pop(context); // Close the current dialog
                await _selectNotesDirectory(); // Allow user to pick a folder
              },
              child: Text("Choose Folder"),
            ),
          ],
        );
      },
    );
  }

  Future<void> _selectNotesDirectory() async {
    String? selectedDirectory = await FilePicker.platform.getDirectoryPath();
    if (selectedDirectory != null) {
      final prefs = await SharedPreferences.getInstance();
      await prefs.setString(
          'notes_directory', selectedDirectory); // Save custom directory
      setState(() {
        notesDirectoryPath = selectedDirectory; // Update state
      });
      _loadNotes(); // Reload notes from the new directory
    }
  }

  Future<void> _loadNotes() async {
    final prefs = await SharedPreferences.getInstance();
    notesDirectoryPath = prefs.getString('notes_directory') ?? defaultDir;
    final notesDir = Directory(notesDirectoryPath!);

    if (!notesDir.existsSync()) {
      notesDir.createSync(recursive: true);
    }

    List<File> allNotes = [];
    Map<String, DateTime> folderTimestamps = {};
    Map<File, Set<String>> extractedTags = {}; // ✅ Store extracted tags here

    void fetchNotes(Directory dir) {
      final entries = dir.listSync(recursive: _includeSubdirectories);

      for (var entry in entries) {
        if (entry is File && _isValidNoteFile(entry)) {

          if (path.basename(path.dirname(entry.path)) == "trash") {
            continue;
          }

          final String content;
          try {
            content = entry.readAsStringSync();
          } on FileSystemException {
            continue; // Not text, e.g. a Mega Drive ROM with a .md extension.
          }

          allNotes.add(entry);
          final folder = path.dirname(entry.path);

          if (!folderTimestamps.containsKey(folder) ||
              entry.lastModifiedSync().isAfter(folderTimestamps[folder]!)) {
            folderTimestamps[folder] = entry.lastModifiedSync();
          }

          extractedTags[entry] = _extractTags(content);
        }
      }
    }

    fetchNotes(notesDir);

    allNotes.sort((a, b) {
      String folderA = path.dirname(a.path);
      String folderB = path.dirname(b.path);
      DateTime timeA = folderTimestamps[folderA] ?? DateTime(0);
      DateTime timeB = folderTimestamps[folderB] ?? DateTime(0);

      // ✅ Prioritize files in the root directory over subdirectories
      bool isRootA = folderA == notesDirectoryPath;
      bool isRootB = folderB == notesDirectoryPath;

      if (isRootA && !isRootB) return -1; // Root files come first
      if (!isRootA && isRootB) return 1;  // Subdir files come after root files

      return timeB.compareTo(timeA); // Otherwise, sort by last modified time
    });

    setState(() {
      notes = allNotes;
      filteredNotes = allNotes;
      noteTags = extractedTags; // ✅ Update stored tags
    });

    _filterNotes(); // ✅ Apply search immediately if a term is active
  }

  /// Extracts unique tags sorted by +, @, #
  Set<String> _extractTags(String content) {
    final tagPattern = RegExp(r'([#@+][a-zA-Z][a-zA-Z0-9_]*)');
    final matches = tagPattern.allMatches(content).map((m) => m.group(0)!).toSet();

    // Sort the tags in order: +tags first, @contexts second, #hashtags last
    final sortedTags = matches.toList()
      ..sort((a, b) {
        const order = {'+': 0, '@': 1, '#': 2};
        return (order[a[0]] ?? 3).compareTo(order[b[0]] ?? 3);
      });

    return sortedTags.toSet(); // Convert back to a set after sorting
  }

  bool _isValidNoteFile(File file) {
    final validExtensions = ['.md', '.txt', '.markdown'];
    return validExtensions.any((ext) => file.path.toLowerCase().endsWith(ext));
  }

  void _filterNotes() {
    final query = searchController.text.trim().toLowerCase();

    setState(() {
      _highlighted = null;
      if (query.isEmpty) {
        filteredNotes = List.from(notes);
        return;
      }

      final terms = query.split(' '); // Split search into words
      final searchTags = terms.where((t) => t.startsWith(RegExp(r'[#@+]'))).toSet();
      final searchText = terms.where((t) => !t.startsWith(RegExp(r'[#@+]'))).join(' ');

      filteredNotes = notes.where((note) {
        final filename = note.uri.pathSegments.last.toLowerCase();
        final noteTags = _extractTags(note.readAsStringSync());

        // ✅ Read file content ONLY if `Include File Content` is enabled
        final content = _includeFileContent ? note.readAsStringSync().toLowerCase() : '';

        // ✅ Match partial tags instead of requiring full matches
        final matchesTags = searchTags.every((tag) =>
            noteTags.any((noteTag) => noteTag.startsWith(tag)));

        if (!_includeFileContent) {
          return filename.contains(searchText) && matchesTags;
        } else {
          return (filename.contains(searchText) || content.contains(searchText)) && matchesTags;
        }
      }).toList();
    });
  }

  /// Search bar terms to locate inside an opened note, split like [_filterNotes].
  List<String> _noteSearchTerms() {
    final terms = searchController.text
        .trim()
        .split(' ')
        .where((t) => t.isNotEmpty && !t.startsWith(RegExp(r'[/:]')));
    final tags = terms.where((t) => t.startsWith(RegExp(r'[#@+]')));
    final text = terms.where((t) => !t.startsWith(RegExp(r'[#@+]'))).join(' ');
    return [if (text.isNotEmpty) text, ...tags];
  }

  void _moveHighlight(int step) {
    if (filteredNotes.isEmpty) return;
    final next = (_highlighted ?? -1) + step;
    setState(() {
      // Moving up past the first note clears the highlight, so Enter creates a note again.
      _highlighted = next < 0 ? null : next.clamp(0, filteredNotes.length - 1);
      if (_highlighted != null && _highlighted! >= _visibleLimit) {
        _visibleLimit = _highlighted! + 1;
      }
    });
    WidgetsBinding.instance.addPostFrameCallback((_) {
      final context = _highlightedKey.currentContext;
      if (context != null) {
        Scrollable.ensureVisible(context,
            alignmentPolicy: step > 0
                ? ScrollPositionAlignmentPolicy.keepVisibleAtEnd
                : ScrollPositionAlignmentPolicy.keepVisibleAtStart);
      }
    });
  }

  void _enterList() {
    if (filteredNotes.isEmpty) return;
    _listFocus.requestFocus();
    if (_highlighted == null) _moveHighlight(1);
  }

  void _leaveList() {
    setState(() => _highlighted = null);
    searchFocusNode.requestFocus();
  }

  void _listUp() {
    if ((_highlighted ?? 0) == 0) {
      _leaveList();
    } else {
      _moveHighlight(-1);
    }
  }

  /// Acts like tapping the blaster: clears the search, or opens the menu.
  void _pressBlaster() {
    if (searchFocusNode.hasFocus && searchController.text.isNotEmpty) {
      searchController.clear();
      return;
    }
    openMenuWithFocus(_menuKey);
  }

  void _openHighlighted() {
    if (_highlighted != null) _openNote(filteredNotes[_highlighted!]);
  }

  void _focusSearch() {
    searchFocusNode.requestFocus();
    searchController.selection = TextSelection(
        baseOffset: 0, extentOffset: searchController.text.length);
  }

  Future<void> _openNote(File noteFile) async {
    if (_useExternalEditor) {
      try {
        if (Platform.isLinux) {
          final result = await Process.run('which', ['xdg-open']);
          if (result.stdout.toString().trim().isNotEmpty) {
            await Process.run('xdg-open', [noteFile.path]);
          } else {
            print("❌ `xdg-open` is not available.");
          }
        } else if (Platform.isAndroid) {
          await _requestStoragePermission();
          final result = await OpenFilex.open(
            noteFile.path,
            type: "text/markdown",
          );
          print("✅ OpenFilex result: ${result.type}, message: ${result.message}");
        }
      } catch (e) {
        print("❌ Failed to open external editor: $e");
      }
    } else {
      final fromList = _listFocus.hasFocus;
      await Navigator.push(
        context,
        MaterialPageRoute(
          builder: (context) => NoteEditorScreen(
            note: noteFile,
            notesDirectoryPath: notesDirectoryPath,
            searchTerms: _noteSearchTerms(),
          ),
        ),
      );
      await _loadNotes(); // ✅ Reload notes after returning
      if (!mounted) return;
      final index = filteredNotes.indexWhere((n) => n.path == noteFile.path);
      if (fromList && index != -1) {
        setState(() => _highlighted = index);
        _listFocus.requestFocus();
      } else {
        searchFocusNode.requestFocus();
      }
    }
  }

  void _loadMoreNotes() {
    if (_isLoadingMore || _visibleNotes.length >= filteredNotes.length) return;

    setState(() => _isLoadingMore = true);

    Future.delayed(Duration(milliseconds: 200), () {
      setState(() {
        _visibleLimit += 20; // Load 20 more each time
        _visibleNotes = filteredNotes.take(_visibleLimit).toList();
        _isLoadingMore = false;
      });
    });
  }

  List<InlineSpan> _formatTags(String content) {
    final tagPattern = RegExp(r'([#@+][a-zA-Z0-9_]+)');
    final Set<String> tagSet = {}; // Avoid duplicate tags

    for (final match in tagPattern.allMatches(content)) {
      tagSet.add(match.group(0)!);
    }

    // Sort tags: +tags before @tags before #tags
    final sortedTags = tagSet.toList()
      ..sort((a, b) {
        if (a.startsWith('+') && !b.startsWith('+')) return -1;
        if (b.startsWith('+') && !a.startsWith('+')) return 1;
        if (a.startsWith('@') && !b.startsWith('@')) return -1;
        if (b.startsWith('@') && !a.startsWith('@')) return 1;
        return a.compareTo(b); // Default alphabetical order
      });

    return sortedTags.map((tag) {
      Color tagColor = Colors.white;
      if (tag.startsWith('#')) tagColor = Colors.pinkAccent;
      if (tag.startsWith('+')) tagColor = Colors.cyan;
      if (tag.startsWith('@')) tagColor = Colors.orange;

      return TextSpan(
        text: "$tag ",
        style: TextStyle(color: tagColor, fontWeight: FontWeight.bold),
      );
    }).toList();
  }

  void _createNewNote(String title) async {
    try {
      String notePath = title.trim();
      String? subfolder;
      String safeTitle;
      String extension = '.md'; // Default extension

      // ✅ Check if user specified an extension manually
      if (title.contains('.')) {
        final ext = path.extension(title);
        if (['.txt', '.markdown', '.md'].contains(ext)) {
          extension = ext;
        }
      }

      if (notePath.startsWith('/')) {
        final parts = notePath.split('/');
        parts.removeWhere((element) => element.isEmpty);
        if (parts.length > 1) {
          subfolder = parts.sublist(0, parts.length - 1).join('/');
        }
        safeTitle = _sanitizeFilename(parts.last.replaceAll(extension, '')); // Remove extension from input
      } else {
        safeTitle = _sanitizeFilename(title.replaceAll(extension, ''));
      }

      // Construct the final file path
      String fullPath = subfolder != null
          ? path.join(notesDirectoryPath!, subfolder, '$safeTitle$extension')
          : path.join(notesDirectoryPath!, '$safeTitle$extension');

      final newNote = File(fullPath);

      // Prevent duplicate note creation
      if (notes.any((note) => note.path == newNote.path)) {
        print("❌ Note already exists at: $fullPath");
        return;
      }

      // Ensure subfolder exists
      final parentDir = newNote.parent;
      if (!parentDir.existsSync()) {
        parentDir.createSync(recursive: true);
      }

      if (!newNote.existsSync()) {
        newNote.writeAsStringSync('# $safeTitle\n\n');
        setState(() {
          notes.add(newNote);
          filteredNotes.add(newNote);
        });

        Navigator.push(
          context,
          MaterialPageRoute(
            builder: (context) => NoteEditorScreen(
              note: newNote,
              notesDirectoryPath: notesDirectoryPath,
            ),
          ),
        );
      }
    } catch (e) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(
          content: Text('Failed to create note: $e'),
        ),
      );
    }
  }

  bool _isNewNote(String title) {
    String notePath = title.trim();
    String? subfolder;
    String safeTitle;

    if (notePath.startsWith('/')) {
      final parts = notePath.split('/');
      parts.removeWhere((element) => element.isEmpty);
      if (parts.length > 1) {
        subfolder = parts.sublist(0, parts.length - 1).join('/');
      }
      safeTitle = _sanitizeFilename(parts.last);
    } else {
      safeTitle = _sanitizeFilename(title);
    }

    // ✅ Allow multiple file extensions
    for (var ext in ['.md', '.txt', '.markdown']) {
      String fullPath = subfolder != null
          ? path.join(notesDirectoryPath!, subfolder, '$safeTitle$ext')
          : path.join(notesDirectoryPath!, '$safeTitle$ext');

      if (notes.any((note) => note.path == fullPath)) {
        return false; // A note with this name already exists
      }
    }

    return true;
  }

  String _sanitizeFilename(String title) {
    return title
        .replaceAll(RegExp(r'[<>:"/\\|?*]'), '') // Remove invalid characters
        .trim();
  }

  void _deleteNote(File note) {
    final rootTrashDir = Directory(path.join(notesDirectoryPath!, 'trash'));

    if (!rootTrashDir.existsSync()) {
      rootTrashDir.createSync(recursive: true);
    }

    // Define the base trashed file path
    String trashedPath = path.join(rootTrashDir.path, note.uri.pathSegments.last);
    File trashedNote = File(trashedPath);

    // If the file already exists in trash, append a timestamp to avoid conflicts
    if (trashedNote.existsSync()) {
      final timestamp = DateTime.now().millisecondsSinceEpoch;
      final newFileName = '${path.basenameWithoutExtension(note.path)}_$timestamp.md';
      trashedNote = File(path.join(rootTrashDir.path, newFileName));
    }

    // Move the file to trash
    note.renameSync(trashedNote.path);

    // Check if the original directory is now empty and delete it if needed
    _deleteEmptyParentFolders(note.parent);

    setState(() {
      notes.remove(note);
      filteredNotes.remove(note);
    });

    // ✅ Ensure we clear previous Snackbars
    ScaffoldMessenger.of(context).clearSnackBars();

    // ✅ Show Snackbar with automatic dismissal
    final snackBar = SnackBar(
      duration: const Duration(seconds: 3), // ✅ Auto-dismiss after 3 seconds
      content: Text('Note moved to trash'),
      action: SnackBarAction(
        label: 'Undo',
        onPressed: () {
          trashedNote.renameSync(note.path);
          setState(() {
            notes.add(note);
            filteredNotes.add(note);
          });
        },
      ),
    );

    // ✅ Show the Snackbar
    ScaffoldMessenger.of(context).showSnackBar(snackBar);

    // 🔥 Force dismiss after timeout in case it gets stuck
    Future.delayed(const Duration(seconds: 2), () {
      if (mounted) {
        ScaffoldMessenger.of(context).hideCurrentSnackBar();
      }
    });
  }

// ✅ Recursively deletes empty parent folders up to the notes directory
  void _deleteEmptyParentFolders(Directory folder) {
    if (folder.path == notesDirectoryPath) return; // Don't delete the root folder

    try {
      if (folder.existsSync() && folder.listSync().isEmpty) {
        folder.deleteSync();
        _deleteEmptyParentFolders(folder.parent); // Recursively check parent
      }
    } catch (e) {
      print("❌ Error deleting empty folder: $e");
    }
  }

  Future<void> _emptyTrash() async {
    final prefs = await SharedPreferences.getInstance();
    final notesPath = prefs.getString('notes_directory') ??
        (await getApplicationDocumentsDirectory()).path;
    final trashDir = Directory('$notesPath/trash');
    if (trashDir.existsSync()) {
      trashDir.deleteSync(recursive: true);
      trashDir.createSync();
    }
  }

  void _confirmEmptyTrash() {
    showDialog(
      context: context,
      builder: (context) {
        return AlertDialog(
          title: Text("Empty Trash"),
          content: Text(
              "Are you sure you want to permanently delete all trashed notes?"),
          actions: [
            TextButton(
              onPressed: () => Navigator.pop(context),
              child: Text("Cancel"),
            ),
            TextButton(
              onPressed: () {
                _emptyTrash();
                Navigator.pop(context);
              },
              child: Text("Empty Trash"),
            ),
          ],
        );
      },
    );
  }

  void _handleCommand(String text) {
    switch (text) {
      case ':tags':
        widget.toggleTags();
        break;
      case ':notags':
        widget.toggleTags();
        break;
      case ':day':
        widget.toggleTheme(false);
        break;
      case ':night':
        widget.toggleTheme(true);
        break;
      case ':extern':
        _toggleExternalEditor(true);
        break;
      case ':intern':
        _toggleExternalEditor(false);
        break;
      case ':emptytrash':
        _confirmEmptyTrash();
        break;
      case ':about':
        _showInfoPage(context, "About", aboutContent);
        break;
      case ':help':
        _showInfoPage(context, "Help", helpContent);
      default:
        return; // Do nothing for unrecognized commands
    }
    searchController.clear();
  }

  _showInfoPage(BuildContext context, String title, String content) {
    Navigator.push(
      context,
      MaterialPageRoute(
        builder: (context) => ReadOnlyPage(
          title: title,
          content: content,
        ),
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    return CallbackShortcuts(
      bindings: {
        primaryShortcut(LogicalKeyboardKey.keyL): _focusSearch,
        primaryShortcut(LogicalKeyboardKey.keyT): widget.toggleTags,
      },
      child: Scaffold(
      appBar: AppBar(
        title: Padding(
          padding: EdgeInsets.symmetric(horizontal: 10),
          child: CallbackShortcuts(
            bindings: dpadNavigation
                ? {
                    const SingleActivator(LogicalKeyboardKey.arrowDown):
                        _enterList,
                    const SingleActivator(LogicalKeyboardKey.arrowRight):
                        _pressBlaster,
                  }
                : {
                    const SingleActivator(LogicalKeyboardKey.arrowDown): () =>
                        _moveHighlight(1),
                    const SingleActivator(LogicalKeyboardKey.arrowUp): () =>
                        _moveHighlight(-1),
                  },
            child: TextField(
            focusNode: searchFocusNode,
            enableInteractiveSelection: true,
            autocorrect: false,
            textInputAction: TextInputAction.done,
            controller: searchController,
            cursorColor: Colors.orange,
            decoration: InputDecoration(
              hintText: 'Search or enter a command...',
              border: InputBorder.none,
            ),
            style: GoogleFonts.ibmPlexMono(color: Colors.grey[300]),
            // Keep focus after Enter so the list's shortcuts stay reachable.
            onEditingComplete: () {},
            onSubmitted: (text) {
              final trimmedText = text.trim();
              if (_highlighted != null) {
                _openNote(filteredNotes[_highlighted!]);
              } else if (trimmedText.isNotEmpty && _isNewNote(trimmedText)) {
                _createNewNote(trimmedText);
                searchController
                    .clear(); // Clears the search field after creation
              }
            },
          ),
          ),
        ),
        actions: [
          Padding(
            padding: EdgeInsets.symmetric(horizontal: 15),
            child: GestureDetector(
              onTap: () {
                if (searchController.text.isNotEmpty) {
                  searchController.clear();
                }
              },
              child: PopupMenuButton<String>(
                key: _menuKey,
                enabled: searchController.text.isEmpty,
                icon: SvgPicture.asset(
                  "assets/blaster.svg",
                  width: 30,
                  color: Colors.orange,
                ),
                onSelected: (String value) {
                  switch (value) {
                    case 'Toggle Tags':
                      widget.toggleTags();
                      break;
                    case 'Include Subdirectories':
                      _toggleIncludeSubdirectories(!_includeSubdirectories);
                      break;
                    case 'Include File Content':
                      _toggleIncludeFileContent(!_includeFileContent);
                      break;
                    case 'Toggle Theme':
                      setState(() {
                        widget.toggleTheme(!widget.isDarkMode);
                      });
                      break;
                    case 'External Editor':
                      _toggleExternalEditor(!_useExternalEditor);
                      break;
                    case 'Select Folder':
                      _showDirectoryChoiceDialog(
                          notesDirectoryPath ?? ''); // Re-trigger popup
                      break;
                    case 'Empty Trash':
                      _confirmEmptyTrash();
                      break;
                    case 'Help':
                      _showInfoPage(context, "Help", helpContent);
                      break;
                    case 'About':
                      _showInfoPage(context, "About", aboutContent);
                      break;
                    }
                },
                itemBuilder: (BuildContext context) => [
                  PopupMenuItem<String>(
                    value: 'Toggle Tags',
                    child: ListTile(
                      leading:
                          Icon(widget.showTags ? Icons.short_text : Icons.tag),
                      title: Text(widget.showTags ? 'Hide Tags' : 'Show Tags'),
                    ),
                  ),
                  PopupMenuItem<String>(
                    value: 'Toggle Theme',
                    child: ListTile(
                      leading: Icon(
                        Theme.of(context).brightness == Brightness.dark
                            ? Icons.light_mode
                            : Icons.dark_mode,
                      ),
                      title: Text(
                        Theme.of(context).brightness == Brightness.dark
                            ? 'Switch to Light Mode'
                            : 'Switch to Dark Mode',
                      ),
                    ),
                  ),
                  PopupMenuItem<String>(
                    value: 'Include Subdirectories',
                    child: ListTile(
                      leading: Icon(_includeSubdirectories ? Icons.file_copy_outlined : Icons.folder_copy_outlined),
                      title: Text(_includeSubdirectories ? 'Exclude Subdirectories' : 'Search Subdirectories'),
                    ),
                  ),
                  PopupMenuItem<String>(
                    value: 'Include File Content',
                    child: ListTile(
                      leading: Icon(
                        _includeFileContent ? Icons.highlight_off : Icons.file_open_outlined,
                      ),
                      title: Text(
                        _includeFileContent ? 'Exclude File Content' : 'Search File Content',
                      ),
                    ),
                  ),
                  PopupMenuItem<String>(
                    value: 'External Editor',
                    child: ListTile(
                      leading: Icon(
                        _useExternalEditor
                            ? Icons.open_in_new_off
                            : Icons.open_in_new,
                      ),
                      title: Text(
                        !_useExternalEditor
                            ? 'Use External Editor'
                            : 'Use Internal Editor',
                      ),
                    ),
                  ),
                  PopupMenuItem<String>(
                    value: 'Select Folder',
                    child: ListTile(
                      leading: Icon(Icons.folder_shared_outlined),
                      title: Text('Set Notes Directory'),
                    ),
                  ),
                  PopupMenuDivider(),
                  PopupMenuItem<String>(
                    value: 'Empty Trash',
                    child: ListTile(
                      leading: Icon(Icons.delete, color: Colors.redAccent),
                      title: Text('Empty Trash',
                          style: TextStyle(color: Colors.redAccent)),
                    ),
                  ),
                  PopupMenuDivider(),
                  PopupMenuItem<String>(
                    value: 'Help',
                    child: ListTile(
                      leading: Icon(Icons.help_outline),
                      title: Text('Help'),
                    ),
                  ),
                  PopupMenuItem<String>(
                    value: 'About',
                    child: ListTile(
                      leading: Icon(Icons.info_outline),
                      title: Text('About'),
                    ),
                  ),
                ],
              ),
            ),
          ),
        ],
      ),
      body: Padding(
        padding: EdgeInsets.only(left: 10),
        child: CallbackShortcuts(
          bindings: {
            const SingleActivator(LogicalKeyboardKey.arrowDown): () =>
                _moveHighlight(1),
            const SingleActivator(LogicalKeyboardKey.arrowUp): _listUp,
            const SingleActivator(LogicalKeyboardKey.arrowLeft): _leaveList,
            const SingleActivator(LogicalKeyboardKey.arrowRight):
                _pressBlaster,
            const SingleActivator(LogicalKeyboardKey.select): _openHighlighted,
            const SingleActivator(LogicalKeyboardKey.enter): _openHighlighted,
          },
          child: Focus(
            focusNode: _listFocus,
            child: NotificationListener<ScrollNotification>(
          onNotification: (ScrollNotification scrollInfo) {
            if (!_isLoadingMore && scrollInfo.metrics.pixels >= scrollInfo.metrics.maxScrollExtent - 100) {
              _loadMoreNotes(); // ✅ Lazy load when user scrolls
            }
            return false;
          },
          child: ListView.builder(
            itemCount: filteredNotes.length > _visibleLimit ? _visibleLimit + 1 : filteredNotes.length,
            itemBuilder: (context, index) {
              if (index == _visibleLimit && filteredNotes.length > _visibleLimit) {
                return Center(
                  child: Padding(
                    padding: EdgeInsets.all(10),
                    child: CircularProgressIndicator(), // ✅ Show loading indicator
                  ),
                );
              }

              final noteFile = filteredNotes[index];
              final noteContent = _includeFileContent ? noteFile.readAsStringSync() : ""; // ✅ Read content only if needed
              final tagSpans = _formatTags(noteContent).isNotEmpty
                  ? _formatTags(noteContent)
                  : [TextSpan(text: '')];

              return Dismissible(
                key: Key(noteFile.path),
                direction: DismissDirection.endToStart,
                background: Container(
                  color: Colors.redAccent,
                  alignment: Alignment.centerRight,
                  padding: EdgeInsets.symmetric(horizontal: 20),
                  child: Icon(Icons.delete, color: Colors.white),
                ),
                onDismissed: (direction) => _deleteNote(noteFile),
                child: ListTile(
                  key: index == _highlighted ? _highlightedKey : null,
                  selected: index == _highlighted,
                  selectedColor: Colors.orange,
                  selectedTileColor: Colors.orange.withAlpha(30),
                  title: Text(noteFile.uri.pathSegments.last.replaceAll('.md', '')),
                  subtitle: LayoutBuilder(
                    builder: (context, constraints) {
                      final bool hasEnoughSpace = constraints.maxWidth > 200; // Adjust threshold

                      return Row(
                        children: [
                          if (path.relative(path.dirname(noteFile.path), from: notesDirectoryPath!) != ".")
                            Padding(
                              padding: EdgeInsets.only(right: 8),
                              child: Text(
                                path.relative(path.dirname(noteFile.path), from: notesDirectoryPath!),
                                style: TextStyle(color: Colors.blueGrey),
                              ),
                            ),
                          if (widget.showTags && hasEnoughSpace && noteTags[noteFile]?.isNotEmpty == true)
                            Expanded(
                              child: RichText(
                                text: TextSpan(
                                  style: DefaultTextStyle.of(context).style,
                                  children: _formatTags(noteTags[noteFile]!.join(' ')), // ✅ Use stored tags
                                ),
                                overflow: TextOverflow.ellipsis,
                              ),
                            ),
                        ],
                      );
                    },
                  ),
                  onTap: () => _openNote(noteFile),
                ),
              );
            },
          ),
        ),
          ),
        ),
      ),
      ),
    );
  }
}