// ignore_for_file: implementation_imports, depend_on_referenced_packages

import 'dart:async';
import 'dart:math';

import 'package:collection/collection.dart';
import 'package:matrix/matrix.dart';
import 'package:sqflite_common/sqflite.dart';
import 'package:synchronized/synchronized.dart';

import 'package:fluffychat/pangea/analytics_data/derived_analytics_data_model.dart';
import 'package:fluffychat/pangea/analytics_misc/construct_type_enum.dart';
import 'package:fluffychat/pangea/analytics_misc/construct_use_model.dart';
import 'package:fluffychat/pangea/analytics_misc/construct_use_type_enum.dart';
import 'package:fluffychat/pangea/analytics_misc/constructs_event.dart';
import 'package:fluffychat/pangea/analytics_misc/constructs_model.dart';
import 'package:fluffychat/pangea/constructs/construct_identifier.dart';

import 'package:matrix/src/database/database_file_storage_stub.dart'
    if (dart.library.io) 'package:matrix/src/database/database_file_storage_io.dart';
import 'package:matrix/src/database/indexeddb_box.dart'
    if (dart.library.io) 'package:matrix/src/database/sqflite_box.dart';

class AnalyticsDatabase with DatabaseFileStorage {
  final String name;

  late BoxCollection _collection;
  late Box<String> _lastEventTimestampBox;

  late Box<List> _serverConstructsBox;
  late Box<List> _localConstructsBox;
  late Box<Map> _aggregatedServerVocabConstructsBox;
  late Box<Map> _aggregatedLocalVocabConstructsBox;
  late Box<Map> _aggregatedServerMorphConstructsBox;
  late Box<Map> _aggregatedLocalMorphConstructsBox;
  late Box<Map> _derivedStatsBox;

  static const String _serverConstructsBoxName = 'box_server_constructs';

  static const String _localConstructsBoxName = 'box_local_constructs';

  /// Key is Tuple of construct lemma, type, and category
  static const String _aggregatedServerVocabConstructsBoxName =
      'box_aggregated_server_vocab_constructs';

  static const String _aggregatedLocalVocabConstructsBoxName =
      'box_aggregated_local_vocab_constructs';

  static const String _aggregatedServerMorphConstructsBoxName =
      'box_aggregated_server_morph_constructs';

  static const String _aggregatedLocalMorphConstructsBoxName =
      'box_aggregated_local_morph_constructs';

  static const String _derivedStatsBoxName = 'box_derived_stats';

  static const String _lastEventTimestampBoxName = 'box_last_event_timestamp';

  Database? database;

  /// Custom IdbFactory used to create the indexedDB. On IO platforms it would
  /// lead to an error to import "dart:indexed_db" so this is dynamically
  /// typed.
  final dynamic idbFactory;

  /// Custom SQFlite Database Factory used for high level operations on IO
  /// like delete. Set it if you want to use sqlite FFI.
  final DatabaseFactory? sqfliteFactory;

  static Future<AnalyticsDatabase> init(
    String name, {
    Database? database,
    dynamic idbFactory,
    DatabaseFactory? sqfliteFactory,
    Uri? fileStorageLocation,
    Duration? deleteFilesAfterDuration,
  }) async {
    final analyticsDatabase = AnalyticsDatabase._(
      name,
      database: database,
      idbFactory: idbFactory,
      sqfliteFactory: sqfliteFactory,
      fileStorageLocation: fileStorageLocation,
      deleteFilesAfterDuration: deleteFilesAfterDuration,
    );
    await analyticsDatabase.open();
    return analyticsDatabase;
  }

  AnalyticsDatabase._(
    this.name, {
    this.database,
    this.idbFactory,
    this.sqfliteFactory,
    Uri? fileStorageLocation,
    Duration? deleteFilesAfterDuration,
  }) {
    this.fileStorageLocation = fileStorageLocation;
    this.deleteFilesAfterDuration = deleteFilesAfterDuration;
  }

  final _lock = Lock();

