import 'dart:io';
import 'package:background_downloader/background_downloader.dart';
import 'package:file_picker/file_picker.dart';
import 'package:flutter/material.dart';
import 'package:path_provider/path_provider.dart';
import 'package:provider/provider.dart';
import '../controllers/session_controller.dart';
import '../controllers/upload_controller.dart';
import '../core/app_theme.dart';
import '../models/drive_models.dart';
import '../services/api_client.dart';
import '../services/token_store.dart';
import 'gallery_screen.dart';
import 'upload_history_screen.dart';

class DriveScreen extends StatefulWidget {
  const DriveScreen({super.key});
  @override
  State<DriveScreen> createState() => _DriveScreenState();
}

class _DriveScreenState extends State<DriveScreen> {
  final List<DriveFolder> _path = [];
  List<DriveFolder> _folders = [];
  List<DriveFile> _files = [];
  bool _loading = true;
  String? _error;
  String? _token;
  UploadController? _uploadController;
  int _completedVersion = 0;
  int _loadGeneration = 0;
  bool _uploadRefreshScheduled = false;
  String? get _folderId => _path.isEmpty ? null : _path.last.id;

  @override
  void initState() {
    super.initState();
    const TokenStore().read().then((value) {
      if (mounted) setState(() => _token = value);
    });
    _load();
  }

  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    context.read<UploadController>().selectOrganization(
      context.read<SessionController>().organizationId,
    );
    final controller = context.read<UploadController>();
    if (_uploadController == controller) return;
    _uploadController?.removeListener(_onUploadChanged);
    _uploadController = controller..addListener(_onUploadChanged);
    _completedVersion = controller.completedVersion;
  }

  void _onUploadChanged() {
    final version = _uploadController?.completedVersion ?? 0;
    if (version == _completedVersion || _uploadRefreshScheduled) return;
    _completedVersion = version;
    _uploadRefreshScheduled = true;
    WidgetsBinding.instance.addPostFrameCallback((_) {
      _uploadRefreshScheduled = false;
      if (mounted) _load();
    });
  }

  @override
  void dispose() {
    _uploadController?.removeListener(_onUploadChanged);
    super.dispose();
  }

  Future<void> _load() async {
    if (!mounted) return;
    final generation = ++_loadGeneration;
    setState(() {
      _loading = true;
      _error = null;
    });
    try {
      final api = context.read<ApiClient>();
      final values = await Future.wait([
        api.folders(_folderId),
        api.files(_folderId),
      ]);
      if (!mounted || generation != _loadGeneration) return;
      setState(() {
        _folders = values[0] as List<DriveFolder>;
        _files = values[1] as List<DriveFile>;
      });
    } catch (error) {
      if (mounted && generation == _loadGeneration) {
        setState(() => _error = context.read<ApiClient>().messageFrom(error));
      }
    } finally {
      if (mounted && generation == _loadGeneration) {
        setState(() => _loading = false);
      }
    }
  }

  Future<void> _createFolder() async {
    final name = await showDialog<String>(
      context: context,
      builder: (_) => const _CreateFolderDialog(),
    );
    if (name == null || name.isEmpty || !mounted) return;
    try {
      await context.read<ApiClient>().createFolder(name, _folderId);
      await _load();
    } catch (error) {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text(context.read<ApiClient>().messageFrom(error))),
        );
      }
    }
  }

  Future<void> _deleteFile(DriveFile file) async {
    if (!await _confirm('Delete ${file.name}?')) return;
    if (!mounted) return;
    try {
      await context.read<ApiClient>().deleteFile(file.id);
      await _load();
    } catch (error) {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text(context.read<ApiClient>().messageFrom(error))),
        );
      }
    }
  }

  Future<void> _deleteFolder(DriveFolder folder) async {
    if (!await _confirm('Delete the empty folder “${folder.name}”?')) return;
    if (!mounted) return;
    try {
      await context.read<ApiClient>().deleteFolder(folder.id);
      await _load();
    } catch (error) {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text(context.read<ApiClient>().messageFrom(error))),
        );
      }
    }
  }

  Future<bool> _confirm(String text) async =>
      await showDialog<bool>(
        context: context,
        builder: (context) => AlertDialog(
          title: const Text('Confirm deletion'),
          content: Text(text),
          actions: [
            TextButton(
              onPressed: () => Navigator.pop(context, false),
              child: const Text('Keep'),
            ),
            FilledButton(
              onPressed: () => Navigator.pop(context, true),
              child: const Text('Delete'),
            ),
          ],
        ),
      ) ??
      false;

  Future<void> _openGallery() async {
    await Navigator.of(context).push(
      MaterialPageRoute(builder: (_) => GalleryScreen(folderId: _folderId)),
    );
    if (mounted) _load();
  }

  Future<void> _pickFiles() async {
    final result = await FilePicker.pickFiles(
      allowMultiple: true,
      type: FileType.any,
      withData: false,
    );
    if (result == null || !mounted) return;
    final support = await getApplicationSupportDirectory();
    final queue = Directory(
      '${support.path}${Platform.pathSeparator}upload_queue',
    );
    await queue.create(recursive: true);
    var queued = 0;
    for (var index = 0; index < result.files.length; index++) {
      final selected = result.files[index];
      if (selected.path == null) continue;
      final original = selected.name.replaceAll(RegExp(r'[\\/:*?"<>|]'), '_');
      final stagedName =
          '${DateTime.now().microsecondsSinceEpoch}_$index-$original';
      await File(
        selected.path!,
      ).copy('${queue.path}${Platform.pathSeparator}$stagedName');
      if (!mounted) return;
      await context.read<UploadController>().enqueue(
        filename: stagedName,
        displayName: original,
        folderId: _folderId,
      );
      queued++;
    }
    if (mounted) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text('$queued file(s) added to the upload queue.')),
      );
    }
  }

  void _showUploadSources() {
    showModalBottomSheet(
      context: context,
      showDragHandle: true,
      builder: (sheetContext) => SafeArea(
        child: Padding(
          padding: const EdgeInsets.fromLTRB(16, 0, 16, 24),
          child: Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              ListTile(
                leading: const Icon(Icons.photo_library_outlined),
                title: const Text('Photos and videos'),
                subtitle: const Text(
                  'Browse the gallery inside Metatron-Drive',
                ),
                onTap: () {
                  Navigator.pop(sheetContext);
                  _openGallery();
                },
              ),
              ListTile(
                leading: const Icon(Icons.attach_file_rounded),
                title: const Text('Any file'),
                subtitle: const Text(
                  'Documents, audio, archives, PDFs, and more',
                ),
                onTap: () {
                  Navigator.pop(sheetContext);
                  _pickFiles();
                },
              ),
            ],
          ),
        ),
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    final session = context.watch<SessionController>();
    final user = session.user!;
    final membership = session.membership;
    return PopScope(
      canPop: _path.isEmpty,
      onPopInvokedWithResult: (didPop, result) {
        if (!didPop && _path.isNotEmpty) {
          setState(() => _path.removeLast());
          _load();
        }
      },
      child: Scaffold(
        appBar: AppBar(
          title: Column(
            crossAxisAlignment: CrossAxisAlignment.start,
            children: [
              Text(
                _path.isEmpty
                    ? membership?.organization.name ?? 'Metatron-Drive'
                    : _path.last.name,
                style: const TextStyle(fontWeight: FontWeight.w800),
              ),
              Text(
                'Hello, ${user.name.split(' ').first} • ${membership?.organization.code ?? ''}',
                style: const TextStyle(
                  fontSize: 12,
                  fontWeight: FontWeight.normal,
                  color: Colors.black54,
                ),
              ),
            ],
          ),
          actions: [
            PopupMenuButton<String>(
              tooltip: 'Switch organization',
              icon: const Icon(Icons.business_outlined),
              onSelected: session.selectOrganization,
              itemBuilder: (_) => user.approvedMemberships
                  .map(
                    (item) => PopupMenuItem(
                      value: item.organization.id,
                      child: Row(
                        children: [
                          if (item.organization.id == session.organizationId)
                            const Padding(
                              padding: EdgeInsets.only(right: 8),
                              child: Icon(Icons.check, size: 18),
                            ),
                          Text(item.organization.name),
                        ],
                      ),
                    ),
                  )
                  .toList(),
            ),
            IconButton(
              onPressed: () => Navigator.of(context).push(
                MaterialPageRoute(builder: (_) => const UploadHistoryScreen()),
              ),
              tooltip: 'Upload history',
              icon: const Icon(Icons.history_rounded),
            ),
            IconButton(
              onPressed: _load,
              tooltip: 'Refresh',
              icon: const Icon(Icons.refresh_rounded),
            ),
            IconButton(
              onPressed: () =>
                  _showProfile(user.name, user.username, user.email),
              tooltip: 'Profile',
              icon: CircleAvatar(
                radius: 16,
                backgroundColor: AppTheme.navy,
                child: Text(
                  user.name.substring(0, 1).toUpperCase(),
                  style: const TextStyle(color: Colors.white),
                ),
              ),
            ),
            const SizedBox(width: 8),
          ],
        ),
        body: RefreshIndicator(
          onRefresh: _load,
          child: CustomScrollView(
            slivers: [
              SliverToBoxAdapter(
                child: _DriveHeader(
                  path: _path,
                  onRoot: () {
                    setState(_path.clear);
                    _load();
                  },
                  onCreate: _createFolder,
                  onFiles: _pickFiles,
                ),
              ),
              if (_loading)
                const SliverFillRemaining(
                  child: Center(child: CircularProgressIndicator()),
                )
              else if (_error != null)
                SliverFillRemaining(
                  child: _EmptyState(
                    icon: Icons.cloud_off_rounded,
                    title: 'Could not load your drive',
                    subtitle: _error!,
                    action: _load,
                  ),
                )
              else if (_folders.isEmpty && _files.isEmpty)
                SliverFillRemaining(
                  hasScrollBody: false,
                  child: _EmptyState(
                    icon: Icons.cloud_upload_outlined,
                    title: 'This folder is empty',
                    subtitle:
                        'Choose media from your gallery or create a folder.',
                    action: _openGallery,
                  ),
                )
              else ...[
                if (_folders.isNotEmpty)
                  const SliverToBoxAdapter(
                    child: Padding(
                      padding: EdgeInsets.fromLTRB(20, 12, 20, 8),
                      child: Text(
                        'Folders',
                        style: TextStyle(
                          fontSize: 17,
                          fontWeight: FontWeight.w700,
                        ),
                      ),
                    ),
                  ),
                SliverPadding(
                  padding: const EdgeInsets.symmetric(horizontal: 16),
                  sliver: SliverGrid.builder(
                    gridDelegate:
                        const SliverGridDelegateWithMaxCrossAxisExtent(
                          maxCrossAxisExtent: 220,
                          childAspectRatio: 1.55,
                          mainAxisSpacing: 10,
                          crossAxisSpacing: 10,
                        ),
                    itemCount: _folders.length,
                    itemBuilder: (context, index) {
                      final folder = _folders[index];
                      return _FolderCard(
                        folder: folder,
                        onOpen: () {
                          setState(() => _path.add(folder));
                          _load();
                        },
                        onDelete: () => _deleteFolder(folder),
                      );
                    },
                  ),
                ),
                if (_files.isNotEmpty)
                  const SliverToBoxAdapter(
                    child: Padding(
                      padding: EdgeInsets.fromLTRB(20, 20, 20, 8),
                      child: Text(
                        'Files',
                        style: TextStyle(
                          fontSize: 17,
                          fontWeight: FontWeight.w700,
                        ),
                      ),
                    ),
                  ),
                SliverPadding(
                  padding: const EdgeInsets.fromLTRB(16, 0, 16, 120),
                  sliver: SliverGrid.builder(
                    gridDelegate:
                        const SliverGridDelegateWithMaxCrossAxisExtent(
                          maxCrossAxisExtent: 190,
                          childAspectRatio: .82,
                          mainAxisSpacing: 10,
                          crossAxisSpacing: 10,
                        ),
                    itemCount: _files.length,
                    itemBuilder: (context, index) => _FileCard(
                      file: _files[index],
                      token: _token,
                      api: context.read<ApiClient>(),
                      organizationId: session.organizationId,
                      onDelete: () => _deleteFile(_files[index]),
                    ),
                  ),
                ),
              ],
            ],
          ),
        ),
        floatingActionButton: FloatingActionButton.extended(
          onPressed: _showUploadSources,
          icon: const Icon(Icons.cloud_upload_outlined),
          label: const Text('Upload'),
        ),
        bottomSheet: const _UploadStrip(),
      ),
    );
  }

  void _showProfile(String name, String username, String email) {
    showModalBottomSheet(
      context: context,
      showDragHandle: true,
      builder: (sheetContext) => Padding(
        padding: const EdgeInsets.fromLTRB(24, 8, 24, 32),
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
            CircleAvatar(
              radius: 34,
              backgroundColor: AppTheme.navy,
              child: Text(
                name.substring(0, 1).toUpperCase(),
                style: const TextStyle(fontSize: 26, color: Colors.white),
              ),
            ),
            const SizedBox(height: 12),
            Text(
              name,
              style: const TextStyle(fontSize: 21, fontWeight: FontWeight.w700),
            ),
            Text(
              '@$username • $email',
              style: const TextStyle(color: Colors.black54),
            ),
            const SizedBox(height: 22),
            OutlinedButton.icon(
              onPressed: () {
                Navigator.pop(sheetContext);
                _joinOrganization();
              },
              icon: const Icon(Icons.group_add_outlined),
              label: const Text('Join another organization'),
            ),
            const SizedBox(height: 8),
            OutlinedButton.icon(
              onPressed: () {
                Navigator.pop(sheetContext);
                context.read<SessionController>().logout();
              },
              icon: const Icon(Icons.logout),
              label: const Text('Sign out'),
            ),
            const SizedBox(height: 8),
            TextButton.icon(
              onPressed: () {
                Navigator.pop(sheetContext);
                _confirmAccountDeletion();
              },
              style: TextButton.styleFrom(foregroundColor: Colors.red),
              icon: const Icon(Icons.person_remove_outlined),
              label: const Text('Delete database account'),
            ),
          ],
        ),
      ),
    );
  }

  Future<void> _joinOrganization() async {
    final code = TextEditingController();
    final submitted = await showDialog<bool>(
      context: context,
      builder: (dialogContext) => AlertDialog(
        title: const Text('Join an organization'),
        content: TextField(
          controller: code,
          textCapitalization: TextCapitalization.characters,
          decoration: const InputDecoration(labelText: 'Organization code'),
        ),
        actions: [
          TextButton(
            onPressed: () => Navigator.pop(dialogContext, false),
            child: const Text('Cancel'),
          ),
          FilledButton(
            onPressed: () => Navigator.pop(dialogContext, true),
            child: const Text('Submit request'),
          ),
        ],
      ),
    );
    if (submitted != true || !mounted) {
      code.dispose();
      return;
    }
    try {
      final message = await context.read<ApiClient>().joinOrganization(
        code.text.trim().toUpperCase(),
      );
      if (mounted) {
        await context.read<SessionController>().refreshProfile();
        if (mounted) {
          ScaffoldMessenger.of(
            context,
          ).showSnackBar(SnackBar(content: Text(message)));
        }
      }
    } catch (error) {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text(context.read<ApiClient>().messageFrom(error))),
        );
      }
    } finally {
      code.dispose();
    }
  }

  Future<void> _confirmAccountDeletion() async {
    final password = TextEditingController();
    final confirmed = await showDialog<bool>(
      context: context,
      builder: (dialogContext) => AlertDialog(
        title: const Text('Delete account data?'),
        content: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
            const Text(
              'Your profile, folders, and file records will be removed from the database. Existing Google Drive files will be retained.',
            ),
            const SizedBox(height: 16),
            TextField(
              controller: password,
              obscureText: true,
              decoration: const InputDecoration(labelText: 'Confirm password'),
            ),
          ],
        ),
        actions: [
          TextButton(
            onPressed: () => Navigator.pop(dialogContext, false),
            child: const Text('Cancel'),
          ),
          FilledButton(
            onPressed: () => Navigator.pop(dialogContext, true),
            style: FilledButton.styleFrom(backgroundColor: Colors.red),
            child: const Text('Delete database data'),
          ),
        ],
      ),
    );
    if (confirmed != true || !mounted) {
      password.dispose();
      return;
    }
    try {
      await context.read<SessionController>().deleteAccount(password.text);
    } catch (error) {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text(context.read<ApiClient>().messageFrom(error))),
        );
      }
    } finally {
      password.dispose();
    }
  }
}

