import 'dart:convert';
import 'package:chepuhagram/core/constants.dart';
import 'package:chepuhagram/domain/services/api_service.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../widgets/contact_tile.dart';
import '../screens/settings_screen.dart';
import '../screens/new_chat_screen.dart';
import '../screens/chat_screen.dart';
import '/logic/contact_provider.dart';
import 'package:cached_network_image/cached_network_image.dart';
import '/logic/auth_provider.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'package:chepuhagram/domain/services/crypto_service.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:chepuhagram/main.dart';
import 'dart:async';
import 'package:http/http.dart' as http;
import 'package:package_info_plus/package_info_plus.dart';
import 'dart:io';
import 'package:dio/dio.dart';
import 'package:path_provider/path_provider.dart';
import 'package:open_filex/open_filex.dart';
import '/data/datasources/ws_client.dart';

class ContactsScreen extends StatefulWidget {
  final int? targetChatId;

  const ContactsScreen({super.key, this.targetChatId});

  @override
  State<ContactsScreen> createState() => _ContactsScreenState();
}

class _ContactsScreenState extends State<ContactsScreen> with RouteAware {
  static const String _notificationLaunchKey = 'notification_launch_data';
  StreamSubscription<dynamic>? _socketSubscription;
  bool _isDownloading = false;
  double _downloadProgress = 0.0;
  int _downloadedBytes = 0;
  int _downloadTotalBytes = 0;
  int _apkFileSizeBytes = 0;
  CancelToken? _cancelToken = CancelToken();
  String? _latestApkUrl;
  bool _showUpdateBanner = false;
  bool _contactsLoaded = false;
  Timer? _contactLoadTimer;

  @override
  void initState() {
    super.initState();
    print('ContactsScreen initState, targetChatId: ${widget.targetChatId}');
    _setupPushNotifications();
    final socketService = Provider.of<SocketService>(context, listen: false);
    _socketSubscription = socketService.messages.listen(_handleIncomingMessage);
    WidgetsBinding.instance.addPostFrameCallback((_) {
      final authProvider = context.read<AuthProvider>();
      final contactProvider = context.read<ContactProvider>();

      // Установить текущего пользователя и загрузить контакты с сообщениями
      print(
        'Setting current user ID in ContactProvider: ${authProvider.currentUserId}',
      );
      contactProvider.setCurrentUserId(authProvider.currentUserId);
      _startContactsLoadTimer();
    });
  }

  Future<void> _startContactsLoadTimer() async {
    if (_contactLoadTimer != null && _contactLoadTimer!.isActive) return;
    _contactLoadTimer = Timer(const Duration(seconds: 2), () {
      _initContacts();
    });
  }

