import 'dart:convert';
import 'dart:typed_data';

import 'package:dart_mq/dart_mq.dart';
import 'package:flat_buffers/flat_buffers.dart' as fb;
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:objectbox/internal.dart' show EntityDefinition;
import 'package:stadtbote/content_views/messages_page.dart';
import 'package:stadtbote/main.dart';
import 'package:stadtbote/model/chat_message.dart';
import 'package:stadtbote/model/session_status.dart';
import 'package:stadtbote/objectbox.g.dart';
import 'package:stadtbote/tools/constants.dart';
import 'package:stadtbote/tools/messages/publish_payload_message.dart';

void main() {
  setUp(() {
    MQClient.initialize();
    MQClient.instance.declareQueue(Constants.messageTopicPublishPayload);
  });

  tearDown(() {
    MQClient.instance.close();
  });

  testWidgets('bestätigt die Server-ID auch nach der lokalen ID-Vergabe', (
    tester,
  ) async {
    final message = ChatMessage.fromJson({
      'id': 6094830,
      'time': 1791536566,
      'from': 'NL',
      'subj': 'Test1',
      'text': 'Test2',
    });
    final store = _MessageStore();
    final definition =
        getObjectBoxModel().bindings[ChatMessage]!
            as EntityDefinition<ChatMessage>;

    // Die nativen Datenbankzugriffe werden ersetzt; die generierte
    // ObjectBox-Serialisierung und der Nachrichtenversand laufen unverändert.
    definition.setId(message, 2);
    final builder = fb.Builder();
    definition.objectToFB(message, builder);
    final restored = definition.objectFromFB(
      store,
      ByteData.sublistView(builder.buffer),
    );
    expect(restored.id, 2);
    expect(restored.externalId, 6094830);
    expect(restored.read, isFalse);

    store.messages = _MessageBox(restored);
    MyApp.objectBoxStore = store;

    await tester.pumpWidget(
      const MaterialApp(home: Scaffold(body: MessagesPage())),
    );
    await tester.pumpAndSettle();

    final published =
        MQClient.instance
                .getLatestMessage(Constants.messageTopicPublishPayload)!
                .payload
            as PublishPayloadMessage;
    expect(published.topic, 'mssg_received');
    expect(published.acknowledgeRequired, isFalse);
    expect(jsonDecode(jsonEncode(published.message)), {
      'ids': ['6094830'],
      'time': isA<int>(),
    });
    expect(restored.read, isTrue);
    expect(find.text('Test1\nTest2', findRichText: true), findsOneWidget);
  });
}

class _MessageStore extends Fake implements Store {
  late final _MessageBox messages;

  @override
  Box<T> box<T>() {
    if (T == ChatMessage) return messages as Box<T>;
    if (T == SessionStatus) return _SessionBox() as Box<T>;
    throw StateError('Unerwarteter Entity-Typ: $T');
  }
}

class _SessionBox extends Fake implements Box<SessionStatus> {
  @override
  List<SessionStatus> getAll() => [];
}

class _MessageBox extends Fake implements Box<ChatMessage> {
  final ChatMessage message;

  _MessageBox(this.message);

  @override
  List<ChatMessage> getAll() => [message];

  @override
  QueryBuilder<ChatMessage> query([Condition<ChatMessage>? qc]) =>
      _UnreadQueryBuilder(message);

  @override
  int put(ChatMessage object, {PutMode mode = PutMode.put}) => object.id;
}

class _UnreadQueryBuilder extends Fake implements QueryBuilder<ChatMessage> {
  final ChatMessage message;

  _UnreadQueryBuilder(this.message);

  @override
  Query<ChatMessage> build() => _UnreadQuery(message);
}

class _UnreadQuery extends Fake implements Query<ChatMessage> {
  final ChatMessage message;

  _UnreadQuery(this.message);

  @override
  List<ChatMessage> find() => [if (!message.read) message];

  @override
  void close() {}
}