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:http/http.dart' as http;
import '../networks/api_client.dart';
import 'database_service.dart';

typedef SupportJson=Map<String,dynamic>;
SupportJson supportMap(dynamic value)=>Map<String,dynamic>.from(value as Map);
List<SupportJson> supportRows(dynamic value)=>(value as List? ?? []).map(supportMap).toList();
int supportInt(dynamic value)=>int.tryParse('$value')??0;
bool supportBool(dynamic value)=>value==true||value==1||value=='t'||value=='true';
class SupportError implements Exception {
  final int code;final String message;
  SupportError(this.code,this.message);
  @override String toString()=>message;
}
class SupportFile {
  final String name;final Uint8List bytes;
  SupportFile(this.name,this.bytes);
}
/// Instance belongs to one account. Call clearForLogout before removing that session.
class ITSupportService extends ChangeNotifier {
  static const maxFileBytes=5*1024*1024;
  static Future<void>? _hive;
  static final Set<ITSupportService> _instances={};
  final String email,scope,sessionKey;
  final Box<dynamic> _box;
  final LazyBox<dynamic> _files;
  final http.Client _http=http.Client();
  final Map<String,Future<SupportJson>> _reads={};
  final Map<String,Map<String,String>> _recent={};
  Future<void> _writes=Future<void>.value();
  Timer? _timer;
  bool _closed=false,_syncing=false,_foreground=true;
  int _failures=0;
  DateTime? _retryAfter;
  String status='Saved support workspace ready';
  ITSupportService._(this.email,this.scope,this.sessionKey,this._box,this._files);
  static Future<ITSupportService> open() async {
    // Reuse the app's saved bearer session. A missing local profile should not
    // force a second sign-in when the main app session is still valid.
    final headers=await ApiClient.getHeaders();
    final bearer=_bearer(headers);
    if(bearer.isEmpty)throw SupportError(401,'Your saved sign-in session is missing. Sign in to continue.');
    final sessionKey=sha256.convert(utf8.encode(bearer)).toString();
    final user=await DatabaseService.getLocalUser();
    var email='${user?.email??''}'.trim().toLowerCase();
    _hive??=Hive.initFlutter();await _hive;
    final identities=await Hive.openBox<dynamic>('rvu_it_identity_v1');
    // This small identity cache lets the offline-first panel reopen offline
    // after it has already been opened once with this same saved session.
    if(email.isEmpty)email='${identities.get(sessionKey)??''}'.trim().toLowerCase();
    if(email.isEmpty){
      final response=await http.get(Uri.parse('${ApiClient.baseUrl}/api/it_support.php').replace(queryParameters:{'op':'me'}),headers:headers).timeout(const Duration(seconds:20));
      dynamic data;try{data=jsonDecode(response.body);}catch(_){throw SupportError(response.statusCode>=400?response.statusCode:502,'Could not verify the saved sign-in session.');}
      if(response.statusCode<200||response.statusCode>=300)throw SupportError(response.statusCode,data is Map?'${data['detail']??'Saved sign-in session is no longer valid.'}':'Saved sign-in session is no longer valid.');
      if(data is Map&&data['user'] is Map)email='${data['user']['email']??''}'.trim().toLowerCase();
    }
    if(email.isEmpty)throw SupportError(401,'Could not find the account for this saved session. Sign in to continue.');
    await identities.put(sessionKey,email);
    final scope=sha256.convert(utf8.encode('${ApiClient.baseUrl}|$email')).toString().substring(0,32);
    // Only one active support route per account; do not create competing outbox pumps.
    for(final old in _instances.toList())old.close();
    final box=await Hive.openBox<dynamic>('rvu_it_v1_$scope');
    final files=await Hive.openLazyBox<dynamic>('rvu_it_files_v1_$scope');
    final s=ITSupportService._(email,scope,sessionKey,box,files);_instances.add(s);
    // Sending can safely return to pending: the server has transactional receipts.
    final jobs=s.jobs;
    for(final job in jobs)if(job['state']=='sending')job['state']='pending';
    await box.put('jobs',jobs);
    final refs={for(final job in jobs)if(job['file_key']!=null)'${job['file_key']}'};
    for(final key in files.keys.toList())if(!refs.contains(key))await files.delete(key);
    s.setForeground(true);return s;
  }
  static String _bearer(Map<String,String> headers){
    for(final entry in headers.entries){
      if(entry.key.toLowerCase()=='authorization'){
        final value=entry.value.trim();
        if(value.toLowerCase().startsWith('bearer '))return value.substring(7).trim();
      }
    }
    return '';
  }
  Future<void> _guard() async {
    final headers=await ApiClient.getHeaders();
    final currentBearer=_bearer(headers);
    final user=await DatabaseService.getLocalUser();final currentEmail='${user?.email??''}'.trim().toLowerCase();
    if(_closed||currentBearer.isEmpty||sha256.convert(utf8.encode(currentBearer)).toString()!=sessionKey||(currentEmail.isNotEmpty&&currentEmail!=email)){
      close();throw SupportError(401,'Your sign-in session changed. Reopen IT Support.');
    }
  }
  bool get closed=>_closed;
  void _changed(){if(!_closed)notifyListeners();}
  void setForeground(bool active){_foreground=active;_timer?.cancel();if(active&&!_closed)_timer=Timer.periodic(const Duration(minutes:2),(_)=>sync());}
  void close(){if(_closed)return;_closed=true;_timer?.cancel();_http.close();_instances.remove(this);notifyListeners();}
  @override void dispose(){close();super.dispose();}
  static Future<void> clearForLogout() async {
    final user=await DatabaseService.getLocalUser();final email='${user?.email??''}'.trim().toLowerCase();
    for(final s in _instances.toList()){s.close();await s._serial(()async{});}
    if(email.isEmpty)return;
    final scope=sha256.convert(utf8.encode('${ApiClient.baseUrl}|$email')).toString().substring(0,32);
    _hive??=Hive.initFlutter();await _hive;
    final box=await Hive.openBox<dynamic>('rvu_it_v1_$scope');final files=await Hive.openLazyBox<dynamic>('rvu_it_files_v1_$scope');
    await box.clear();await files.clear();
  }
  Future<T> _serial<T>(Future<T> Function() action){final f=_writes.then((_)=>action());_writes=f.then<void>((_){},onError:(Object _,StackTrace __){});return f;}
  String _key()=>List.generate(16,(_)=>Random.secure().nextInt(256).toRadixString(16).padLeft(2,'0')).join();
  Uri _url(String op,Map<String,String> parameters)=>Uri.parse('${ApiClient.baseUrl}/api/it_support.php').replace(queryParameters:{'op':op,...parameters});
  Future<SupportJson> _decode(http.Response response) async {
    dynamic data;try{data=jsonDecode(response.body);}catch(_){throw SupportError(response.statusCode>=400?response.statusCode:502,'Invalid support server response.');}
    if(response.statusCode<200||response.statusCode>=300){
      if(response.statusCode==401){await _serial(()async{await _box.clear();await _files.clear();});close();}
      throw SupportError(response.statusCode,data is Map?'${data['detail']??'Request failed.'}':'Request failed.');
    }
    if(data is! Map)throw SupportError(502,'Invalid support server response.');return supportMap(data);
  }
  Future<SupportJson> read(String op,[Map<String,String> parameters=const {},bool force=false]) async {
    await _guard();final key=jsonEncode([op,parameters]);_recent.remove(key);_recent[key]=parameters;
    while(_recent.length>8)_recent.remove(_recent.keys.first);
    final saved=_box.get('cache:$key');
    if(!force&&saved is Map){
      final age=DateTime.now().difference(DateTime.parse('${saved['at']}'));
      if(age>=Duration.zero&&age<const Duration(hours:12)){
        if(saved['stale']==true||age>const Duration(minutes:2))unawaited(_fetch(op,parameters,key).catchError((_)=> <String,dynamic>{}));
        return supportMap(saved['data']);
      }
    }
    return _fetch(op,parameters,key,force:force);
  }
  Future<SupportJson> _fetch(String op,Map<String,String> parameters,String key,{bool force=false}){
    return _reads.putIfAbsent(key,()=>_fetchOne(op,parameters,key,force:force).whenComplete(()=>_reads.remove(key)));
  }
  Future<SupportJson> _fetchOne(String op,Map<String,String> parameters,String key,{bool force=false}) async {
    await _guard();if(!force&&_retryAfter!=null&&DateTime.now().isBefore(_retryAfter!))throw SupportError(0,'Offline. Saved content remains available.');
    try{
      final response=await _http.get(_url(op,parameters),headers:await ApiClient.getHeaders()).timeout(const Duration(seconds:20));
      final data=await _decode(response);await _guard();
      await _serial(()async{
        await _guard();await _box.put('cache:$key',{'at':DateTime.now().toIso8601String(),'data':data});
        final keys=_box.keys.whereType<String>().where((k)=>k.startsWith('cache:')).toList();
        if(keys.length>60){keys.sort((a,b)=>'${(_box.get(a) as Map)['at']}'.compareTo('${(_box.get(b) as Map)['at']}'));await _box.deleteAll(keys.take(keys.length-60));}
      });
      _failures=0;_retryAfter=null;status='Updated · ${jobs.length} in outbox';_changed();return data;
    }catch(e){
      if(e is SupportError&&[403,404].contains(e.code)){await _box.delete('cache:$key');_changed();}
      _failed(e);rethrow;
    }
  }
  void _failed(Object e){if(_closed)return;_failures=min(6,_failures+1);_retryAfter=DateTime.now().add(Duration(seconds:min(300,5*(1<<_failures))));status='Offline or unavailable · saved work retained';}
  List<SupportJson> get jobs=>supportRows(_box.get('jobs',defaultValue:[]));
  SupportJson draft(String key)=>_box.get('draft:$key') is Map?supportMap(_box.get('draft:$key')):<String,dynamic>{};
  Future<void> saveDraft(String key,SupportJson data)=>_serial(()async{await _guard();await _box.put('draft:$key',data);});
  Future<String> queue(String op,SupportJson payload,{SupportFile? file,String? ticketRef,String? clearDraft})=>_serial(()async{
    await _guard();final jobs=this.jobs;if(jobs.length>=25)throw SupportError(422,'Send or review the existing outbox first (25 entries maximum).');
    if(file!=null&&(file.bytes.isEmpty||file.bytes.length>maxFileBytes))throw SupportError(413,'Each attachment must be no larger than 5 MB.');
    final total=jobs.fold<int>(0,(n,j)=>n+supportInt(j['size']));if(total+(file?.bytes.length??0)>25*1024*1024)throw SupportError(413,'Outbox attachment limit reached (25 MB).');
    final key=_key();
    try{
      if(file!=null)await _files.put(key,file.bytes);
      jobs.add({'key':key,'op':op,'payload':payload,'state':'pending','ticket_ref':ticketRef,'file_key':file==null?null:key,'filename':file?.name,'size':file?.bytes.length??0,'created':DateTime.now().toIso8601String()});
      await _box.put('jobs',jobs);if(clearDraft!=null)await _box.delete('draft:$clearDraft');
    }catch(_){if(file!=null)await _files.delete(key);rethrow;}
    status='Saved on this device · waiting to send';_changed();unawaited(sync());return key;
  });
  Future<void> discard(String key)=>_serial(()async{
    await _guard();final jobs=this.jobs;final i=jobs.indexWhere((j)=>j['key']==key);if(i<0)return;
    if(jobs[i]['state']=='sending')throw SupportError(409,'Wait for this send attempt to finish.');
    if(jobs.any((j)=>j['ticket_ref']==key))throw SupportError(409,'Remove dependent attachments first.');
    final file=jobs[i]['file_key'];jobs.removeAt(i);await _box.put('jobs',jobs);if(file!=null)await _files.delete(file);_changed();
  });
  Future<bool> _job(SupportJson job,{bool claim=false,bool remove=false})=>_serial(()async{
    await _guard();final jobs=this.jobs;final i=jobs.indexWhere((j)=>j['key']==job['key']);if(i<0)return false;
    if(claim&&jobs[i]['state']!='pending')return false;
    if(remove){jobs.removeAt(i);}else{if(claim)job['state']='sending';jobs[i]=job;}
    await _box.put('jobs',jobs);_changed();return true;
  });
  Future<void> sync({bool force=false}) async {
    if(_closed||_syncing||(!_foreground&&!force))return;
    if(!force&&_retryAfter!=null&&DateTime.now().isBefore(_retryAfter!))return;
    _syncing=true;if(force||(_retryAfter!=null&&!DateTime.now().isBefore(_retryAfter!)))_retryAfter=null;
    try{
      await _guard();
      for(final job in jobs.where((j)=>j['state']=='pending')){
        if(!_foreground&&!force)break;
        final payload=supportMap(job['payload']);final ref=job['ticket_ref'];
        if(ref!=null){final id=_box.get('result:$ref');if(id==null)continue;payload['ticket_id']=id;}
        if(!await _job(job,claim:true))continue;
        try{
          await _guard();http.Response response;
          if(job['op']=='attach'){
            final bytes=await _files.get(job['file_key']);if(bytes is! Uint8List)throw SupportError(422,'Saved attachment is missing.');
            final request=http.MultipartRequest('POST',_url('attach',{}));
            request.headers.addAll(await ApiClient.getHeaders());request.headers.removeWhere((k,_)=>k.toLowerCase()=='content-type');
            request.fields.addAll({'client_key':'${job['key']}',...payload.map((k,v)=>MapEntry(k,'$v'))});
            request.files.add(http.MultipartFile.fromBytes('file',bytes,filename:'${job['filename']}'));
            response=await http.Response.fromStream(await _http.send(request).timeout(const Duration(seconds:60))).timeout(const Duration(seconds:30));
          }else{
            response=await _http.post(_url('${job['op']}',{}),headers:{...await ApiClient.getHeaders(),'Content-Type':'application/json'},body:jsonEncode({...payload,'client_key':job['key']})).timeout(const Duration(seconds:30));
          }
          final result=await _decode(response);await _guard();_retryAfter=null;_failures=0;status='Saved changes delivered';
          if(result['ticket_id']!=null)await _box.put('result:${job['key']}',supportInt(result['ticket_id']));
          await _job(job,remove:true);if(job['file_key']!=null)await _files.delete(job['file_key']);
          await _serial(()async{for(final key in _box.keys.whereType<String>().where((k)=>k.startsWith('cache:')).toList()){final saved=supportMap(_box.get(key));saved['stale']=true;await _box.put(key,saved);}});
        }catch(e){
          if(_closed)break;
          job['state']=e is SupportError&&e.code>=400&&e.code<500&&e.code!=408&&e.code!=429?'review':'pending';job['error']=e.toString();await _job(job);_failed(e);break;
        }
      }
      if(_retryAfter==null)for(final key in _recent.keys.toList()){
        final parts=jsonDecode(key) as List;
        try{await read('${parts[0]}',Map<String,String>.from(parts[1] as Map),true);}catch(_){break;}
      }
    }catch(e){_failed(e);}finally{_syncing=false;_changed();}
  }
  Future<Uint8List> download(SupportJson file) async {
    await _guard();final response=await _http.get(_url('download',{'id':'${file['id']}'}),headers:await ApiClient.getHeaders()).timeout(const Duration(seconds:30));
    if(response.statusCode!=200){await _decode(response);throw SupportError(500,'Download failed.');}
    await _guard();final bytes=response.bodyBytes;
    if(bytes.length>maxFileBytes||bytes.length!=supportInt(file['size_bytes'])||sha256.convert(bytes).toString()!=file['sha256'])throw SupportError(502,'Attachment verification failed.');return bytes;
  }
}