  Future<void> open() async {
    _collection = await BoxCollection.open(
      name,
      {
        _lastEventTimestampBoxName,
        _serverConstructsBoxName,
        _localConstructsBoxName,
        _aggregatedServerVocabConstructsBoxName,
        _aggregatedLocalVocabConstructsBoxName,
        _aggregatedServerMorphConstructsBoxName,
        _aggregatedLocalMorphConstructsBoxName,
        _derivedStatsBoxName,
      },
      sqfliteDatabase: database,
      sqfliteFactory: sqfliteFactory,
      idbFactory: idbFactory,
      version: MatrixSdkDatabase.version,
    );

    _lastEventTimestampBox = _collection.openBox<String>(
      _lastEventTimestampBoxName,
    );
    _serverConstructsBox = _collection.openBox<List>(_serverConstructsBoxName);
    _localConstructsBox = _collection.openBox<List>(_localConstructsBoxName);
    _aggregatedServerVocabConstructsBox = _collection.openBox<Map>(
      _aggregatedServerVocabConstructsBoxName,
    );
    _aggregatedLocalVocabConstructsBox = _collection.openBox<Map>(
      _aggregatedLocalVocabConstructsBoxName,
    );
    _aggregatedServerMorphConstructsBox = _collection.openBox<Map>(
      _aggregatedServerMorphConstructsBoxName,
    );
    _aggregatedLocalMorphConstructsBox = _collection.openBox<Map>(
      _aggregatedLocalMorphConstructsBoxName,
    );
    _derivedStatsBox = _collection.openBox<Map>(_derivedStatsBoxName);
  }

  Future<void> delete() async {
    await _collection.deleteDatabase(
      database?.path ?? name,
      sqfliteFactory ?? idbFactory,
    );
  }

  Future<void> clear() async {
    _lastEventTimestampBox.clearQuickAccessCache();
    _serverConstructsBox.clearQuickAccessCache();
    _localConstructsBox.clearQuickAccessCache();
    _aggregatedServerVocabConstructsBox.clearQuickAccessCache();
    _aggregatedLocalVocabConstructsBox.clearQuickAccessCache();
    _aggregatedServerMorphConstructsBox.clearQuickAccessCache();
    _aggregatedLocalMorphConstructsBox.clearQuickAccessCache();
    _derivedStatsBox.clearQuickAccessCache();
    await _collection.clear();
  }

  Future<T> _transaction<T>(Future<T> Function() action) {
    return _lock.synchronized(action);
  }

  Box<Map> _aggBox(ConstructTypeEnum type, bool local) =>
      switch ((type, local)) {
        (ConstructTypeEnum.vocab, true) => _aggregatedLocalVocabConstructsBox,
        (ConstructTypeEnum.vocab, false) => _aggregatedServerVocabConstructsBox,
        (ConstructTypeEnum.morph, true) => _aggregatedLocalMorphConstructsBox,
        (ConstructTypeEnum.morph, false) => _aggregatedServerMorphConstructsBox,
      };

  String _langKey(String key, String language) => '$language|$key';

  bool _isLanguageKey(String key, String language) =>
      key.startsWith('$language|');

  Future<String?> getUserID() => _lastEventTimestampBox.get('user_id');

  Future<DateTime?> getLastUpdated(String language) async {
    final entry = await _lastEventTimestampBox.get(
      _langKey('last_updated', language),
    );
    if (entry == null) return null;
    return DateTime.tryParse(entry);
  }

  Future<DateTime?> getLastEventTimestamp(String language) async {
    final timestampString = await _lastEventTimestampBox.get(
      _langKey('last_event_timestamp', language),
    );
    if (timestampString == null) return null;
    return DateTime.parse(timestampString);
  }

  Future<String?> getCurrentLanguage() async {
    return _lastEventTimestampBox.get('current_language');
  }

  Future<DerivedAnalyticsDataModel> getDerivedStats(String language) async {
    final raw = await _derivedStatsBox.get(_langKey('derived_stats', language));
    return raw == null
        ? DerivedAnalyticsDataModel()
        : DerivedAnalyticsDataModel.fromJson(Map<String, dynamic>.from(raw));
  }

