import 'dart:async';
import 'dart:convert';
import 'dart:typed_data';

import 'package:crypto/crypto.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'package:http/http.dart' as http;
import 'package:image_picker/image_picker.dart';

import '../networks/api_client.dart';
import 'database_service.dart';

class CampusAnnouncementMedia {
  final int id;
  final int announcementId;
  final String type;
  final String path;
  final String thumbnailPath;
  final int sizeBytes;

  const CampusAnnouncementMedia({
    required this.id,
    required this.announcementId,
    required this.type,
    required this.path,
    required this.thumbnailPath,
    required this.sizeBytes,
  });

  bool get isVideo => type.toLowerCase() == 'video';
  bool get isImage => !isVideo;

  factory CampusAnnouncementMedia.fromJson(Map<String, dynamic> json) {
    return CampusAnnouncementMedia(
      id: int.tryParse('${json['id'] ?? 0}') ?? 0,
      announcementId: int.tryParse('${json['announcement_id'] ?? 0}') ?? 0,
      type: '${json['type'] ?? json['media_type'] ?? 'image'}',
      path: '${json['path'] ?? json['media_path'] ?? ''}',
      thumbnailPath: '${json['thumbnail_path'] ?? json['thumbnail'] ?? ''}',
      sizeBytes: int.tryParse('${json['size_bytes'] ?? 0}') ?? 0,
    );
  }
}

class CampusAnnouncement {
  final int id;
  final int authorId;
  final String title;
  final String body;
  final String category;
  final String priority;
  final String audience;
  final String campus;
  final String status;
  final bool isPinned;
  final DateTime createdAt;
  final DateTime? updatedAt;
  final DateTime? publishedAt;
  final DateTime? scheduledAt;
  final DateTime? expiresAt;
  final String authorName;
  final String authorRole;
  final String authorProfilePicture;
  final List<CampusAnnouncementMedia> media;
  final int likeCount;
  final int commentCount;
  final bool likedByMe;

  const CampusAnnouncement({
    required this.id,
    required this.authorId,
    required this.title,
    required this.body,
    required this.category,
    required this.priority,
    required this.audience,
    required this.campus,
    required this.status,
    required this.isPinned,
    required this.createdAt,
    required this.updatedAt,
    required this.publishedAt,
    required this.scheduledAt,
    required this.expiresAt,
    required this.authorName,
    required this.authorRole,
    required this.authorProfilePicture,
    required this.media,
    required this.likeCount,
    required this.commentCount,
    required this.likedByMe,
  });

  List<CampusAnnouncementMedia> get images => media.where((m) => m.isImage).toList();
  CampusAnnouncementMedia? get video {
    for (final item in media) {
      if (item.isVideo) return item;
    }
    return null;
  }

  factory CampusAnnouncement.fromJson(Map<String, dynamic> json) {
    final media = <CampusAnnouncementMedia>[];
    if (json['media'] is List) {
      for (final item in json['media'] as List) {
        if (item is Map) {
          media.add(CampusAnnouncementMedia.fromJson(
            item.map((key, value) => MapEntry(key.toString(), value)),
          ));
        }
      }
    }

    return CampusAnnouncement(
      id: int.tryParse('${json['id'] ?? 0}') ?? 0,
      authorId: int.tryParse('${json['author_id'] ?? 0}') ?? 0,
      title: '${json['title'] ?? ''}',
      body: '${json['body'] ?? ''}',
      category: '${json['category'] ?? 'General'}',
      priority: '${json['priority'] ?? 'Normal'}',
      audience: '${json['audience'] ?? 'All Staff'}',
      campus: '${json['campus'] ?? ''}',
      status: '${json['status'] ?? 'published'}',
      isPinned: _bool(json['is_pinned']),
      createdAt: DateTime.tryParse('${json['created_at'] ?? ''}') ?? DateTime.now(),
      updatedAt: DateTime.tryParse('${json['updated_at'] ?? ''}'),
      publishedAt: DateTime.tryParse('${json['published_at'] ?? ''}'),
      scheduledAt: DateTime.tryParse('${json['scheduled_at'] ?? ''}'),
      expiresAt: DateTime.tryParse('${json['expires_at'] ?? ''}'),
      authorName: '${json['author_name'] ?? 'Rockview Staff'}',
      authorRole: '${json['author_role'] ?? 'staff'}',
      authorProfilePicture: '${json['author_profile_picture'] ?? ''}',
      media: media,
      likeCount: int.tryParse('${json['like_count'] ?? 0}') ?? 0,
      commentCount: int.tryParse('${json['comment_count'] ?? 0}') ?? 0,
      likedByMe: _bool(json['liked_by_me']),
    );
  }

