import 'package:mutex/mutex.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'package:simplecloudnotifier/api/api_client.dart';
import 'package:simplecloudnotifier/models/channel.dart';
import 'package:simplecloudnotifier/models/client.dart';
import 'package:simplecloudnotifier/models/keytoken.dart';
import 'package:simplecloudnotifier/models/scn_message.dart';
import 'package:simplecloudnotifier/state/application_log.dart';
import 'package:simplecloudnotifier/state/fb_message.dart';
import 'package:simplecloudnotifier/state/globals.dart';
import 'package:simplecloudnotifier/state/request_log.dart';
import 'package:simplecloudnotifier/state/app_auth.dart';

final lockHive = Mutex();

void setFirebaseToken(String fcmToken) async {
  final acc = AppAuth();

  final oldToken = Globals().getPrefFCMToken();

  await Globals().setPrefFCMToken(fcmToken);

  ApplicationLog.info('New firebase token received', additional: 'Token: $fcmToken (old: $oldToken)');

  if (!acc.isAuth()) return;

  Client? client;
  try {
    client = await acc.loadClient(forceIfOlder: Duration(seconds: 60));
  } catch (exc, trace) {
    ApplicationLog.error('Failed to get client: ' + exc.toString(), trace: trace);
    return;
  }

  if (oldToken != null && oldToken == fcmToken && client != null && client.fcmToken == fcmToken) {
    ApplicationLog.info('Firebase token unchanged - do nothing', additional: 'Token: $fcmToken');
    return;
  }

  if (client == null) {
    // should not really happen - perhaps someone externally deleted the client?
    final newClient = await APIClient.addClient(acc, fcmToken, Globals().deviceModel, Globals().version, Globals().hostname, Globals().clientType);
    acc.setClientAndClientID(newClient);
    await acc.save();
  } else {
    final newClient = await APIClient.updateClient(acc, client.clientID, fcmToken: fcmToken, agentModel: Globals().deviceModel, name: Globals().hostname, agentVersion: Globals().version);
    acc.setClientAndClientID(newClient);
    await acc.save();
  }
}

Future<void> initHive() async {
  await lockHive.protect(() async {
    if (Globals().hiveAdaptersRegistered) return;

    await Hive.initFlutter();
    Globals().hiveInitialized = true;
  });
}

Future<void> openHiveBoxes(bool safe) async {
  await lockHive.protect(() async {
    if (Globals().hiveBoxesOpened) return;

    if (!safe) {
      await Hive.openBox<SCNLog>('scn-logs');
      await Hive.openBox<SCNRequest>('scn-requests');
      await Hive.openBox<SCNMessage>('scn-message-cache');
      await Hive.openBox<Channel>('scn-channel-cache');
      await Hive.openBox<FBMessage>('scn-fb-messages');
      await Hive.openBox<KeyToken>('scn-keytoken-value-cache');
      Globals().hiveBoxesOpened = true;
      return;
    }

    try {
      print('[INIT] Load Hive<scn-logs>...');
      await Hive.openBox<SCNLog>('scn-logs');
    } catch (exc, trace) {
      Hive.deleteBoxFromDisk('scn-logs');
      await Hive.openBox<SCNLog>('scn-logs');
      ApplicationLog.error('Failed to open Hive-Box: scn-logs: ' + exc.toString(), trace: trace);
      ApplicationLog.writeRawFailure('Failed to open Hive-Box: scn-logs', {'error': exc.toString(), 'trace': trace});
    }

    try {
      print('[INIT] Load Hive<scn-requests>...');
      await Hive.openBox<SCNRequest>('scn-requests');
    } catch (exc, trace) {
      Hive.deleteBoxFromDisk('scn-requests');
      await Hive.openBox<SCNRequest>('scn-requests');
      ApplicationLog.error('Failed to open Hive-Box: scn-requests: ' + exc.toString(), trace: trace);
      ApplicationLog.writeRawFailure('Failed to open Hive-Box: scn-requests', {'error': exc.toString(), 'trace': trace});
    }

    try {
      print('[INIT] Load Hive<scn-message-cache>...');
      await Hive.openBox<SCNMessage>('scn-message-cache');
    } catch (exc, trace) {
      Hive.deleteBoxFromDisk('scn-message-cache');
      await Hive.openBox<SCNMessage>('scn-message-cache');
      ApplicationLog.error('Failed to open Hive-Box: scn-message-cache' + exc.toString(), trace: trace);
      ApplicationLog.writeRawFailure('Failed to open Hive-Box: scn-message-cache', {'error': exc.toString(), 'trace': trace});
    }

    try {
      print('[INIT] Load Hive<scn-channel-cache>...');
      await Hive.openBox<Channel>('scn-channel-cache');
    } catch (exc, trace) {
      Hive.deleteBoxFromDisk('scn-channel-cache');
      await Hive.openBox<Channel>('scn-channel-cache');
      ApplicationLog.error('Failed to open Hive-Box: scn-channel-cache' + exc.toString(), trace: trace);
      ApplicationLog.writeRawFailure('Failed to open Hive-Box: scn-channel-cache', {'error': exc.toString(), 'trace': trace});
    }

    try {
      print('[INIT] Load Hive<scn-fb-messages>...');
      await Hive.openBox<FBMessage>('scn-fb-messages');
    } catch (exc, trace) {
      Hive.deleteBoxFromDisk('scn-fb-messages');
      await Hive.openBox<FBMessage>('scn-fb-messages');
      ApplicationLog.error('Failed to open Hive-Box: scn-fb-messages' + exc.toString(), trace: trace);
      ApplicationLog.writeRawFailure('Failed to open Hive-Box: scn-fb-messages', {'error': exc.toString(), 'trace': trace});
    }

    try {
      print('[INIT] Load Hive<scn-keytoken-value-cache>...');
      await Hive.openBox<KeyToken>('scn-keytoken-value-cache');
    } catch (exc, trace) {
      Hive.deleteBoxFromDisk('scn-keytoken-value-cache');
      await Hive.openBox<KeyToken>('scn-keytoken-value-cache');
      ApplicationLog.error('Failed to open Hive-Box: scn-keytoken-value-cache' + exc.toString(), trace: trace);
      ApplicationLog.writeRawFailure('Failed to open Hive-Box: scn-keytoken-value-cache', {'error': exc.toString(), 'trace': trace});
    }

    Globals().hiveBoxesOpened = true;
  });
}

Future<void> registerHiveAdapter() async {
  await lockHive.protect(() async {
    if (Globals().hiveAdaptersRegistered) return;

    Hive.registerAdapter(SCNRequestAdapter());
    Hive.registerAdapter(SCNLogAdapter());
    Hive.registerAdapter(SCNLogLevelAdapter());
    Hive.registerAdapter(SCNMessageAdapter());
    Hive.registerAdapter(ChannelAdapter());
    Hive.registerAdapter(FBMessageAdapter());
    Hive.registerAdapter(KeyTokenAdapter());

    Globals().hiveAdaptersRegistered = true;
  });
}