  Future<List<OneConstructUse>> getUses(
    String language, {
    int? count,
    String? roomId,
    DateTime? since,
    List<ConstructUseTypeEnum>? types,
  }) async {
    final stopwatch = Stopwatch()..start();
    final results = <OneConstructUse>[];

    bool addUseIfValid(OneConstructUse use) {
      if (since != null && use.timeStamp.isBefore(since)) {
        return false; // stop iteration entirely
      }
      if (roomId != null && use.metadata.roomId != roomId) {
        return true; // skip but continue
      }
      if (types != null && !types.contains(use.useType)) {
        return true; // skip but continue
      }

      results.add(use);
      return count == null || results.length < count;
    }

    // ---- Local uses ----
    final localUses = await getLocalUses(language)
      ..sort((a, b) => b.timeStamp.compareTo(a.timeStamp));

    for (final use in localUses) {
      if (!addUseIfValid(use)) break;
    }

    if (count != null && results.length >= count) {
      stopwatch.stop();
      Logs().i("Get uses took ${stopwatch.elapsedMilliseconds} ms");
      return results;
    }

    // ---- Server uses ----
    final serverKeys = (await _serverConstructsBox.getAllKeys())
        .where((key) => _isLanguageKey(key, language))
        // Filter out malformed or legacy keys that don't have a timestamp
        .where((key) {
          final parts = key.split('|');
          return parts.length >= 3 && int.tryParse(parts[2]) != null;
        })
        .sorted((a, b) {
          final aTimestamp = int.parse(a.split('|')[2]);
          final bTimestamp = int.parse(b.split('|')[2]);
          return bTimestamp.compareTo(aTimestamp);
        });

    for (final key in serverKeys) {
      final serverUses = await getServerUses(key)
        ..sort((a, b) => b.timeStamp.compareTo(a.timeStamp));

      for (final use in serverUses) {
        if (!addUseIfValid(use)) break;
      }

      if (count != null && results.length >= count) break;
    }

    stopwatch.stop();
    Logs().i("Get uses took ${stopwatch.elapsedMilliseconds} ms");
    return results;
  }

  Future<List<OneConstructUse>> getLocalUses(String language) async {
    final List<OneConstructUse> uses = [];
    final localKeys = (await _localConstructsBox.getAllKeys())
        .where((key) => _isLanguageKey(key, language))
        .toList();

    final localValues = await _localConstructsBox.getAll(localKeys);
    for (final rawList in localValues) {
      if (rawList == null) continue;
      for (final raw in rawList) {
        final use = OneConstructUse.fromJson(Map<String, dynamic>.from(raw));
        uses.add(use);
      }
    }
    return uses;
  }

  Future<List<OneConstructUse>> getServerUses(String key) async {
    final List<OneConstructUse> uses = [];
    final serverValues = await _serverConstructsBox.get(key);
    if (serverValues == null) return [];

    for (final entry in serverValues) {
      uses.add(OneConstructUse.fromJson(Map<String, dynamic>.from(entry)));
    }
    return uses;
  }

  Future<int> getLocalConstructCount(String language) async {
    final keys = (await _localConstructsBox.getAllKeys()).where(
      (key) => _isLanguageKey(key, language),
    );
    return keys.length;
  }

  Future<ConstructUses> getConstructUse(
    List<ConstructIdentifier> ids,
    String language,
  ) async {
    assert(ids.isNotEmpty);

    final ConstructUses construct = ConstructUses(
      uses: [],
      constructType: ids.first.type,
      lemma: ids.first.lemma,
      category: ids.first.category,
    );

    for (final id in ids) {
      final key = id.storageKey;

      ConstructUses? server;
      ConstructUses? local;

      final serverBox = _aggBox(id.type, false);
      final localBox = _aggBox(id.type, true);

      final serverRaw = await serverBox.get(_langKey(key, language));
      if (serverRaw != null) {
        server = ConstructUses.fromJson(Map<String, dynamic>.from(serverRaw));
      }

      final localRaw = await localBox.get(_langKey(key, language));
      if (localRaw != null) {
        local = ConstructUses.fromJson(Map<String, dynamic>.from(localRaw));
      }

      if (server != null) construct.merge(server);
      if (local != null) construct.merge(local);
    }
    return construct;
  }

  Future<Map<ConstructIdentifier, ConstructUses>> getConstructUses(
    Map<ConstructIdentifier, List<ConstructIdentifier>> ids,
    String language,
  ) async {
    final Map<ConstructIdentifier, ConstructUses> results = {};
    for (final entry in ids.entries) {
      final construct = await getConstructUse(entry.value, language);
      results[entry.key] = construct;
    }
    return results;
  }

  Future<void> clearLocalConstructData(String language) async {
    await _transaction(() async {
      final localKeys = (await _localConstructsBox.getAllKeys())
          .where((key) => _isLanguageKey(key, language))
          .toList();

      final localVocabAggKeys =
          (await _aggregatedLocalVocabConstructsBox.getAllKeys())
              .where((key) => _isLanguageKey(key, language))
              .toList();

      final localMorphAggKeys =
          (await _aggregatedLocalMorphConstructsBox.getAllKeys())
              .where((key) => _isLanguageKey(key, language))
              .toList();

      await _localConstructsBox.deleteAll(localKeys);
      await _aggregatedLocalVocabConstructsBox.deleteAll(localVocabAggKeys);
      await _aggregatedLocalMorphConstructsBox.deleteAll(localMorphAggKeys);
    });
  }