  CampusAnnouncement copyWith({int? likeCount, int? commentCount, bool? likedByMe}) {
    return CampusAnnouncement(
      id: id,
      authorId: authorId,
      title: title,
      body: body,
      category: category,
      priority: priority,
      audience: audience,
      campus: campus,
      status: status,
      isPinned: isPinned,
      createdAt: createdAt,
      updatedAt: updatedAt,
      publishedAt: publishedAt,
      scheduledAt: scheduledAt,
      expiresAt: expiresAt,
      authorName: authorName,
      authorRole: authorRole,
      authorProfilePicture: authorProfilePicture,
      media: media,
      likeCount: likeCount ?? this.likeCount,
      commentCount: commentCount ?? this.commentCount,
      likedByMe: likedByMe ?? this.likedByMe,
    );
  }
}

class CampusAnnouncementComment {
  final int id;
  final int announcementId;
  final int userId;
  final int? parentCommentId;
  final String comment;
  final String authorName;
  final String authorRole;
  final String authorProfilePicture;
  final DateTime createdAt;

  const CampusAnnouncementComment({
    required this.id,
    required this.announcementId,
    required this.userId,
    required this.parentCommentId,
    required this.comment,
    required this.authorName,
    required this.authorRole,
    required this.authorProfilePicture,
    required this.createdAt,
  });

  bool get isReply => parentCommentId != null;

  factory CampusAnnouncementComment.fromJson(Map<String, dynamic> json) {
    return CampusAnnouncementComment(
      id: int.tryParse('${json['id'] ?? 0}') ?? 0,
      announcementId: int.tryParse('${json['announcement_id'] ?? 0}') ?? 0,
      userId: int.tryParse('${json['user_id'] ?? 0}') ?? 0,
      parentCommentId: int.tryParse('${json['parent_comment_id'] ?? ''}'),
      comment: '${json['comment'] ?? ''}',
      authorName: '${json['author_name'] ?? 'Rockview User'}',
      authorRole: '${json['author_role'] ?? 'user'}',
      authorProfilePicture: '${json['author_profile_picture'] ?? ''}',
      createdAt: DateTime.tryParse('${json['created_at'] ?? ''}') ?? DateTime.now(),
    );
  }
}

class AnnouncementMentionableUser {
  final int id;
  final String fullName;
  final String role;
  final String campus;
  final String profilePicture;

  const AnnouncementMentionableUser({
    required this.id,
    required this.fullName,
    required this.role,
    required this.campus,
    required this.profilePicture,
  });

  factory AnnouncementMentionableUser.fromJson(Map<String, dynamic> json) {
    return AnnouncementMentionableUser(
      id: int.tryParse('${json['id'] ?? 0}') ?? 0,
      fullName: '${json['full_name'] ?? 'Rockview User'}',
      role: '${json['role'] ?? 'user'}',
      campus: '${json['campus'] ?? ''}',
      profilePicture: '${json['profile_picture'] ?? ''}',
    );
  }
}

class CampusAnnouncementNotification {
  final int id;
  final int? announcementId;
  final int? commentId;
  final String type;
  final String title;
  final String message;
  final String actorName;
  final String actorProfilePicture;
  final bool isRead;
  final DateTime createdAt;

  const CampusAnnouncementNotification({
    required this.id,
    required this.announcementId,
    required this.commentId,
    required this.type,
    required this.title,
    required this.message,
    required this.actorName,
    required this.actorProfilePicture,
    required this.isRead,
    required this.createdAt,
  });

