initial

lib/features/logs/notifier/logs_notifier.dart

@@ -0,0 +1,81 @@
+import 'dart:async';
+
+import 'package:dartx/dartx.dart';
+import 'package:hiddify/data/data_providers.dart';
+import 'package:hiddify/domain/clash/clash.dart';
+import 'package:hiddify/features/logs/notifier/logs_state.dart';
+import 'package:hiddify/utils/utils.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'logs_notifier.g.dart';
+
+// TODO: rewrite
+@riverpod
+class LogsNotifier extends _$LogsNotifier with AppLogger {
+  static const maxLength = 1000;
+
+  @override
+  Stream<LogsState> build() {
+    state = const AsyncData(LogsState());
+    return ref.read(clashFacadeProvider).watchLogs().asyncMap(
+      (event) async {
+        _logs = [
+          event.getOrElse((l) => throw l),
+          ..._logs.takeFirst(maxLength - 1),
+        ];
+        return switch (state) {
+          // ignore: unused_result
+          AsyncData(:final value) => value.copyWith(logs: await _computeLogs()),
+          _ => LogsState(logs: await _computeLogs()),
+        };
+      },
+    );
+  }
+
+  var _logs = <ClashLog>[];
+  final _debouncer = CallbackDebouncer(const Duration(milliseconds: 200));
+  LogLevel? _levelFilter;
+  String _filter = "";
+
+  Future<List<ClashLog>> _computeLogs() async {
+    if (_levelFilter == null && _filter.isEmpty) return _logs;
+    return _logs.where((e) {
+      return (_filter.isEmpty || e.message.contains(_filter)) &&
+          (_levelFilter == null || e.level == _levelFilter);
+    }).toList();
+  }
+
+  void clear() {
+    if (state case AsyncData(:final value)) {
+      state = AsyncData(value.copyWith(logs: [])).copyWithPrevious(state);
+    }
+  }
+
+  void filterMessage(String? filter) {
+    _filter = filter ?? '';
+    _debouncer(
+      () async {
+        if (state case AsyncData(:final value)) {
+          state = AsyncData(
+            value.copyWith(
+              filter: _filter,
+              logs: await _computeLogs(),
+            ),
+          ).copyWithPrevious(state);
+        }
+      },
+    );
+  }
+
+  Future<void> filterLevel(LogLevel? level) async {
+    _levelFilter = level;
+    if (state case AsyncData(:final value)) {
+      state = AsyncData(
+        value.copyWith(
+          levelFilter: _levelFilter,
+          logs: await _computeLogs(),
+        ),
+      ).copyWithPrevious(state);
+    }
+  }
+}