class _DriveHeader extends StatelessWidget {
  const _DriveHeader({
    required this.path,
    required this.onRoot,
    required this.onCreate,
    required this.onFiles,
  });
  final List<DriveFolder> path;
  final VoidCallback onRoot;
  final VoidCallback onCreate;
  final VoidCallback onFiles;
  @override
  Widget build(BuildContext context) => Padding(
    padding: const EdgeInsets.fromLTRB(16, 8, 16, 6),
    child: Column(
      children: [
        Card(
          child: Padding(
            padding: const EdgeInsets.all(18),
            child: Row(
              children: [
                const CircleAvatar(
                  backgroundColor: Color(0xFFE8EEFF),
                  child: Icon(Icons.lock_outline_rounded, color: AppTheme.blue),
                ),
                const SizedBox(width: 14),
                const Expanded(
                  child: Column(
                    crossAxisAlignment: CrossAxisAlignment.start,
                    children: [
                      Text(
                        'Private workspace',
                        style: TextStyle(fontWeight: FontWeight.w700),
                      ),
                      Text(
                        'Original quality • protected access',
                        style: TextStyle(fontSize: 12, color: Colors.black54),
                      ),
                    ],
                  ),
                ),
                IconButton(
                  onPressed: onFiles,
                  tooltip: 'Upload any file',
                  icon: const Icon(Icons.attach_file_rounded),
                ),
                IconButton(
                  onPressed: onCreate,
                  tooltip: 'Create folder',
                  icon: const Icon(Icons.create_new_folder_outlined),
                ),
              ],
            ),
          ),
        ),
        if (path.isNotEmpty)
          Align(
            alignment: Alignment.centerLeft,
            child: TextButton.icon(
              onPressed: onRoot,
              icon: const Icon(Icons.home_outlined, size: 18),
              label: Text(
                'Metatron-Drive / ${path.map((item) => item.name).join(' / ')}',
                maxLines: 1,
                overflow: TextOverflow.ellipsis,
              ),
            ),
          ),
      ],
    ),
  );
}