  Future<void> _initContacts() async {
    if (_contactsLoaded) return; // Предотвращаем повторную загрузку
    final contactProvider = context.read<ContactProvider>();
    // Ждем завершения загрузки контактов
    await contactProvider.loadContacts();

    print('Contacts loaded, checking targetChatId: ${widget.targetChatId}');

    WidgetsBinding.instance.addPostFrameCallback((_) {
      _checkAppUpdate();
    });

    // Дальнейшая логика выполнится только после того, как loadContacts завершится
    if (widget.targetChatId != null) {
      _navigateToTargetChat();
    } else {
      _checkSavedNotificationTarget();
    }
    _contactLoadTimer?.cancel();
    _contactLoadTimer = null;
    _contactsLoaded = true;
  }

  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    routeObserver.subscribe(this, ModalRoute.of(context) as PageRoute);
  }

  @override
  void didPopNext() {
    print("Пользователь вернулся на этот экран!");
    _refreshData();
  }

  @override
  void dispose() {
    routeObserver.unsubscribe(this);
    _socketSubscription?.cancel();
    super.dispose();
  }

  void _refreshData() {
    print("Обновляем данные контактов и сообщений...");
    final contactProvider = context.read<ContactProvider>();

    contactProvider.loadContacts();
  }

  Future<void> _checkSavedNotificationTarget() async {
    final prefs = await SharedPreferences.getInstance();
    final savedData = prefs.getString(_notificationLaunchKey);
    if (savedData == null) {
      print('No saved notification data found in SharedPreferences');
      return;
    }

    try {
      final data = jsonDecode(savedData) as Map<String, dynamic>;
      print('Recovered saved notification data: $data');
      final senderId = int.tryParse(data['sender_id']?.toString() ?? '');
      final type = data['type']?.toString();

      // Поддерживаем старый payload (только sender_id) и новый (type+sender_id)
      if (senderId != null && (type == null || type == 'enc_message')) {
        print('Recovered targetChatId from saved data: $senderId');

        await prefs.remove(_notificationLaunchKey);
        _navigateToTargetChatWithId(senderId);
        return;
      }

      print('Saved notification data is not a valid payload: $data');
      await prefs.remove(_notificationLaunchKey);
    } catch (e) {
      print('Error parsing saved notification data: $e');
      await prefs.remove(_notificationLaunchKey);
    }
  }

  void _navigateToTargetChat() {
    if (widget.targetChatId == null) return;

    _navigateToTargetChatWithId(widget.targetChatId!);
  }

  void _navigateToTargetChatWithId(int targetChatId) async {
    print('_navigateToTargetChat called with targetChatId: $targetChatId');
    final contactProvider = context.read<ContactProvider>();
    try {
      final contact = contactProvider.contacts.firstWhere(
        (c) => c.id == targetChatId,
      );
      print('Auto-navigating to chat with contact: ${contact.username}');
      currentActiveChatContactId = targetChatId; // Устанавливаем активный чат
      final result = await Navigator.push(
        context,
        MaterialPageRoute(builder: (_) => ChatScreen(contact: contact)),
      );
      if (result != null) {
        _refreshData(); // Обновляем данные при возвращении с чата, если нужно
      }
    } catch (e) {
      print('Target contact with id $targetChatId not found: $e');
    }
  }

  Future<void> _checkAppUpdate() async {
    print('Проверка обновлений');
    PackageInfo packageInfo = await PackageInfo.fromPlatform();
    try {
      // 1. Запрос к вашему FastAPI
      final response = await http.get(
        Uri.parse('${AppConstants.baseUrl}/check-update'),
      );
      if (response.statusCode == 200) {
        final data = jsonDecode(response.body);
        final String latestVersion = data['latest_version'];
        print('444444');
        print(latestVersion);
        print(packageInfo.version);
        // Сравнение версий (предположим, у вас есть способ получить текущую версию)
        if (latestVersion != packageInfo.version) {
          setState(() {
            _showUpdateBanner = true;
            _latestApkUrl = data['apk_url'];
          });
          if (_latestApkUrl != null) {
            final size = await _fetchApkSize(_latestApkUrl!);
            if (mounted) {
              setState(() {
                _apkFileSizeBytes = size;
              });
            }
          }
        }
      }
    } catch (e) {
      print("Ошибка проверки обновлений: $e");
    }
  }

  Future<void> _setupPushNotifications() async {
    // Request permissions
    await FirebaseMessaging.instance.requestPermission();

    String? token = await FirebaseMessaging.instance.getToken();
    if (token != null) {
      ApiService apiService = ApiService();
      print(token);
      await apiService.updateFcmToken(token);
    }

    // Listen for token refresh
    FirebaseMessaging.instance.onTokenRefresh.listen((newToken) {
      ApiService apiService = ApiService();
      apiService.updateFcmToken(newToken);
      print('FCM Token refreshed: $newToken');
    });

    // Listen for foreground messages
    FirebaseMessaging.onMessage.listen(_handleIncomingMessage);

    // Handle notification tap when app was terminated/backgrounded
    FirebaseMessaging.onMessageOpenedApp.listen((RemoteMessage message) {
      print('Notification tapped, app opened: ${message.data}');
      if (message.data['type'] == 'enc_message') {
        final senderId = int.tryParse(
          message.data['sender_id']?.toString() ?? '',
        );
        if (senderId != null) {
          _navigateToChatFromNotification(senderId);
        } else {
          print(
            'Notification tap contains invalid sender_id: ${message.data['sender_id']}',
          );
        }
      }
    });
  }

  void _navigateToChatFromNotification(int senderId) async {
    final contactProvider = context.read<ContactProvider>();
    print('Navigate to chat from notification with senderId: $senderId');

    // Если контакты еще не загружены, ждем их загрузки
    if (contactProvider.contacts.isEmpty) {
      print('Contacts not loaded yet, waiting...');
      // Ждем немного и пробуем снова
      Future.delayed(const Duration(milliseconds: 500), () {
        if (mounted) {
          _navigateToChatFromNotification(senderId);
        }
      });
      return;
    }

    try {
      final contact = contactProvider.contacts.firstWhere(
        (c) => c.id == senderId,
      );
      print('Navigating to chat from notification: ${contact.username}');
      currentActiveChatContactId = senderId; // Устанавливаем активный чат
      final result = await Navigator.push(
        context,
        MaterialPageRoute(builder: (_) => ChatScreen(contact: contact)),
      );
      if (result != null) {
        _refreshData(); // Обновляем данные при возвращении с чата, если нужно
      }
    } catch (e) {
      // Contact not found, stay on contacts screen
      print('Contact not found for notification: $senderId');
    }
  }

  Future<void> _handleIncomingMessage(dynamic data) async {
    if (data is RemoteMessage) {
      // FCM message
      await _handleFCMMessage(data);
    } else if (data is Map<String, dynamic>) {
      // WebSocket message
      print('WebSocket message received: $data');
      if (data['type'] == 'user_updated') {
        final userId = int.tryParse(data['user_id']?.toString() ?? '');
        if (userId != null) {
          final contactProvider = context.read<ContactProvider>();
          contactProvider.updateContact(userId);
        }
      }
      if (data['type'] == 'user_online') {
        final userId = int.tryParse(data['user_id']?.toString() ?? '');
        if (userId != null) {
          final contactProvider = context.read<ContactProvider>();
          contactProvider.updateContactOnlineStatus(userId, true);
        }
      }
      if (data['type'] == 'user_offline') {
        final userId = int.tryParse(data['user_id']?.toString() ?? '');
        if (userId != null) {
          final contactProvider = context.read<ContactProvider>();
          contactProvider.updateContactOnlineStatus(userId, false);
        }
      }
      if (data['type'] == 'message_edited') {
        final messageId = int.tryParse(data['message_id']?.toString() ?? '');
        final senderId = int.tryParse(data['sender_id']?.toString() ?? '');
        if (messageId != null && senderId != null) {
          final contactProvider = context.read<ContactProvider>();
          final contact = contactProvider.contacts
              .where((c) => c.id == senderId)
              .firstOrNull;

          if (contact != null) {
            final editedAt = DateTime.tryParse(
              data['edited_at']?.toString() ?? '',
            );

            // Дефолтные значения на случай ошибки расшифровки
            String lastMessageText = contact.lastMessage ?? '';
            bool isDecrypted = false;

            final myPrivKey = await CryptoService().getPrivateKey();
            if (myPrivKey != null && contact.publicKey != null) {
              try {
                final sharedSecret = await CryptoService().deriveSharedSecret(
                  myPrivKey,
                  contact.publicKey!,
                );
                lastMessageText = await CryptoService().decryptMessage(
                  data['content']?.toString() ?? '',
                  sharedSecret,
                );
                isDecrypted = true;
              } catch (e) {
                print('Error decrypting edited message for contacts list: $e');
              }
            }

            // Единая точка обновления состояния
            await contactProvider.updateContactLastMessage(
              contact.id,
              lastMessage: lastMessageText,
              lastMessageTime: editedAt,
              isLastMsgDecrypted: isDecrypted,
              lastMessageId: messageId,
              isEdited: true,
            );
          }
        }
      }

      if (data['type'] == 'message_deleted') {
        final messageId = int.tryParse(data['message_id']?.toString() ?? '');
        if (messageId != null) {
          final contactProvider = context.read<ContactProvider>();
          final contactIndex = contactProvider.contacts.indexWhere(
            (c) => c.lastMessageId == messageId,
          );
          if (contactIndex != -1) {
            final contactId = contactProvider.contacts[contactIndex].id;
            await contactProvider.refreshContactLastMessage(contactId);
          }
        }
      }
    }
  }

  Future<void> _handleFCMMessage(RemoteMessage message) async {
    try {
      // Проверяем, не находимся ли мы уже в чате с отправителем
      final senderId = int.tryParse(
        message.data['sender_id']?.toString() ?? '',
      );
      if (senderId != null && currentActiveChatContactId == senderId) {
        print('Already in chat with sender $senderId, skipping notification');
        return;
      }

      // Ensure notification channel exists
      const AndroidNotificationChannel channel = AndroidNotificationChannel(
        'Messages',
        'Новые сообщения',
        description: 'Chat messages notifications',
        importance: Importance.high,
      );

      await flutterLocalNotificationsPlugin
          .resolvePlatformSpecificImplementation<
            AndroidFlutterLocalNotificationsPlugin
          >()
          ?.createNotificationChannel(channel);

      final crypto = CryptoService();
      final myPrivKey = await crypto.getPrivateKey();
      if (myPrivKey == null) {
        print('Private key not found, cannot decrypt message');
        return;
      }

      final sharedSecret = await crypto.deriveSharedSecret(
        myPrivKey,
        message.data['public_key'],
      );
      final decryptedText = await crypto.decryptMessage(
        message.data['content'],
        sharedSecret,
      );

      if (senderId == null) return;
      final String groupKey = 'ru.chepuhagram.app.$senderId';

      final prefs = await SharedPreferences.getInstance();
      final String? firstName = prefs.getString(
        'firstname_${message.data['sender_id']}',
      );
      final String? lastName = prefs.getString(
        'lastname_${message.data['sender_id']}',
      );
      final String localFullName = '${firstName ?? ''} ${lastName ?? ''}'
          .trim();

      final String title = localFullName.isNotEmpty
          ? localFullName
          : (message.data['username'] ?? 'Unknown');
      // Show local notification

      await flutterLocalNotificationsPlugin.show(
        senderId,
        '',
        '',
        NotificationDetails(
          android: AndroidNotificationDetails(
            'Messages',
            'Новые сообщения',
            groupKey: groupKey,
            setAsGroupSummary: true,
            importance: Importance.high,
            priority: Priority.high,
            groupAlertBehavior: GroupAlertBehavior.all,
          ),
        ),
      );
      await flutterLocalNotificationsPlugin.show(
        message.hashCode,
        title,
        decryptedText,
        NotificationDetails(
          android: AndroidNotificationDetails(
            'Messages',
            'Новые сообщения',
            groupKey: groupKey,
            importance: Importance.high,
            priority: Priority.high,
            showWhen: true,
          ),
        ),
        payload: jsonEncode({
          'type': 'enc_message',
          'sender_id': message.data['sender_id'],
          'timestamp':
              message.data['timestamp'] ?? DateTime.now().toIso8601String(),
        }),
      );

      if (message.data['type'] == 'enc_message') {
        print('Received private message FCM, updating contact $senderId');
        final contactProvider = context.read<ContactProvider>();
        contactProvider.updateContact(
          senderId,
          lastMessage: decryptedText,
          lastMessageTime: DateTime.tryParse(
            message.data['timestamp'] ?? DateTime.now().toIso8601String(),
          ),
          isLastMsgDecrypted: true,
          unreadCount: message.data['unread_count'] != null
              ? int.tryParse(message.data['unread_count'].toString()) ?? 1
              : null,
        );
      }
    } catch (e) {
      print('Error processing foreground FCM message: $e');
    }
  }

  @override
  Widget build(BuildContext context) {
    double bannerHeight = 0.0;
    if (_showUpdateBanner) {
      bannerHeight = _isDownloading ? 152.0 : 96.0;
    }
    final double fabBottomPadding = _showUpdateBanner
        ? (bannerHeight + 20.0)
        : 16.0;
    return Scaffold(
      appBar: AppBar(
        title: Text(
          "Chepuhagram",
          style: TextStyle(fontWeight: FontWeight.bold),
        ),
        centerTitle: false,
        elevation: 0,
        actions: [IconButton(icon: const Icon(Icons.search), onPressed: () {})],
      ),
      body: Stack(
        children: [
          Consumer<ContactProvider>(
            builder: (context, contactProvider, child) {
              if (contactProvider.isLoading) {
                return const Center(child: CircularProgressIndicator());
              }
              if (contactProvider.error != null) {
                return Center(
                  child: Text(
                    '${contactProvider.error?.replaceAll('Exception: ', '')}',
                    style: TextStyle(
                      color: Theme.of(context).colorScheme.error,
                    ),
                    textAlign: TextAlign.center,
                  ),
                );
              }
              return ListView.separated(
                itemCount: contactProvider.contacts.length,
                separatorBuilder: (context, index) => Divider(
                  height: 1,
                  indent: 80,
                  color: Theme.of(context).colorScheme.primaryContainer,
                ),
                itemBuilder: (context, index) {
                  final contact = contactProvider.contacts[index];
                  return ContactTile(
                    contact: contact,
                    onTap: () async {
                      final result = await Navigator.push(
                        context,
                        MaterialPageRoute(
                          builder: (_) => ChatScreen(contact: contact),
                        ),
                      );
                      if (result != null) {
                        _refreshData(); // Обновляем данные при возвращении с чата, если нужно
                      }
                    },
                  );
                },
              );
            },
          ),
          if (_showUpdateBanner)
            Positioned(
              left: 0,
              right: 0,
              bottom: 40,
              child: _buildUpdateBanner(),
            ),
        ],
      ),
      floatingActionButton: AnimatedPadding(
        duration: const Duration(milliseconds: 100),
        curve: Curves.easeInOut,
        padding: EdgeInsets.only(bottom: fabBottomPadding),
        child: FloatingActionButton(
          onPressed: () {
            Navigator.push(
              context,
              MaterialPageRoute(builder: (_) => const NewChatScreen()),
            );
          },
          child: const Icon(Icons.edit),
        ),
      ),
      drawer: Drawer(
        child: ListView(
          padding: EdgeInsets.zero,
          children: [
            // Шапка меню с данными юзера
            Consumer<AuthProvider>(
              builder: (context, authProvider, _) {
                final username = authProvider.username;
                final displayName = authProvider.displayName;
                final initials =
                    (displayName.isNotEmpty ? displayName : (username ?? 'U'))
                        .trim()
                        .split(RegExp(r'\s+'))
                        .where((p) => p.isNotEmpty)
                        .take(2)
                        .map((p) => p[0].toUpperCase())
                        .join();

                return UserAccountsDrawerHeader(
                  accountName: Text(
                    displayName,
                    style: TextStyle(
                      color: Theme.of(context).colorScheme.onSurface,
                    ),
                  ),
                  accountEmail: Text(
                    username == null || username.isEmpty ? '' : '@$username',
                    style: TextStyle(
                      color: Theme.of(context).colorScheme.onSurface,
                    ),
                  ),
                  currentAccountPicture: CircleAvatar(
                    backgroundColor:
                        authProvider.avatarUrl == null &&
                            authProvider.avatarPath == null
                        ? Theme.of(context).colorScheme.onSurface
                        : null,
                    backgroundImage: authProvider.avatarUrl != null
                        ? CachedNetworkImageProvider(authProvider.avatarUrl!)
                        : authProvider.avatarPath != null
                        ? FileImage(File(authProvider.avatarPath!))
                        : null,
                    child:
                        (authProvider.avatarUrl == null &&
                            authProvider.avatarPath == null)
                        ? Text(
                            initials.isEmpty ? 'U' : initials,
                            style: TextStyle(
                              fontSize: 20,
                              fontWeight: FontWeight.bold,
                              color: Theme.of(
                                context,
                              ).colorScheme.primaryContainer,
                            ),
                          )
                        : null,
                  ),
                  decoration: BoxDecoration(
                    color: Theme.of(context).colorScheme.inversePrimary,
                  ),
                );
              },
            ),
            ListTile(
              leading: const Icon(Icons.settings),
              title: const Text("Настройки"),
              onTap: () {
                // Закрываем Drawer и переходим на экран настроек
                Navigator.pop(context);
                Navigator.push(
                  context,
                  MaterialPageRoute(builder: (_) => SettingsScreen()),
                );
              },
            ),
            ListTile(
              leading: const Icon(Icons.info_outline),
              title: const Text("О приложении"),
              onTap: () {
                /* ... */
              },
            ),
          ],
        ),
      ),
    );
  }

  Future<void> _startDownload() async {
    if (_latestApkUrl == null) return;

    // Показываем индикатор
    setState(() => _isDownloading = true);

    final dir = await getExternalStorageDirectory();
    final path = '${dir!.path}/update.apk';
    final file = File(path);

    // Удаляем старый файл, если он есть, чтобы гарантировать чистоту
    if (await file.exists()) {
      await file.delete();
    }

    try {
      setState(() {
        _downloadProgress = 0.0;
        _downloadedBytes = 0;
        _downloadTotalBytes = 0;
      });

      // Скачиваем файл «в лоб»
      await Dio().download(
        _latestApkUrl!,
        path,
        cancelToken: _cancelToken,
        onReceiveProgress: (rec, total) {
          if (mounted) {
            setState(() {
              _downloadedBytes = rec;
              _downloadTotalBytes = total > 0 ? total : 0;
              _downloadProgress = total > 0 ? rec / total : 0.0;
            });
          }
        },
      );

      // После успешного скачивания — установка
      final result = await OpenFilex.open(path);
      if (result.type != ResultType.done) {
        print("Ошибка при установке: ${result.message}");
      }
    } on DioException catch (e) {
      if (e.type != DioExceptionType.cancel) {
        print("Ошибка скачивания: $e");
      }
    } catch (e) {
      print("Ошибка: $e");
    } finally {
      if (mounted) {
        setState(() {
          _isDownloading = false;
          _downloadProgress = 0.0;
          _downloadedBytes = 0;
          _downloadTotalBytes = 0;
        });
      }
    }
  }

  Future<int> _fetchApkSize(String url) async {
    try {
      final response = await http.head(Uri.parse(url));
      final lengthHeader = response.headers['content-length'];
      if (lengthHeader == null) return 0;
      return int.tryParse(lengthHeader) ?? 0;
    } catch (_) {
      return 0;
    }
  }

  String _formatBytes(int bytes) {
    if (bytes <= 0) return '0 B';
    const kb = 1024;
    const mb = kb * 1024;
    if (bytes < kb) return '$bytes B';
    if (bytes < mb) return '${(bytes / kb).toStringAsFixed(1)} KB';
    return '${(bytes / mb).toStringAsFixed(1)} MB';
  }

  Widget _buildUpdateBanner() {
    return Container(
      margin: const EdgeInsets.fromLTRB(
        12,
        0,
        12,
        16,
      ), // Отступы от краев и снизу
      child: Material(
        elevation: 6,
        borderRadius: BorderRadius.circular(12),
        child: Container(
          padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 14),
          decoration: BoxDecoration(
            gradient: LinearGradient(
              colors: [Colors.orange.shade600, Colors.deepOrange.shade400],
              begin: Alignment.topLeft,
              end: Alignment.bottomRight,
            ),
            borderRadius: BorderRadius.circular(12),
          ),
          child: Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              Row(
                children: [
                  const Icon(
                    Icons.system_update_alt,
                    color: Colors.white,
                    size: 28,
                  ),
                  const SizedBox(width: 12),
                  Expanded(
                    child: Text(
                      _isDownloading
                          ? 'Скачивание ${(_downloadProgress * 100).toStringAsFixed(0)}%'
                          : _apkFileSizeBytes > 0
                          ? 'Доступно новое обновление: ${_formatBytes(_apkFileSizeBytes)}'
                          : 'Доступно новое обновление!',
                      style: const TextStyle(
                        color: Colors.white,
                        fontWeight: FontWeight.bold,
                        fontSize: 16,
                      ),
                    ),
                  ),
                  TextButton(
                    onPressed: () async {
                      if (_isDownloading) {
                        // Если уже качаем — отменяем
                        _cancelToken?.cancel("Пользователь отменил загрузку");
                        setState(() {
                          _isDownloading = false;
                          _cancelToken = null; // Обязательно обнуляем токен!
                          _downloadProgress = 0.0;
                          _downloadedBytes = 0;
                          _downloadTotalBytes = 0;
                        });
                      } else {
                        // Если не качаем — запускаем
                        setState(() {
                          _isDownloading = true;
                          _cancelToken =
                              CancelToken(); // Создаем новый токен перед началом
                        });

                        // ВАЖНО: вызываем саму функцию скачивания
                        await _startDownload();
                      }
                    },
                    style: TextButton.styleFrom(
                      backgroundColor: Colors.white24,
                      shape: RoundedRectangleBorder(
                        borderRadius: BorderRadius.circular(8),
                      ),
                    ),
                    child: Text(
                      _isDownloading ? "Отмена" : "Обновить",
                      style: const TextStyle(
                        color: Colors.white,
                        fontWeight: FontWeight.bold,
                      ),
                    ),
                  ),
                ],
              ),
              if (_isDownloading) ...[
                const SizedBox(height: 12),
                LinearProgressIndicator(
                  value: _downloadProgress,
                  color: Colors.white,
                  backgroundColor: Colors.white24,
                ),
                const SizedBox(height: 8),
                Align(
                  alignment: Alignment.centerLeft,
                  child: Text(
                    '${_formatBytes(_downloadedBytes)} из ${_formatBytes(_downloadTotalBytes)}',
                    style: const TextStyle(color: Colors.white70, fontSize: 14),
                  ),
                ),
              ],
            ],
          ),
        ),
      ),
    );
  }
}