import 'dart:async';
import 'dart:convert';
import 'dart:math';
import 'dart:typed_data';
import 'package:crypto/crypto.dart';
import 'package:flutter/foundation.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'package:image_picker/image_picker.dart';
import 'campus_news_service.dart' as api;
import 'database_service.dart';
import '../networks/api_client.dart';
import 'news_local_models.dart';
export 'news_local_models.dart';

/// Local snapshots are the UI source. The existing service remains the wire API.
/// No inferred endpoint URLs, model constructors or new server requirements.
class NewsOfflineService {
  static final revision=ValueNotifier<int>(0);
  static final status=ValueNotifier<String>('Opening saved campus news…');
  static final accountScope=ValueNotifier<String>('');
  static NewsOfflineService? _instance;
  static Future<void>? _hive;
  static Future<NewsOfflineService>? _opening;
  static Timer? _timer;
  static bool _foreground=true;
  final String account;
  final String email;
  final Box<dynamic> box;
  final LazyBox<dynamic> media;
  final Map<String,Future<dynamic>> _inflight={};
  final Map<String,Future<dynamic> Function()> _loaders={};
  DateTime? _retryAfter;
  bool _sending=false;
  bool _closed=false;
  bool _authRequired=false;
  String? _rejectedToken;
  int _failures=0;
  static const offlineReadLease=Duration(hours:24);
  Future<void> _writes=Future<void>.value();
  NewsOfflineService._(this.account,this.email,this.box,this.media);
  static List<String> get categories=>api.CampusNewsService.categories;
  static int get maxVideoBytes=>api.CampusNewsService.maxVideoBytes;
  static String formatBytes(int bytes)=>api.CampusNewsService.formatBytes(bytes);
  static String mediaUrl(String path)=>api.CampusNewsService.mediaUrl(path);
  static bool isStoredMediaPath(String path)=>api.CampusNewsService.isStoredMediaPath(path);