class _FolderCard extends StatelessWidget {
  const _FolderCard({
    required this.folder,
    required this.onOpen,
    required this.onDelete,
  });
  final DriveFolder folder;
  final VoidCallback onOpen;
  final VoidCallback onDelete;
  @override
  Widget build(BuildContext context) => Card(
    child: InkWell(
      borderRadius: BorderRadius.circular(20),
      onTap: onOpen,
      child: Padding(
        padding: const EdgeInsets.all(14),
        child: Row(
          children: [
            const Icon(
              Icons.folder_rounded,
              color: Color(0xFFFFB547),
              size: 38,
            ),
            const SizedBox(width: 10),
            Expanded(
              child: Column(
                mainAxisAlignment: MainAxisAlignment.center,
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text(
                    folder.name,
                    maxLines: 2,
                    overflow: TextOverflow.ellipsis,
                    style: const TextStyle(fontWeight: FontWeight.w700),
                  ),
                  Text(
                    '${folder.childCount} folders • ${folder.fileCount} files',
                    style: const TextStyle(fontSize: 11, color: Colors.black54),
                  ),
                ],
              ),
            ),
            PopupMenuButton(
              onSelected: (_) => onDelete(),
              itemBuilder: (_) => const [
                PopupMenuItem(
                  value: 'delete',
                  child: Text('Delete empty folder'),
                ),
              ],
            ),
          ],
        ),
      ),
    ),
  );
}