  /// Group uses by aggregate key
  Map<String, List<OneConstructUse>> _groupUses(
    List<OneConstructUse> uses,
    String language,
  ) {
    final Map<String, List<OneConstructUse>> grouped = {};
    for (final u in uses) {
      final key = _langKey(u.identifier.storageKey, language);
      (grouped[key] ??= []).add(u);
    }
    return grouped;
  }

  Map<String, ConstructUses> _aggregateConstructs(
    Map<String, List<OneConstructUse>> groups,
    Map<String, Map<dynamic, dynamic>?> existingRaw,
  ) {
    final Map<String, ConstructUses> updates = {};

    for (final entry in groups.entries) {
      final key = entry.key;
      final usesForKey = entry.value;
      final raw = existingRaw[key];

      ConstructUses model;

      if (raw != null) {
        model = ConstructUses.fromJson(Map<String, dynamic>.from(raw));
      } else {
        final u = usesForKey.first;
        model = ConstructUses(
          uses: [],
          constructType: u.constructType,
          lemma: u.lemma,
          category: u.category,
        );
      }

      model.addUses(usesForKey);
      updates[key] = model;
    }

    return updates;
  }

  Future<Map<String, ConstructUses>> _aggregateFromBox(
    Box<Map> box,
    Map<String, List<OneConstructUse>> grouped,
  ) async {
    final keys = grouped.keys.toList();
    final existing = await box.getAll(keys);

    final existingMap = Map.fromIterables(keys, existing);
    return _aggregateConstructs(grouped, existingMap);
  }

  Future<List<ConstructUses>> getAggregatedConstructs(
    ConstructTypeEnum type,
    String language,
  ) async {
    Map<String, ConstructUses> combined = {};
    final stopwatch = Stopwatch()..start();

    final localKeys = (await _aggBox(
      type,
      true,
    ).getAllKeys()).where((key) => _isLanguageKey(key, language)).toList();
    final serverKeys = (await _aggBox(
      type,
      false,
    ).getAllKeys()).where((key) => _isLanguageKey(key, language)).toList();

    final serverValues = await _aggBox(type, false).getAll(serverKeys);
    final serverConstructs = serverValues
        .map((e) => ConstructUses.fromJson(Map<String, dynamic>.from(e!)))
        .toList();

    final serverAgg = Map.fromIterables(serverKeys, serverConstructs);

    if (localKeys.isEmpty) {
      combined = serverAgg;
    } else {
      final localValues = await _aggBox(type, true).getAll(localKeys);
      final localConstructs = localValues
          .map((e) => ConstructUses.fromJson(Map<String, dynamic>.from(e!)))
          .toList();

      final localAgg = Map.fromIterables(localKeys, localConstructs);

      combined = Map<String, ConstructUses>.from(serverAgg);
      for (final entry in localAgg.entries) {
        final key = entry.key;
        final localModel = entry.value;

        if (combined.containsKey(key)) {
          final serverModel = combined[key]!;
          serverModel.merge(localModel);
          combined[key] = serverModel;
        } else {
          combined[key] = localModel;
        }
      }
    }

    stopwatch.stop();
    Logs().i("Combining aggregates took ${stopwatch.elapsedMilliseconds} ms");

    return combined.values.toList();
  }

  Future<void> updateUserID(String userID) {
    return _transaction(() async {
      await _lastEventTimestampBox.put('user_id', userID);
    });
  }

  Future<void> updateCurrentLanguage(String language) {
    return _transaction(() async {
      await _lastEventTimestampBox.put('current_language', language);
    });
  }

  Future<void> _updateLastUpdated(DateTime timestamp, String language) async {
    return _transaction(() async {
      await _lastEventTimestampBox.put(
        _langKey('last_updated', language),
        timestamp.toIso8601String(),
      );
    });
  }

  Future<void> updateXPOffset(int offset, String language) async {
    return _transaction(() async {
      final stats = await getDerivedStats(language);
      final updatedStats = stats.copyWithOffset(offset);
      await _derivedStatsBox.put(
        _langKey('derived_stats', language),
        updatedStats.toJson(),
      );
    });
  }

  Future<void> updateTotalXP(int totalXP, String language) {
    return _transaction(() async {
      final stats = await getDerivedStats(language);
      final updatedStats = stats.copyWithTotalXP(totalXP);
      await _derivedStatsBox.put(
        _langKey('derived_stats', language),
        updatedStats.toJson(),
      );
    });
  }