  factory CampusAnnouncementNotification.fromJson(Map<String, dynamic> json) {
    return CampusAnnouncementNotification(
      id: int.tryParse('${json['id'] ?? 0}') ?? 0,
      announcementId: int.tryParse('${json['announcement_id'] ?? ''}'),
      commentId: int.tryParse('${json['comment_id'] ?? ''}'),
      type: '${json['type'] ?? 'general'}',
      title: '${json['title'] ?? 'Announcement activity'}',
      message: '${json['message'] ?? ''}',
      actorName: '${json['actor_name'] ?? ''}',
      actorProfilePicture: '${json['actor_profile_picture'] ?? ''}',
      isRead: _bool(json['is_read']),
      createdAt: DateTime.tryParse('${json['created_at'] ?? ''}') ?? DateTime.now(),
    );
  }
}

class CampusAnnouncementPage {
  final List<CampusAnnouncement> announcements;
  final bool hasMore;
  final int total;

  const CampusAnnouncementPage({
    required this.announcements,
    required this.hasMore,
    required this.total,
  });
}

class CampusAnnouncementNotificationPage {
  final List<CampusAnnouncementNotification> items;
  final int unreadCount;

  const CampusAnnouncementNotificationPage({required this.items, required this.unreadCount});
}

class CampusAnnouncementsService {
  static Future<void>? _hiveReady;
  static const _offlineLease = Duration(hours: 24);
  static const List<String> categories = <String>[
    'General',
    'Academic',
    'Administration',
    'Human Resources',
    'Meetings',
    'ICT',
    'Finance',
    'Health & Safety',
    'Events',
    'Emergency',
  ];

  static const List<String> priorities = <String>['Normal', 'Important', 'Urgent'];
  static const List<String> audiences = <String>['All Staff', 'Campus Staff', 'Department', 'Everyone'];

  static Future<Box<dynamic>?> _offlineBox() async {
    try {
      final dynamic user = await DatabaseService.getLocalUser();
      final email = '${user?.email ?? ''}'.trim().toLowerCase();
      if (email.isEmpty || email == 'null') return null;
      _hiveReady ??= Hive.initFlutter();
      await _hiveReady;
      final scope = sha256.convert(utf8.encode('${ApiClient.baseUrl}|$email')).toString().substring(0, 24);
      return await Hive.openBox<dynamic>('rvu_announcements_v1_$scope');
    } catch (_) {
      return null;
    }
  }

  static Future<http.Response> _getCachedResponse({
    required String cacheKey,
    required Uri uri,
    required String emptyBody,
  }) async {
    final box = await _offlineBox();
    final storageKey = 'get:${sha256.convert(utf8.encode(cacheKey))}';
    final saved = box?.get(storageKey);
    String? savedBody;
    if (saved is Map) {
      final at = DateTime.tryParse('${saved['at'] ?? ''}');
      final age = at == null ? null : DateTime.now().difference(at);
      if (age != null && !age.isNegative && age < _offlineLease && saved['body'] is String) {
        savedBody = saved['body'] as String;
      }
    }

    // Return account-scoped saved content immediately. Refresh is silent and
    // updates the cache for the next open; slow endpoints never block the feed.
    if (savedBody != null) {
      unawaited(_refreshCachedResponse(box, storageKey, uri));
      return http.Response(savedBody, 200);
    }

    try {
      final response = await http.get(uri, headers: await ApiClient.getHeaders())
          .timeout(const Duration(seconds: 8));
      if (response.statusCode == 200) {
        await box?.put(storageKey, {
          'at': DateTime.now().toIso8601String(),
          'body': response.body,
        });
        return response;
      }
      if (response.statusCode == 403) await box?.delete(storageKey);
      await ApiClient.handleUnauthorized(response);
      return savedBody == null ? http.Response(emptyBody, 200) : http.Response(savedBody, 200);
    } catch (_) {
      return savedBody == null ? http.Response(emptyBody, 200) : http.Response(savedBody, 200);
    }
  }