class _FileCard extends StatelessWidget {
  const _FileCard({
    required this.file,
    required this.token,
    required this.api,
    required this.organizationId,
    required this.onDelete,
  });
  final DriveFile file;
  final String? token;
  final ApiClient api;
  final String? organizationId;
  final VoidCallback onDelete;
  @override
  Widget build(BuildContext context) => Card(
    clipBehavior: Clip.antiAlias,
    child: Column(
      crossAxisAlignment: CrossAxisAlignment.stretch,
      children: [
        Expanded(
          child: ColoredBox(
            color: const Color(0xFFF0F3F9),
            child: file.isImage && token != null
                ? Image.network(
                    api.contentUrl(file.id),
                    headers: {
                      'Authorization': 'Bearer $token',
                      ..._organizationHeader(organizationId),
                    },
                    fit: BoxFit.cover,
                    errorBuilder: (_, _, _) =>
                        const Icon(Icons.broken_image_outlined, size: 42),
                  )
                : Icon(
                    file.isVideo
                        ? Icons.play_circle_outline_rounded
                        : Icons.insert_drive_file_outlined,
                    size: 48,
                    color: AppTheme.blue,
                  ),
          ),
        ),
        Padding(
          padding: const EdgeInsets.fromLTRB(12, 8, 4, 8),
          child: Row(
            children: [
              Expanded(
                child: Column(
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: [
                    Text(
                      file.name,
                      maxLines: 1,
                      overflow: TextOverflow.ellipsis,
                      style: const TextStyle(fontWeight: FontWeight.w600),
                    ),
                    Text(
                      _size(file.sizeBytes),
                      style: const TextStyle(
                        fontSize: 11,
                        color: Colors.black54,
                      ),
                    ),
                  ],
                ),
              ),
              PopupMenuButton(
                onSelected: (_) => onDelete(),
                itemBuilder: (_) => const [
                  PopupMenuItem(value: 'delete', child: Text('Delete')),
                ],
              ),
            ],
          ),
        ),
      ],
    ),
  );
  static String _size(int bytes) => bytes < 1024 * 1024
      ? '${(bytes / 1024).toStringAsFixed(1)} KB'
      : '${(bytes / 1024 / 1024).toStringAsFixed(1)} MB';
}