  static Future<String> _email() async {
    final user=await DatabaseService.getLocalUser();
    final value='${user?.email??''}'.trim().toLowerCase();
    if(value.isEmpty)throw StateError('Sign in to open the campus news.');
    return value;
  }
  static Future<NewsOfflineService> _ready() async {
    final email=await _email();
    final scope=sha256.convert(utf8.encode('${ApiClient.baseUrl}|$email')).toString().substring(0,32);
    if(_instance?.account==scope&&!_instance!._closed)return _instance!;
    if(_opening!=null){await _opening;return _ready();}
    final future=_open(scope,email);_opening=future;
    try{return await future;}finally{_opening=null;}
  }
  static Future<NewsOfflineService> _open(String scope,String email) async {
    _instance?._closed=true;_instance=null;
    accountScope.value=''; // Unmount old-account screens before loading a new account.
    _hive??=Hive.initFlutter();await _hive;
    final box=await Hive.openBox<dynamic>('rvu_news_v1_$scope');
    final media=await Hive.openLazyBox<dynamic>('rvu_news_media_v1_$scope');
    if(await _email()!=email)throw StateError('Account changed. Reopen campus news.');
    final service=NewsOfflineService._(scope,email,box,media);
    // A process crash after send began is an unknown outcome, never a safe retry.
    final jobs=service._jobs;
    for(final job in jobs)if(job['state']=='sending'){
      job['state']='review';job['error']='Sending was interrupted. Check the server before resending.';
    }
    await box.put('outbox',jobs);
    final draftKeys={for(final job in jobs)for(var i=0;i<(job['photos'] as num).toInt();i++)'draft:${job['key']}:$i'};
    for(final key in media.keys.whereType<String>().where((k)=>k.startsWith('draft:')&&!draftKeys.contains(k)).toList())await media.delete(key);
    _instance=service;accountScope.value=scope;status.value='Saved campus news ready';
    return service;
  }
  Future<void> _guard() async {
    if(_closed||await _email()!=email||sha256.convert(utf8.encode('${ApiClient.baseUrl}|$email')).toString().substring(0,32)!=account)throw StateError('Account changed. Reopen campus news.');
  }
  void _changed(){if(!_closed&&_instance==this)revision.value++;}
  void _failed(Object error){
    _failures=min(6,_failures+1);
    _retryAfter=DateTime.now().add(Duration(seconds:min(300,5*(1<<_failures))));
    if(!_closed)status.value=_authRequired
      ? 'Saved campus news available · sign in to sync pending changes'
      : 'Saved campus news available · sync will retry automatically';
  }
  bool _denied(Object error){
    final text=error.toString().toLowerCase();
    return RegExp(r'\b401\b').hasMatch(text)||text.contains('session is invalid')||text.contains('session expired');
  }
  bool _forbidden(Object error)=>RegExp(r'\b403\b').hasMatch(error.toString());
  Future<void> _checkDenied(Object error) async {
    if(_denied(error)){
      // Keep this account's local snapshot and outbox. Authentication failures
      // pause synchronization; they must not erase offline work or attachments.
      _authRequired=true;
      _rejectedToken=(await DatabaseService.getToken()).trim();
      _retryAfter=DateTime.now().add(const Duration(minutes:5));
      if(_instance==this)status.value='Saved campus news available · sign in to sync pending changes';
      _changed();
    }
  }
  Future<dynamic> _read(String key,Future<dynamic> Function() loader,{Duration ttl=const Duration(minutes:2),bool privileged=false}) async {
    await _guard();
    final raw=box.get('cache:$key');
    final cached=raw is Map?Map<String,dynamic>.from(raw):null;
    final age=cached==null?null:DateTime.now().difference(DateTime.parse('${cached['at']}'));
    _loaders.remove(key);_loaders[key]=loader;
    while(_loaders.length>8)_loaders.remove(_loaders.keys.first);
    if(cached!=null && (!privileged||(age!=null&&!age.isNegative&&age<offlineReadLease))){
      if(!_authRequired&&(age==null||age.isNegative||age>ttl))unawaited(_fetch(key,loader).catchError((_){return null;}));
      return cached['value'];
    }
    return _fetch(key,loader);
  }
  Future<dynamic> _fetch(String key,Future<dynamic> Function() loader,{bool force=false}) {
    if(_inflight.containsKey(key))return _inflight[key]!;
    final future=_fetchOnce(key,loader,force:force);_inflight[key]=future;
    return future.whenComplete(()=>_inflight.remove(key));
  }
  Future<dynamic> _fetchOnce(String key,Future<dynamic> Function() loader,{bool force=false}) async {
    await _guard();
    if(_authRequired){
      final current=(await DatabaseService.getToken()).trim();
      if(current.isNotEmpty&&current!=_rejectedToken){_authRequired=false;_rejectedToken=null;_retryAfter=null;}
      else throw StateError('Saved data is available. Sign in to refresh campus news.');
    }
    if(!force&&_retryAfter!=null&&DateTime.now().isBefore(_retryAfter!))throw StateError('Offline. Saved data is available.');
    try{
      final value=await loader().timeout(const Duration(seconds:8));await _guard();
      await _serial(()async{
      await _guard();await box.put('cache:$key',{'at':DateTime.now().toIso8601String(),'value':value});
      // Bound snapshots by count; pages contain <=50 records and no image bytes.
      final keys=box.keys.whereType<String>().where((k)=>k.startsWith('cache:')).toList();
      if(keys.length>80){keys.sort((a,b)=>'${(box.get(a) as Map)['at']}'.compareTo('${(box.get(b) as Map)['at']}'));await box.deleteAll(keys.take(keys.length-80));}
      });
      _failures=0;_retryAfter=null;_authRequired=false;_rejectedToken=null;status.value='Saved data updated · ${_jobs.length} in outbox';_changed();return value;
    }catch(e){
      if(_forbidden(e)){
        // A permission denial is authoritative. Remove only this response
        // snapshot so private content cannot linger after access is revoked.
        await box.delete('cache:$key');
        status.value='Access to this campus news item is no longer available';
        _changed();
      }else{
        await _checkDenied(e);_failed(e);
      }
      rethrow;
    }
  }
  static Future<void> start() async {await _ready();setForeground(true);unawaited(sync());}
  static void setForeground(bool foreground){
    _foreground=foreground;_timer?.cancel();_timer=null;
    if(foreground)_timer=Timer.periodic(const Duration(minutes:2),(_)=>sync());
  }
  static void stop(){_timer?.cancel();_timer=null;_foreground=false;}
  static Future<void> sync({bool force=false}) async {
    if(!_foreground&&!force)return;
    try{
      final s=await _ready();
      if(force)s._retryAfter=null;
      if(s._retryAfter!=null&&DateTime.now().isBefore(s._retryAfter!))return;
      await s._pump();
      // Only the few recently viewed collections, never every stored query.
      for(final e in s._loaders.entries.toList()){
        try{await s._fetch(e.key,e.value,force:force);}catch(_){break;}
      }
    }catch(_){status.value='Saved data available · sync will resume when connected';}
    finally{_instance?._changed();}
  }
  static Future<CampusNewsPage> getNews({String status='published',bool mine=false,String campus='All Campuses',String category='All Categories',String search='',int page=1,int limit=8}) async {
    final s=await _ready();
    final key='items:${jsonEncode([status,mine,campus,category,search.trim().toLowerCase(),page,limit])}';
    Map data;
    try{data=await s._read(key,()async{
      final result=await api.CampusNewsService.getNews(status:status,mine:mine,campus:campus,category:category,search:search,page:page,limit:limit);
      return {'items':[for(final a in result.articles)CampusNewsArticle.remote(a).data],'hasMore':result.hasMore};
    }) as Map;}catch(e){
      if(s._closed)rethrow;
      if(s._forbidden(e)){
        NewsOfflineService.status.value='Access to this campus news is no longer available';
        return CampusNewsPage(const [],false);
      }
      final found=<int,CampusNewsArticle>{};
      for(final k in s.box.keys.whereType<String>().where((k)=>k.startsWith('cache:items:'))){
        final tuple=jsonDecode(k.substring('cache:items:'.length)) as List;
        if(tuple[0]!=status||tuple[1]!=mine)continue;
        final snapshot=s.box.get(k) as Map;
        final saved=snapshot['value'] as Map;
        for(final row in (saved['items'] as List).whereType<Map>()){
          final a=CampusNewsArticle(row);
          if(campus!='All Campuses'&&a.campus!=campus)continue;
          if(category!='All Categories'&&a.category!=category)continue;
          if(!'${a.title} ${a.body} ${a.authorName}'.toLowerCase().contains(search.trim().toLowerCase()))continue;
          final old=found[a.id];
          if(old==null||(a.updatedAt??a.createdAt).isAfter(old.updatedAt??old.createdAt))found[a.id]=a;
        }
      }
      if(found.isEmpty){
        NewsOfflineService.status.value='No saved campus news yet · it will appear after the first successful sync';
        return CampusNewsPage(const [],false);
      }
      final articles=found.values.toList()..sort((a,b)=>(b.publishedAt??b.createdAt).compareTo(a.publishedAt??a.createdAt));
      final offset=(page-1)*limit;
      return CampusNewsPage(articles.skip(offset).take(limit).toList(),articles.length>offset+limit);
    }
    return CampusNewsPage((data['items'] as List).whereType<Map>().map(CampusNewsArticle.new).toList(),data['hasMore']==true);
  }
  static Future<CampusNewsArticle> getArticle(int id) async {
    final s=await _ready();
    final data=await s._read('article:$id',()async=>CampusNewsArticle.remote(await api.CampusNewsService.getArticle(id)).data) as Map;
    return CampusNewsArticle(data);
  }
  static Future<Map<String,dynamic>> getCurrentUser() async {
    final s=await _ready();
    try{return Map<String,dynamic>.from(await s._read('me',()=>api.CampusNewsService.getCurrentUser(),ttl:const Duration(minutes:10),privileged:true) as Map);}
    catch(_){return const <String,dynamic>{};}
  }
  static Future<List<String>> getCampuses() async {
    final s=await _ready();try{return List<String>.from(await s._read('campuses',()=>api.CampusNewsService.getCampuses(),ttl:const Duration(hours:12)) as List);}catch(_){return const <String>[];}
  }
  static Future<NewsNotificationPage> getNotifications({int limit=50}) async {
    final s=await _ready();try{final data=await s._read('notices:$limit',()async{
      final p=await api.CampusNewsService.getNotifications(limit:limit);
      return {'items':[for(final n in p.notifications)CampusNewsNotification.remote(n).data],'unread':p.unreadCount};
    },privileged:true) as Map;
    return NewsNotificationPage((data['items'] as List).whereType<Map>().map(CampusNewsNotification.new).toList(),(data['unread'] as num).toInt());
    }catch(_){return NewsNotificationPage(const [],0);}
  }
  static Future<List<CampusNewsComment>> getComments(int id) async {
    final s=await _ready();try{final data=await s._read('comments:$id',()async=>[for(final c in await api.CampusNewsService.getComments(id))CampusNewsComment.remote(c).data],privileged:true) as List;
    return data.whereType<Map>().map(CampusNewsComment.new).toList();}catch(_){return const <CampusNewsComment>[];}
  }
  static Future<List<NewsMentionUser>> searchMentionUsers(String query) async {
    final s=await _ready();try{final data=await s._read('mentions:${query.trim().toLowerCase()}',()async=>[for(final u in await api.CampusNewsService.searchMentionUsers(query))NewsMentionUser.remote(u).data],ttl:const Duration(hours:1),privileged:true) as List;
    return data.whereType<Map>().map(NewsMentionUser.new).toList();}catch(_){return const <NewsMentionUser>[];}
  }
  static Future<Map<String,String>> mediaHeaders(String url) async {
    final uri=Uri.parse(url);final base=Uri.parse(ApiClient.baseUrl);
    return uri.origin==base.origin?Map<String,String>.from(await ApiClient.getHeaders()):<String,String>{};
  }

