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 'package:http/http.dart' as http;

import 'campus_market_service.dart' as api;

import 'database_service.dart';

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

import 'market_local_models.dart';

export 'market_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 MarketOfflineService {

  static final revision=ValueNotifier<int>(0);

  static final status=ValueNotifier<String>('Opening saved marketplace…');

  static final accountScope=ValueNotifier<String>('');

  static MarketOfflineService? _instance;

  static Future<void>? _hive;

  static Future<MarketOfflineService>? _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;

  int _failures=0;

  Future<void> _writes=Future<void>.value();

  MarketOfflineService._(this.account,this.email,this.box,this.media);

  static List<String> get categories=>api.CampusMarketService.categories;

  static List<String> get conditions=>api.CampusMarketService.conditions;

  // Upload paths must be joined to the app root, even if baseUrl ends in /api.

  // Static files live beside the api folder, under /uploads.

  static String mediaUrl(String path){

    final value=path.trim();

    if(value.isEmpty||value.startsWith('data:')||value.startsWith('http://')||value.startsWith('https://'))return value;

    final base=Uri.parse(ApiClient.baseUrl);

    var root=base.path.replaceAll(RegExp(r'/+$'),'');

    if(root.endsWith('/api'))root=root.substring(0,root.length-4);

    final clean=value.replaceAll('\\\\','/').replaceFirst(RegExp(r'^/+'),'');

    return base.replace(path:'$root/$clean',query:null,fragment:null).toString();

  }

  static bool isStoredPath(String path){

    final value=path.trim().replaceAll('\\\\','/');

    if(api.CampusMarketService.isStoredPath(value))return true;

    final lower=value.toLowerCase();

    return (value.startsWith('/')||value.contains('/'))&&

        (lower.endsWith('.jpg')||lower.endsWith('.jpeg')||lower.endsWith('.png')||lower.endsWith('.webp')||lower.endsWith('.gif'));

  }



  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 marketplace.');

    return value;

  }

  static Future<MarketOfflineService> _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<MarketOfflineService> _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_market_v1_$scope');

    final media=await Hive.openLazyBox<dynamic>('rvu_market_media_v1_$scope');

    if(await _email()!=email)throw StateError('Account changed. Reopen marketplace.');

    final service=MarketOfflineService._(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 marketplace 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 marketplace.');

  }

  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='Connection unavailable · showing saved data';

  }

  bool _denied(Object error){

    final text=error.toString().toLowerCase();

    return RegExp(r'\b(401|403)\b').hasMatch(text)||text.contains('unauthori')||text.contains('forbidden')||text.contains('session expired');

  }

  Future<void> _checkDenied(Object error) async {

    if(_denied(error)){

      await box.clear();await media.clear();_closed=true;

      if(_instance==this){accountScope.value='';status.value='Sign in again to verify marketplace access';}

      _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<const Duration(minutes:15)))){

      if(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(!force&&_retryAfter!=null&&DateTime.now().isBefore(_retryAfter!))throw StateError('Offline. Saved data is available.');

    try{

      final value=await loader().timeout(const Duration(seconds:20));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;status.value='Up to date · ${_jobs.length} in outbox';_changed();return value;

    }catch(e){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(e){status.value='Saved data available · ${e.toString()}';}

    finally{_instance?._changed();}

  }

  static Future<MarketPage> getItems({String status='active',bool mine=false,bool moderation=false,String category='All Categories',String campus='All Campuses',String search='',int page=1,int limit=12}) async {

    final s=await _ready();

    final key='items:${jsonEncode([status,mine,moderation,category,campus,search.trim().toLowerCase(),page,limit])}';

    Future<dynamic> loader() async {

      final result=await api.CampusMarketService.getItems(status:status,mine:mine,moderation:moderation,category:category,campus:campus,search:search,page:page,limit:limit);

      return {'items':[for(final item in result.items)MarketItem.remote(item).data],'hasMore':result.hasMore};

    }

    Map data;

    try{data=Map.from(await s._read(key,loader,privileged:moderation) as Map);}

    catch(e){

      if(moderation||s._closed)rethrow;

      // New searches can still use previously saved pages, never another scope.

      final found=<int,MarketItem>{};

      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||tuple[2]!=moderation)continue;

        final saved=(s.box.get(k) as Map)['value'] as Map;

        for(final row in (saved['items'] as List).whereType<Map>()){

          final item=MarketItem(row);final q=search.trim().toLowerCase();

          if(category!='All Categories'&&item.category!=category)continue;

          if(campus!='All Campuses'&&item.campus!=campus)continue;

          if(!'${item.title} ${item.category} ${item.sellerName}'.toLowerCase().contains(q))continue;

          found[item.id]=item;

        }

      }

      if(found.isEmpty)rethrow;

      final items=found.values.toList()..sort((a,b)=>b.createdAt.compareTo(a.createdAt));

      final from=(page-1)*limit;return MarketPage(items.skip(from).take(limit).toList(),items.length>from+limit);

    }

    return MarketPage((data['items'] as List).whereType<Map>().map(MarketItem.new).toList(),data['hasMore']==true);

  }

  static Future<Map<String,dynamic>> getCurrentUser({bool requireFreshRole=false}) async {

    final s=await _ready();return Map<String,dynamic>.from(await s._read('me',()=>api.CampusMarketService.getCurrentUser(),ttl:const Duration(minutes:10),privileged:requireFreshRole) as Map);

  }

  static Future<List<String>> getCampuses() async {

    final s=await _ready();return List<String>.from(await s._read('campuses',()=>api.CampusMarketService.getCampuses(),ttl:const Duration(hours:12)) as List);

  }

  static Future<MarketNotificationPage> getNotifications({int limit=30}) async {

    final s=await _ready();final data=await s._read('notices:$limit',()async{

      final p=await api.CampusMarketService.getNotifications(limit:limit);

      return {'items':[for(final n in p.items)MarketNotification.remote(n).data],'unread':p.unreadCount};

    }) as Map;

    return MarketNotificationPage((data['items'] as List).whereType<Map>().map(MarketNotification.new).toList(),(data['unread'] as num).toInt());

  }

  static Future<List<MarketComment>> getComments(int id) async {

    final s=await _ready();final data=await s._read('comments:$id',()async=>[for(final c in await api.CampusMarketService.getComments(id))MarketComment.remote(c).data]) as List;

    return data.whereType<Map>().map(MarketComment.new).toList();

  }

  static Future<List<MarketMentionableUser>> getMentionableUsers(int id) async {

    final s=await _ready();final data=await s._read('mentions:$id',()async=>[for(final u in await api.CampusMarketService.getMentionableUsers(id))MarketMentionableUser.remote(u).data],ttl:const Duration(hours:1)) as List;

    return data.whereType<Map>().map(MarketMentionableUser.new).toList();

  }



  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','inquiry','update','report'].contains(kind))throw ArgumentError('Unsupported queued action');

    final s=await _ready();await s._enqueue(kind,id,payload,[]);unawaited(sync());

  }

  static Future<void> queueListing(Map<String,dynamic> payload,List<XFile> images) async {

    final s=await _ready();final bytes=<Uint8List>[];int total=0;

    if(images.length>6)throw StateError('Maximum six images.');

    for(final image in images){final b=await image.readAsBytes();total+=b.length;if(total>12*1024*1024)throw StateError('Use smaller photos: maximum 12 MB per queued listing.');bytes.add(b);}

    await s._enqueue('listing',0,{...payload,'photoNames':images.map((i)=>i.name).toList(),'photoMimeTypes':images.map((i)=>i.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 photo 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();

  });

  bool _canSend(Map<String,dynamic> job){
    if(job['state']=='pending')return true;
    // A listing already created on the server can resume its photo upload safely.
    return job['kind']=='listing'&&job['state']=='review'&&int.tryParse('${job['server_id']??''}')!=null;
  }

  Future<bool> _claim(Map<String,dynamic> job)=>_serial(()async{

    await _guard();final jobs=_jobs;final index=jobs.indexWhere((j)=>j['key']==job['key']&&_canSend(j));

    if(index<0)return false;job['state']='sending';jobs[index]=job;await box.put('outbox',jobs);_changed();return true;

  });

  String _serverMessage(http.Response response){
    try{final value=jsonDecode(response.body);if(value is Map)return '${value['detail']??value['message']??response.body}';}catch(_){}
    return response.body.trim().isEmpty?'Image upload failed (${response.statusCode}).':response.body;
  }

  Future<int> _uploadedImageCount(int listingId) async {
    final url=Uri.parse('${ApiClient.baseUrl}/api/market_feed.php').replace(queryParameters:{'id':'$listingId'});
    final response=await http.get(url,headers:await ApiClient.getHeaders()).timeout(const Duration(seconds:20));
    await ApiClient.handleUnauthorized(response);
    if(response.statusCode!=200)throw StateError(_serverMessage(response));
    final payload=jsonDecode(response.body);
    if(payload is! Map||payload['data'] is! Map)throw const FormatException('The server did not return the listing details.');
    dynamic images=(payload['data'] as Map)['media'];
    if(images is String){try{images=jsonDecode(images);}catch(_){images=const [];}}
    return images is List?images.length:0;
  }

  Future<void> _uploadListingImages(int listingId,Map<String,dynamic> job,Map<String,dynamic> payload) async {
    final photoCount=(job['photos'] as num? ?? 0).toInt();
    var alreadyUploaded=await _uploadedImageCount(listingId);
    if(alreadyUploaded>photoCount)alreadyUploaded=photoCount;
    for(var i=alreadyUploaded;i<photoCount;i++){
      final bytes=await media.get('draft:${job['key']}:$i');
      if(bytes is! Uint8List||bytes.isEmpty)throw StateError('Saved photo ${i+1} is missing or empty.');
      if(bytes.length>8*1024*1024)throw StateError('Photo ${i+1} is larger than the server limit of 8 MB. Choose a smaller photo.');
      final photoNames=payload['photoNames'];
      final rawName=photoNames is List&&i<photoNames.length?'${photoNames[i]}':'market_${job['key']}_$i.jpg';
      final fileName=rawName.replaceAll(RegExp(r'[^A-Za-z0-9._-]'),'_');
      final request=http.MultipartRequest('POST',Uri.parse('${ApiClient.baseUrl}/api/market_media.php'));
      final headers=await ApiClient.getHeaders();
      headers.removeWhere((key,_)=>key.toLowerCase()=='content-type');
      request.headers.addAll(headers);
      request.fields['item_id']='$listingId';
      request.files.add(http.MultipartFile.fromBytes('images[]',bytes,filename:fileName));
      final streamed=await request.send().timeout(const Duration(seconds:60));
      final response=await http.Response.fromStream(streamed);
      await ApiClient.handleUnauthorized(response);
      if(response.statusCode!=200&&response.statusCode!=201)throw StateError(_serverMessage(response));
      alreadyUploaded++;
    }
  }

  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||_jobs.every((j)=>!_canSend(j)))return;

    _sending=true;

    try{

      // Preflight can fail without sending a mutation; these jobs remain pending.

      await _guard();await api.CampusMarketService.getCurrentUser().timeout(const Duration(seconds:12));await _guard();

      for(final job in _jobs.where(_canSend).toList()){

        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 'listing':

              final previousId=int.tryParse('${job['server_id']??''}');
              final listingId=previousId??await api.CampusMarketService.createItem(title:'${p['title']}',description:'${p['description']}',price:(p['price'] as num).toDouble(),category:'${p['category']}',condition:'${p['condition']}',quantity:(p['quantity'] as num).toInt(),sellerPhone:'${p['sellerPhone']}',location:'${p['location']}');
              if(previousId==null){await _guard();job['server_id']=listingId;await _saveJob(job);}
              if((job['photos'] as num? ?? 0)>0){await _guard();await _uploadListingImages(listingId,job,p);}
              break;

            case 'comment':await api.CampusMarketService.addComment(id,'${p['text']}',parentCommentId:(p['parent'] as num?)?.toInt(),mentionUserIds:List<int>.from(p['mentions'] as List? ?? []));break;

            case 'inquiry':await api.CampusMarketService.sendInquiry(id,'${p['text']}');break;

            case 'update':await api.CampusMarketService.updateItem(id,p);break;

            case 'report':await api.CampusMarketService.reportItem(id,'${p['reason']}');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() async {

    // Expire snapshots; retain visible data until the authoritative replacement arrives.

    for(final key in box.keys.whereType<String>().where((k)=>k.startsWith('cache:items:')).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) async {

    final s=await _ready();await s._guard();

    try{final value=await action();await s._guard();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.CampusMarketService.toggleLike(id)));

  static Future<void> deleteItem(int id)=>_online(()async{await api.CampusMarketService.deleteItem(id);});

  static Future<void> moderateItem(int id,String action)=>_online(()async{await api.CampusMarketService.moderateItem(id,action);});

  static Future<void> markAllNotificationsRead()=>_online(()async{await api.CampusMarketService.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.CampusMarketService.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.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> removeCachedImage(String url) async {

    final s=await _ready();await s._guard();final key='image:${sha256.convert(utf8.encode(url))}';

    await s.media.delete(key);

    final index=Map<String,dynamic>.from(s.box.get('imageIndex',defaultValue:{}) as Map);

    if(index.remove(key)!=null)await s.box.put('imageIndex',index);

  }

  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);

    });

  }

}