Map<String, String> _organizationHeader(String? organizationId) =>
    organizationId == null ? const {} : {'X-Organization-Id': organizationId};

class _UploadStrip extends StatelessWidget {
  const _UploadStrip();
  @override
  Widget build(BuildContext context) => Consumer<UploadController>(
    builder: (context, uploads, _) {
      final active = uploads.uploads
          .where(
            (item) => !const {
              TaskStatus.complete,
              TaskStatus.failed,
              TaskStatus.canceled,
            }.contains(item.status),
          )
          .toList();
      if (active.isEmpty) return const SizedBox.shrink();
      final item = active.first;
      return Material(
        elevation: 10,
        color: AppTheme.navy,
        child: InkWell(
          onTap: () => Navigator.of(context).push(
            MaterialPageRoute(builder: (_) => const UploadHistoryScreen()),
          ),
          child: SafeArea(
            top: false,
            child: Padding(
              padding: const EdgeInsets.fromLTRB(16, 10, 12, 10),
              child: Row(
                children: [
                  const Icon(Icons.cloud_upload_outlined, color: Colors.white),
                  const SizedBox(width: 12),
                  Expanded(
                    child: Column(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      mainAxisSize: MainAxisSize.min,
                      children: [
                        Text(
                          '${active.length} upload${active.length == 1 ? '' : 's'} active',
                          style: const TextStyle(
                            color: Colors.white,
                            fontWeight: FontWeight.w700,
                          ),
                        ),
                        const SizedBox(height: 4),
                        LinearProgressIndicator(
                          value: item.progress,
                          minHeight: 4,
                          backgroundColor: Colors.white24,
                          color: AppTheme.mint,
                        ),
                      ],
                    ),
                  ),
                  IconButton(
                    onPressed: () => uploads.cancel(item.taskId),
                    icon: const Icon(Icons.close, color: Colors.white70),
                  ),
                ],
              ),
            ),
          ),
        ),
      );
    },
  );
}