  List<Map<String,dynamic>> get _jobs=>(box.get('outbox',defaultValue:[]) as List).whereType<Map>().map((e)=>Map<String,dynamic>.from(e)).toList();
  Future<T> _serial<T>(Future<T> Function() action){
    final next=_writes.then((_)=>action());_writes=next.then<void>((_){},onError:(Object e,StackTrace st){});return next;
  }
  static Future<List<Map<String,dynamic>>> outbox() async => (await _ready())._jobs;
  static Future<void> queueAction(String kind,int id,Map<String,dynamic> payload) async {
    if(!['comment','update'].contains(kind))throw ArgumentError('Unsupported queued action');
    final s=await _ready();await s._enqueue(kind,id,payload,[]);unawaited(sync());
  }
  static Future<void> queueStory({int? id,required Map<String,dynamic> payload,required List<XFile> images,XFile? video}) async {
    final s=await _ready();final files=[...images,if(video!=null)video];final bytes=<Uint8List>[];int total=0;
    if(images.length>6)throw StateError('Maximum six images per queued story.');
    for(final file in files){
      final length=await file.length();total+=length;
      if(total>22*1024*1024)throw StateError('Use smaller attachments: maximum 22 MB per queued story.');
      if(file==video&&length>maxVideoBytes)throw StateError('Video exceeds the upload limit.');
      bytes.add(await file.readAsBytes());
    }
    await s._enqueue('story',id??0,{...payload,'imageCount':images.length,'hasVideo':video!=null,
      'fileNames':files.map((f)=>f.name).toList(),'mimeTypes':files.map((f)=>f.mimeType).toList()},bytes);
    unawaited(sync());
  }
  Future<void> _enqueue(String kind,int item,Map<String,dynamic> payload,List<Uint8List> images)=>_serial(()async{
    await _guard();final jobs=_jobs;if(jobs.length>=15)throw StateError('Review or send the existing outbox first (maximum 15).');
    final key=List.generate(16,(_)=>Random.secure().nextInt(256).toRadixString(16).padLeft(2,'0')).join();
    int pendingBytes=0;for(final job in jobs)pendingBytes+=(job['bytes'] as num? ?? 0).toInt();
    final size=images.fold<int>(0,(a,b)=>a+b.length);if(pendingBytes+size>40*1024*1024)throw StateError('Outbox attachment storage is full (40 MB).');
    try{
      for(var i=0;i<images.length;i++)await media.put('draft:$key:$i',images[i]);
      jobs.add({'key':key,'kind':kind,'item':item,'payload':payload,'photos':images.length,'bytes':size,'state':'pending','created':DateTime.now().toIso8601String()});
      await box.put('outbox',jobs);
    }catch(_){for(var i=0;i<images.length;i++)await media.delete('draft:$key:$i');rethrow;}
    status.value='Saved on this device · waiting to send';_changed();
  });
  Future<void> _saveJob(Map<String,dynamic> job)=>_serial(()async{
    await _guard();final jobs=_jobs;final index=jobs.indexWhere((j)=>j['key']==job['key']);if(index>=0){jobs[index]=job;await box.put('outbox',jobs);}_changed();
  });
  Future<bool> _claim(Map<String,dynamic> job)=>_serial(()async{
    await _guard();final jobs=_jobs;final index=jobs.indexWhere((j)=>j['key']==job['key']&&j['state']=='pending');
    if(index<0)return false;job['state']='sending';jobs[index]=job;await box.put('outbox',jobs);_changed();return true;
  });
  static Future<void> discardJob(String key) async {
    final s=await _ready();await s._serial(()async{
      await s._guard();final jobs=s._jobs;final matches=jobs.where((j)=>j['key']==key).toList();if(matches.isEmpty)return;
      if(matches.first['state']=='sending')throw StateError('Wait until this send attempt finishes.');
      final job=matches.first;jobs.removeWhere((j)=>j['key']==key);await s.box.put('outbox',jobs);
      for(var i=0;i<(job['photos'] as num).toInt();i++)await s.media.delete('draft:$key:$i');s._changed();
    });
  }
  Future<void> _pump() async {
    if(_sending||_authRequired||_jobs.every((j)=>j['state']!='pending'))return;
    _sending=true;
    try{
      // Preflight can fail without sending a mutation; these jobs remain pending.
      await _guard();await api.CampusNewsService.getCurrentUser().timeout(const Duration(seconds:12));await _guard();
      for(final job in _jobs.where((j)=>j['state']=='pending')){
        if(!_foreground)break;
        await _guard();if(!await _claim(job))continue;
        try{
          final p=Map<String,dynamic>.from(job['payload'] as Map);final id=(job['item'] as num).toInt();
          switch(job['kind']){
            case 'story':
              int storyId=id;
              if(storyId==0){
                // Create as draft, upload attachments, then publish. No automatic rollback deletion.
                storyId=await api.CampusNewsService.createNews(title:'${p['title']}',body:'${p['body']}',category:'${p['category']}',status:'draft');
                await _guard();job['server_id']=storyId;await _saveJob(job);
              }else{
                await api.CampusNewsService.updateNews(storyId,{'title':p['title'],'body':p['body'],'category':p['category']});
              }
              final files=<XFile>[];
              for(var i=0;i<(job['photos'] as num).toInt();i++){
                final bytes=await media.get('draft:${job['key']}:$i');
                if(bytes is! Uint8List)throw StateError('A saved attachment is missing.');
                files.add(XFile.fromData(bytes,name:(p['fileNames'] as List)[i] as String,mimeType:(p['mimeTypes'] as List)[i] as String?));
              }
              final imageCount=(p['imageCount'] as num).toInt();
              if(imageCount>0){await _guard();await api.CampusNewsService.uploadImages(storyId,files.take(imageCount).toList());}
              if(p['hasVideo']==true){await _guard();await api.CampusNewsService.uploadVideo(storyId,files.last);}
              await _guard();await api.CampusNewsService.updateNews(storyId,{
                'status':p['status'],
                'is_trending':p['isTrending']==true,
              });break;
            case 'comment':await api.CampusNewsService.addComment(id,'${p['text']}',parentCommentId:(p['parent'] as num?)?.toInt(),mentionUserIds:List<int>.from(p['mentions'] as List? ?? []));break;
            case 'update':await api.CampusNewsService.updateNews(id,p);break;
          }
          await _guard();job['state']='sent';await _saveJob(job);
          await discardJob('${job['key']}');await _invalidateItems();
          if(job['kind']=='comment')await box.delete('cache:comments:$id');
        }catch(e){
          // API has no visible idempotency contract: never blindly replay POSTs.
          job['state']='review';job['error']='Delivery could not be confirmed. ${e.toString()}';await _saveJob(job);await _checkDenied(e);_failed(e);break;
        }
      }
    }catch(e){await _checkDenied(e);_failed(e);}finally{_sending=false;_changed();}
  }
  Future<void> _invalidateItems()=>_serial(()async {
    await _guard();
    // Expire snapshots; retain visible data until the authoritative replacement arrives.
    for(final key in box.keys.whereType<String>().where((k)=>(k.startsWith('cache:items:')||k.startsWith('cache:article:'))).toList()){
      final data=Map<String,dynamic>.from(box.get(key) as Map);data['at']='2000-01-01T00:00:00Z';await box.put(key,data);
    }
    _changed();
  });
  static Future<T> _online<T>(Future<T> Function() action,{bool invalidate=true}) async {
    final s=await _ready();await s._guard();
    try{final value=await action();await s._guard();if(invalidate)await s._invalidateItems();return value;}
    catch(e){await s._checkDenied(e);rethrow;}
  }
  static Future<Map<String,dynamic>> toggleLike(int id)=>_online(()async=>Map<String,dynamic>.from(await api.CampusNewsService.toggleLike(id)));
  static Future<void> deleteNews(int id)=>_online(()async{await api.CampusNewsService.deleteNews(id);});
  static Future<void> deleteImage(int id)=>_online(()async{await api.CampusNewsService.deleteImage(id);});
  static Future<void> deleteVideo(int id)=>_online(()async{await api.CampusNewsService.deleteVideo(id);});
  static Future<void> downloadPhotos(int id)=>_online(()async{await api.CampusNewsService.downloadPhotos(id);},invalidate:false);
  static Future<void> downloadVideo(int id)=>_online(()async{await api.CampusNewsService.downloadVideo(id);},invalidate:false);
  static Future<void> markAllNotificationsRead()=>_online(()async{await api.CampusNewsService.markAllNotificationsRead();final s=await _ready();await s.box.deleteAll(s.box.keys.whereType<String>().where((k)=>k.startsWith('cache:notices:')).toList());});
  static Future<void> markNotificationRead(int id)=>_online(()async{await api.CampusNewsService.markNotificationRead(id);final s=await _ready();await s.box.deleteAll(s.box.keys.whereType<String>().where((k)=>k.startsWith('cache:notices:')).toList());});