  static Future<void> _refreshCachedResponse(
    Box<dynamic>? box,
    String storageKey,
    Uri uri,
  ) async {
    if (box == null) return;
    try {
      final response = await http.get(uri, headers: await ApiClient.getHeaders())
          .timeout(const Duration(seconds: 8));
      await ApiClient.handleUnauthorized(response);
      if (response.statusCode == 200) {
        await box.put(storageKey, {
          'at': DateTime.now().toIso8601String(),
          'body': response.body,
        });
      } else if (response.statusCode == 403) {
        await box.delete(storageKey);
      }
    } catch (_) {
      // The existing snapshot remains usable until the offline lease expires.
    }
  }

  static bool isStoredMediaPath(String value) {
    final normalized = value.trim().replaceAll('\\', '/');
    return normalized.startsWith('uploads/') || normalized.startsWith('/uploads/');
  }

  static String mediaUrl(String value) {
    final trimmed = value.trim();
    if (trimmed.isEmpty) return '';
    if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) return trimmed;
    if (isStoredMediaPath(trimmed)) {
      final clean = trimmed.startsWith('/') ? trimmed.substring(1) : trimmed;
      return '${ApiClient.baseUrl}/$clean';
    }
    return trimmed;
  }

  static Future<Map<String, dynamic>> getCurrentUser() async {
    final response = await http.get(
      Uri.parse('${ApiClient.baseUrl}/api/users.php/me'),
      headers: await ApiClient.getHeaders(),
    ).timeout(const Duration(seconds: 15));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to identify the signed-in account.'));
    }
    final decoded = _decode(response);
    if (decoded is Map) return decoded.map((key, value) => MapEntry(key.toString(), value));
    throw const FormatException('Current-user endpoint returned invalid data.');
  }

  static Future<List<String>> getCampuses() async {
    try {
      final response = await _getCachedResponse(
        cacheKey: 'campuses',
        uri: Uri.parse('${ApiClient.baseUrl}/api/campuses.php'),
        emptyBody: '{"data":[]}',
      );
      final decoded = _decode(response);
      final rows = decoded is Map ? decoded['data'] ?? decoded['campuses'] : decoded;
      if (rows is! List) return const <String>[];
      final names = <String>{};
      for (final item in rows) {
        if (item is Map) {
          final name = '${item['name'] ?? item['campus_name'] ?? ''}'.trim();
          if (name.isNotEmpty) names.add(name);
        }
      }
      final result = names.toList()..sort();
      return result;
    } catch (_) {
      return const <String>[];
    }
  }

  static Future<CampusAnnouncementPage> getAnnouncements({
    String scope = 'active',
    String? campus,
    String? category,
    String? search,
    int page = 1,
    int limit = 8,
  }) async {
    final params = <String, String>{'scope': scope, 'page': '$page', 'limit': '$limit'};
    if (campus != null && campus.trim().isNotEmpty && campus != 'All Campuses') params['campus'] = campus.trim();
    if (category != null && category.trim().isNotEmpty && category != 'All Categories') params['category'] = category.trim();
    if (search != null && search.trim().isNotEmpty) params['q'] = search.trim();

    final uri = Uri.parse('${ApiClient.baseUrl}/api/announcements.php').replace(queryParameters: params);
    final response = await _getCachedResponse(
      cacheKey: 'feed:${jsonEncode(params)}',
      uri: uri,
      emptyBody: '{"data":[],"pagination":{"has_more":false,"total":0}}',
    );
    final decoded = _decode(response);
    final rows = decoded is Map ? decoded['data'] ?? const [] : decoded;
    if (rows is! List) throw const FormatException('Announcements endpoint returned invalid data.');
    final items = rows.whereType<Map>().map((item) => CampusAnnouncement.fromJson(
      item.map((key, value) => MapEntry(key.toString(), value)),
    )).toList();
    final pagination = decoded is Map && decoded['pagination'] is Map
        ? Map<String, dynamic>.from(decoded['pagination'] as Map)
        : <String, dynamic>{};
    return CampusAnnouncementPage(
      announcements: items,
      hasMore: _bool(pagination['has_more'] ?? (items.length >= limit)),
      total: int.tryParse('${pagination['total'] ?? items.length}') ?? items.length,
    );
  }

  static Future<int> createAnnouncement({
    required String title,
    required String body,
    required String category,
    required String priority,
    required String audience,
    required String status,
    bool isPinned = false,
    DateTime? scheduledAt,
    DateTime? expiresAt,
  }) async {
    final response = await http.post(
      Uri.parse('${ApiClient.baseUrl}/api/announcements.php'),
      headers: await ApiClient.getHeaders(),
      body: jsonEncode(<String, dynamic>{
        'title': title.trim(),
        'body': body.trim(),
        'category': category,
        'priority': priority,
        'audience': audience,
        'status': status,
        'is_pinned': isPinned,
        if (scheduledAt != null) 'scheduled_at': scheduledAt.toUtc().toIso8601String(),
        if (expiresAt != null) 'expires_at': expiresAt.toUtc().toIso8601String(),
      }),
    ).timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 201 && response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to create announcement.'));
    }
    final decoded = _decode(response);
    if (decoded is Map) return int.tryParse('${decoded['id'] ?? 0}') ?? 0;
    throw const FormatException('Create announcement returned invalid data.');
  }

  static Future<void> updateAnnouncement(int id, Map<String, dynamic> changes) async {
    final response = await http.put(
      Uri.parse('${ApiClient.baseUrl}/api/announcements.php?id=$id'),
      headers: await ApiClient.getHeaders(),
      body: jsonEncode(changes),
    ).timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200) throw Exception(_errorMessage(response, 'Unable to update announcement.'));
  }

  static Future<void> deleteAnnouncement(int id) async {
    final response = await http.delete(
      Uri.parse('${ApiClient.baseUrl}/api/announcements.php?id=$id'),
      headers: await ApiClient.getHeaders(),
    ).timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200) throw Exception(_errorMessage(response, 'Unable to delete announcement.'));
  }

  static Future<List<CampusAnnouncementMedia>> uploadImages(int announcementId, List<XFile> files) async {
    if (files.isEmpty) return const <CampusAnnouncementMedia>[];
    final request = http.MultipartRequest('POST', Uri.parse('${ApiClient.baseUrl}/api/announcement_media.php'));
    final headers = await ApiClient.getHeaders();
    headers.remove('Content-Type');
    request.headers.addAll(headers);
    request.fields['announcement_id'] = '$announcementId';
    request.fields['media_type'] = 'image';
    for (final file in files) {
      final bytes = await file.readAsBytes();
      request.files.add(http.MultipartFile.fromBytes('images[]', bytes, filename: file.name));
    }
    final streamed = await request.send().timeout(const Duration(seconds: 60));
    final response = await http.Response.fromStream(streamed);
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 201 && response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to upload announcement pictures.'));
    }
    final decoded = _decode(response);
    final rows = decoded is Map ? decoded['data'] ?? const [] : const [];
    if (rows is! List) return const <CampusAnnouncementMedia>[];
    return rows.whereType<Map>().map((item) => CampusAnnouncementMedia.fromJson(
      item.map((key, value) => MapEntry(key.toString(), value)),
    )).toList();
  }

  static Future<CampusAnnouncementMedia?> uploadVideo(int announcementId, XFile file) async {
    final length = await file.length();
    if (length > 10 * 1024 * 1024) throw Exception('Announcement video must not exceed 10 MB.');
    final request = http.MultipartRequest('POST', Uri.parse('${ApiClient.baseUrl}/api/announcement_media.php'));
    final headers = await ApiClient.getHeaders();
    headers.remove('Content-Type');
    request.headers.addAll(headers);
    request.fields['announcement_id'] = '$announcementId';
    request.fields['media_type'] = 'video';
    request.files.add(http.MultipartFile.fromBytes('video', await file.readAsBytes(), filename: file.name));
    final streamed = await request.send().timeout(const Duration(seconds: 90));
    final response = await http.Response.fromStream(streamed);
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 201 && response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to upload announcement video.'));
    }
    final decoded = _decode(response);
    final payload = decoded is Map ? decoded['data'] ?? decoded['media'] : null;
    if (payload is Map) {
      return CampusAnnouncementMedia.fromJson(payload.map((key, value) => MapEntry(key.toString(), value)));
    }
    return null;
  }

  static Future<void> deleteMedia(int mediaId) async {
    final response = await http.delete(
      Uri.parse('${ApiClient.baseUrl}/api/announcement_media.php?id=$mediaId'),
      headers: await ApiClient.getHeaders(),
    ).timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200) throw Exception(_errorMessage(response, 'Unable to remove announcement media.'));
  }

  static Future<Map<String, dynamic>> toggleLike(int announcementId) async {
    final response = await http.post(
      Uri.parse('${ApiClient.baseUrl}/api/announcement_likes.php'),
      headers: await ApiClient.getHeaders(),
      body: jsonEncode(<String, dynamic>{'announcement_id': announcementId}),
    ).timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200) throw Exception(_errorMessage(response, 'Unable to update announcement like.'));
    final decoded = _decode(response);
    return decoded is Map ? decoded.map((key, value) => MapEntry(key.toString(), value)) : <String, dynamic>{};
  }

  static Future<List<CampusAnnouncementComment>> getComments(int announcementId) async {
    final uri = Uri.parse('${ApiClient.baseUrl}/api/announcement_comments.php?announcement_id=$announcementId');
    final response = await _getCachedResponse(
      cacheKey: 'comments:$announcementId',
      uri: uri,
      emptyBody: '{"data":[]}',
    );
    final decoded = _decode(response);
    final rows = decoded is Map ? decoded['data'] ?? const [] : decoded;
    if (rows is! List) return const <CampusAnnouncementComment>[];
    return rows.whereType<Map>().map((item) => CampusAnnouncementComment.fromJson(
      item.map((key, value) => MapEntry(key.toString(), value)),
    )).toList();
  }

  static Future<CampusAnnouncementComment> addComment(
    int announcementId,
    String comment, {
    int? parentCommentId,
    List<int>? mentionUserIds,
  }) async {
    final response = await http.post(
      Uri.parse('${ApiClient.baseUrl}/api/announcement_comments.php'),
      headers: await ApiClient.getHeaders(),
      body: jsonEncode(<String, dynamic>{
        'announcement_id': announcementId,
        'comment': comment.trim(),
        if (parentCommentId != null) 'parent_comment_id': parentCommentId,
        if (mentionUserIds != null && mentionUserIds.isNotEmpty) 'mention_user_ids': mentionUserIds,
      }),
    ).timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 201 && response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to post comment.'));
    }
    final decoded = _decode(response);
    final payload = decoded is Map ? decoded['data'] ?? decoded['comment'] : null;
    if (payload is Map) {
      return CampusAnnouncementComment.fromJson(payload.map((key, value) => MapEntry(key.toString(), value)));
    }
    throw const FormatException('Comment endpoint returned invalid data.');
  }

  static Future<List<AnnouncementMentionableUser>> getMentionableUsers(int announcementId, {String query = ''}) async {
    final params = <String, String>{'announcement_id': '$announcementId'};
    if (query.trim().isNotEmpty) params['q'] = query.trim();
    final uri = Uri.parse('${ApiClient.baseUrl}/api/announcement_mentions.php').replace(queryParameters: params);
    final response = await _getCachedResponse(
      cacheKey: 'mentions:${jsonEncode(params)}',
      uri: uri,
      emptyBody: '{"data":[]}',
    );
    final decoded = _decode(response);
    final rows = decoded is Map ? decoded['data'] ?? const [] : decoded;
    if (rows is! List) return const <AnnouncementMentionableUser>[];
    return rows.whereType<Map>().map((item) => AnnouncementMentionableUser.fromJson(
      item.map((key, value) => MapEntry(key.toString(), value)),
    )).toList();
  }

  static Future<CampusAnnouncementNotificationPage> getNotifications({int limit = 50}) async {
    final uri = Uri.parse('${ApiClient.baseUrl}/api/announcement_notifications.php?limit=$limit');
    final response = await _getCachedResponse(
      cacheKey: 'notifications:$limit',
      uri: uri,
      emptyBody: '{"data":[],"unread_count":0}',
    );
    final decoded = _decode(response);
    final rows = decoded is Map ? decoded['data'] ?? const [] : const [];
    final unread = decoded is Map ? int.tryParse('${decoded['unread_count'] ?? 0}') ?? 0 : 0;
    if (rows is! List) return CampusAnnouncementNotificationPage(items: const [], unreadCount: unread);
    return CampusAnnouncementNotificationPage(
      items: rows.whereType<Map>().map((item) => CampusAnnouncementNotification.fromJson(
        item.map((key, value) => MapEntry(key.toString(), value)),
      )).toList(),
      unreadCount: unread,
    );
  }

  static Future<void> markNotificationRead(int id) async {
    final response = await http.put(
      Uri.parse('${ApiClient.baseUrl}/api/announcement_notifications.php?id=$id'),
      headers: await ApiClient.getHeaders(),
      body: jsonEncode(const <String, dynamic>{'is_read': true}),
    ).timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200) throw Exception(_errorMessage(response, 'Unable to update notification.'));
  }

  static Future<void> markAllNotificationsRead() async {
    final response = await http.post(
      Uri.parse('${ApiClient.baseUrl}/api/announcement_notifications.php'),
      headers: await ApiClient.getHeaders(),
      body: jsonEncode(const <String, dynamic>{'action': 'mark_all_read'}),
    ).timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200) throw Exception(_errorMessage(response, 'Unable to update notifications.'));
  }
}