class _CreateFolderDialog extends StatefulWidget {
  const _CreateFolderDialog();

  @override
  State<_CreateFolderDialog> createState() => _CreateFolderDialogState();
}

class _CreateFolderDialogState extends State<_CreateFolderDialog> {
  String _name = '';
  bool _submitted = false;

  void _submit() {
    final value = _name.trim();
    if (_submitted || value.isEmpty) return;
    _submitted = true;
    Navigator.of(context).pop(value);
  }

  @override
  Widget build(BuildContext context) => AlertDialog(
    title: const Text('New folder'),
    content: TextFormField(
      autofocus: true,
      textCapitalization: TextCapitalization.words,
      decoration: const InputDecoration(labelText: 'Folder name'),
      onChanged: (value) => _name = value,
      onFieldSubmitted: (_) => _submit(),
    ),
    actions: [
      TextButton(
        onPressed: () => Navigator.of(context).pop(),
        child: const Text('Cancel'),
      ),
      FilledButton(onPressed: _submit, child: const Text('Create')),
    ],
  );
}

class _EmptyState extends StatelessWidget {
  const _EmptyState({
    required this.icon,
    required this.title,
    required this.subtitle,
    required this.action,
  });
  final IconData icon;
  final String title;
  final String subtitle;
  final VoidCallback action;
  @override
  Widget build(BuildContext context) => Center(
    child: Padding(
      padding: const EdgeInsets.all(36),
      child: Column(
        mainAxisSize: MainAxisSize.min,
        children: [
          Icon(icon, size: 62, color: AppTheme.blue),
          const SizedBox(height: 16),
          Text(
            title,
            style: const TextStyle(fontSize: 20, fontWeight: FontWeight.w700),
          ),
          const SizedBox(height: 6),
          Text(
            subtitle,
            textAlign: TextAlign.center,
            style: const TextStyle(color: Colors.black54),
          ),
          const SizedBox(height: 18),
          OutlinedButton(onPressed: action, child: const Text('Try again')),
        ],
      ),
    ),
  );
}