  Future<void> updateDerivedStats(
    DerivedAnalyticsDataModel newStats,
    String language,
  ) => _derivedStatsBox.put(
    _langKey('derived_stats', language),
    newStats.toJson(),
  );

  Future<void> updateServerAnalytics(
    List<ConstructAnalyticsEvent> events,
    String language,
  ) async {
    if (events.isEmpty) return;

    final stopwatch = Stopwatch()..start();
    await _transaction(() async {
      final lastUpdated = await getLastEventTimestamp(language);

      DateTime mostRecent = lastUpdated ?? events.first.event.originServerTs;
      final existingKeys = (await _serverConstructsBox.getAllKeys())
          .where((key) => _isLanguageKey(key, language))
          .toSet();

      final List<OneConstructUse> aggregatedVocabUses = [];
      final List<OneConstructUse> aggregatedMorphUses = [];
      final Map<String, List<OneConstructUse>> pendingWrites = {};

      for (final event in events) {
        final ts = event.event.originServerTs;
        final key = TupleKey(
          event.event.eventId,
          ts.millisecondsSinceEpoch.toString(),
        ).toString();

        if (lastUpdated != null && ts.isBefore(lastUpdated)) continue;
        if (existingKeys.contains(_langKey(key, language))) continue;

        if (ts.isAfter(mostRecent)) mostRecent = ts;

        pendingWrites[key] = event.content.uses;
        for (final u in event.content.uses) {
          u.constructType == ConstructTypeEnum.vocab
              ? aggregatedVocabUses.add(u)
              : aggregatedMorphUses.add(u);
        }
      }

      if (pendingWrites.isEmpty) return;

      // Write events sequentially
      for (final e in pendingWrites.entries) {
        _serverConstructsBox.put(
          _langKey(e.key, language),
          e.value.map((u) => u.toJson()).toList(),
        );
      }

      // Update aggregates
      final aggVocabUpdates = await _aggregateFromBox(
        _aggregatedServerVocabConstructsBox,
        _groupUses(aggregatedVocabUses, language),
      );

      for (final entry in aggVocabUpdates.entries) {
        await _aggregatedServerVocabConstructsBox.put(
          entry.key,
          entry.value.toJson(),
        );
      }

      final aggMorphUpdates = await _aggregateFromBox(
        _aggregatedServerMorphConstructsBox,
        _groupUses(aggregatedMorphUses, language),
      );

      for (final entry in aggMorphUpdates.entries) {
        await _aggregatedServerMorphConstructsBox.put(
          entry.key,
          entry.value.toJson(),
        );
      }

      // Update timestamp
      await _lastEventTimestampBox.put(
        _langKey('last_event_timestamp', language),
        mostRecent.toIso8601String(),
      );
    });

    await _updateLastUpdated(DateTime.now(), language);

    stopwatch.stop();
    Logs().i(
      "Server analytics update took ${stopwatch.elapsedMilliseconds} ms",
    );
  }

  Future<void> updateLocalAnalytics(
    List<OneConstructUse> uses,
    String language,
  ) async {
    if (uses.isEmpty) return;

    final stopwatch = Stopwatch()..start();
    await _transaction(() async {
      // Store local constructs
      final key = DateTime.now().millisecondsSinceEpoch;
      _localConstructsBox.put(
        _langKey(key.toString(), language),
        uses.map((u) => u.toJson()).toList(),
      );

      final List<OneConstructUse> vocabUses = [];
      final List<OneConstructUse> morphUses = [];
      for (final u in uses) {
        u.constructType == ConstructTypeEnum.vocab
            ? vocabUses.add(u)
            : morphUses.add(u);
      }

      // Update aggregates
      final aggVocabUpdates = await _aggregateFromBox(
        _aggregatedLocalVocabConstructsBox,
        _groupUses(vocabUses, language),
      );

      for (final entry in aggVocabUpdates.entries) {
        await _aggregatedLocalVocabConstructsBox.put(
          entry.key,
          entry.value.toJson(),
        );
      }

      final aggMorphUpdates = await _aggregateFromBox(
        _aggregatedLocalMorphConstructsBox,
        _groupUses(morphUses, language),
      );

      for (final entry in aggMorphUpdates.entries) {
        await _aggregatedLocalMorphConstructsBox.put(
          entry.key,
          entry.value.toJson(),
        );
      }
    });

    await _updateLastUpdated(DateTime.now(), language);

    stopwatch.stop();
    Logs().i("Local analytics update took ${stopwatch.elapsedMilliseconds} ms");
  }
}