dynamic _decode(http.Response response) {
  var text = response.body.trim();
  if (text.isEmpty) return const <String, dynamic>{};

  // Remove an optional UTF-8 BOM.
  if (text.isNotEmpty && text.codeUnitAt(0) == 0xFEFF) {
    text = text.substring(1).trimLeft();
  }

  try {
    return jsonDecode(text);
  } catch (_) {
    // Some PHP/XAMPP configurations prepend HTML warnings such as <br />
    // before an otherwise valid JSON response. Try the first JSON object/array
    // so the UI does not crash with "Unexpected character".
    final objectStart = text.indexOf('{');
    final arrayStart = text.indexOf('[');
    final starts = <int>[
      if (objectStart >= 0) objectStart,
      if (arrayStart >= 0) arrayStart,
    ]..sort();

    for (final start in starts) {
      try {
        return jsonDecode(text.substring(start));
      } catch (_) {}
    }

    final plain = text
        .replaceAll(RegExp(r'<[^>]*>'), ' ')
        .replaceAll('&nbsp;', ' ')
        .replaceAll('&lt;', '<')
        .replaceAll('&gt;', '>')
        .replaceAll('&amp;', '&')
        .replaceAll(RegExp(r'\s+'), ' ')
        .trim();
    final preview = plain.length > 320 ? '${plain.substring(0, 320)}...' : plain;
    throw FormatException(
      preview.isEmpty
          ? 'Server returned a non-JSON response (HTTP ${response.statusCode}).'
          : 'Server returned a non-JSON response: $preview',
    );
  }
}

String _errorMessage(http.Response response, String fallback) {
  try {
    final decoded = _decode(response);
    if (decoded is Map) {
      final text = '${decoded['detail'] ?? decoded['message'] ?? decoded['error'] ?? ''}'.trim();
      if (text.isNotEmpty) return text;
    }
  } catch (_) {}
  return '$fallback (HTTP ${response.statusCode}).';
}

bool _bool(dynamic value) {
  if (value is bool) return value;
  if (value is num) return value != 0;
  final text = '${value ?? ''}'.trim().toLowerCase();
  return text == '1' || text == 'true' || text == 't' || text == 'yes';
}

String formatBytes(int bytes) {
  if (bytes < 1024) return '$bytes B';
  final kb = bytes / 1024;
  if (kb < 1024) return '${kb.toStringAsFixed(1)} KB';
  return '${(kb / 1024).toStringAsFixed(1)} MB';
}

class PickedAnnouncementImage {
  final XFile file;
  final Uint8List bytes;
  const PickedAnnouncementImage({required this.file, required this.bytes});
}