  // Call and await BEFORE clearing the login session. Pending drafts are removed.
  static Future<void> clearForLogout() async {
    stop();final s=await _ready();s._closed=true;await s._serial(()async{await s.box.clear();await s.media.clear();});
    _instance=null;accountScope.value='';status.value='Signed out';revision.value++;
  }
  // Image widget API. Metadata and image bytes use separate boxes and budgets.
  static Future<Uint8List?> cachedImage(String url) async {
    final s=await _ready();await s._guard();return await s.media.get('image:${sha256.convert(utf8.encode(url))}') as Uint8List?;
  }
  static Future<void> saveImage(String url,Uint8List bytes,{required String expectedScope}) async {
    if(bytes.length>3*1024*1024)return;
    final s=await _ready();await s._guard();final key='image:${sha256.convert(utf8.encode(url))}';
    await s._serial(()async{
      await s._guard();if(s.account!=expectedScope)return;
      final index=Map<String,dynamic>.from(s.box.get('imageIndex',defaultValue:{}) as Map);
      index.remove(key);index[key]=bytes.length;
      while(index.length>100||index.values.fold<int>(0,(a,b)=>a+(b as num).toInt())>40*1024*1024){final oldest=index.keys.first;index.remove(oldest);await s.media.delete(oldest);}
      await s.media.put(key,bytes);await s.box.put('imageIndex',index);
    });
  }
}
