import 'dart:async';
import 'dart:typed_data';

import 'package:flutter/material.dart';

import 'package:flutter_test/flutter_test.dart';

import 'package:image/image.dart' as images;

import 'package:sxchnge_kyc/sxchnge_kyc.dart';

import 'package:sxchnge_app/kyc/photo.dart';
import 'package:sxchnge_app/kyc/preview.dart';

import 'package:sxchnge_app/generated/i18n/app_localizations.dart';

Widget host(Widget child, {Locale locale = const Locale('en')}) => MaterialApp(
  locale: locale,
  localizationsDelegates: AppLocalizations.localizationsDelegates,
  supportedLocales: AppLocalizations.supportedLocales,
  home: Scaffold(body: SingleChildScrollView(child: child)),
);

// Start decoding outside FakeAsync as well as waiting outside it, including
// browser codec callbacks that otherwise remain pending in the test zone.
Future<void> show(WidgetTester tester, Widget widget) async {
  await tester.runAsync(() => tester.pumpWidget(widget));
}

// pumpAndSettle alone does not wait for image codecs. Listen to the actual
// preview streams so a hidden errorBuilder cannot make this regression pass.
Future<void> decoded(WidgetTester tester, {bool succeeds = true}) async {
  final providers = tester
      .widgetList<Image>(find.byType(Image))
      .map((image) => image.image)
      .toList();
  expect(providers, isNotEmpty);
  for (final provider in providers) {
    Object? renderError;
    StackTrace? renderStack;
    await tester.runAsync(() async {
      final stream = provider.resolve(ImageConfiguration.empty);
      final ready = Completer<void>();
      final listener = ImageStreamListener(
        (info, _) {
          info.dispose();
          if (!ready.isCompleted) ready.complete();
        },
        onError: (Object error, StackTrace? stack) {
          renderError = error;
          renderStack = stack;
          if (!ready.isCompleted) ready.complete();
        },
      );
      stream.addListener(listener);
      try {
        await ready.future.timeout(const Duration(seconds: 15));
      } finally {
        stream.removeListener(listener);
      }
    });
    expect(
      renderError,
      succeeds ? isNull : isNotNull,
      reason: succeeds ? '$renderError\n$renderStack' : null,
    );
  }
  await tester.pumpAndSettle();
  expect(tester.takeException(), isNull);
}

void main() {
  late Uint8List png;
  late Uint8List jpeg;
  setUpAll(() {
    // Synthetic, non-sensitive portrait and landscape photos in both formats.
    png = images.encodePng(images.Image(width: 1200, height: 1600));
    jpeg = images.encodeJpg(images.Image(width: 1600, height: 1200));
  });

  for (final format in ['PNG', 'JPEG']) {
    testWidgets('accepted $format renders from an immutable photo model', (
      tester,
    ) async {
      final source = Uint8List.fromList(format == 'PNG' ? png : jpeg);
      final photo = (await tester.runAsync(
        () => FilePhotoService.validate(source),
      ))!;
      final originalFirstByte = photo.bytes.first;
      source[0] = 0;
      expect(photo.bytes.first, originalFirstByte);
      expect(() => photo.bytes[0] = 0, throwsUnsupportedError);
      await show(
        tester,
        host(PhotoPreview(photo: photo, label: 'ID document photo')),
      );
      await decoded(tester);
      final raw = tester.widget<RawImage>(find.byType(RawImage));
      expect(raw.image, isNotNull);
      expect(raw.image!.width, lessThanOrEqualTo(1000));
      expect(
        tester.widget<Image>(find.byType(Image)).semanticLabel,
        'ID document photo',
      );
      expect(find.textContaining('damaged'), findsNothing);
      expect(find.textContaining('could not be displayed'), findsNothing);
    });
  }

  testWidgets('replacement and removal evict sensitive preview cache entries', (
    tester,
  ) async {
    final first = Photo(png);
    await show(tester, host(PhotoPreview(photo: first, label: 'ID')));
    await decoded(tester);
    final initialProvider = tester.widget<Image>(find.byType(Image)).image;
    final initialKey = await initialProvider.obtainKey(
      ImageConfiguration.empty,
    );
    final cache = PaintingBinding.instance.imageCache;
    expect(cache.statusForKey(initialKey).keepAlive, isTrue);
    await show(tester, host(PhotoPreview(photo: first, label: 'Document')));
    await decoded(tester);
    expect(
      identical(
        tester.widget<Image>(find.byType(Image)).image,
        initialProvider,
      ),
      isTrue,
    );
    await show(tester, host(PhotoPreview(photo: Photo(jpeg), label: 'ID')));
    await decoded(tester);
    expect(cache.statusForKey(initialKey).untracked, isTrue);
    final replacement = tester.widget<Image>(find.byType(Image)).image;
    final replacementKey = await replacement.obtainKey(
      ImageConfiguration.empty,
    );
    expect(cache.statusForKey(replacementKey).keepAlive, isTrue);
    expect(tester.widget<RawImage>(find.byType(RawImage)).image!.width, 1000);
    await show(tester, host(const SizedBox()));
    await tester.pumpAndSettle();
    expect(cache.statusForKey(replacementKey).untracked, isTrue);
  });

  testWidgets('ID and selfie both render on review and after returning', (
    tester,
  ) async {
    final passport = Photo(png);
    final selfie = Photo(jpeg);
    for (var visit = 0; visit < 2; visit++) {
      await show(
        tester,
        host(
          Column(
            children: [
              PhotoPanel(
                kind: PhotoKind.passport,
                photo: passport,
                review: true,
              ),
              PhotoPanel(kind: PhotoKind.selfie, photo: selfie, review: true),
            ],
          ),
        ),
      );
      await decoded(tester);
      final previews = tester.widgetList<RawImage>(find.byType(RawImage));
      expect(previews.length, 2);
      expect(previews.every((image) => image.image != null), isTrue);
      expect(find.text('Choose a different photo'), findsNothing);
      await show(tester, host(const SizedBox()));
      await tester.pumpAndSettle();
    }
  });

  for (final locale in ['en', 'ru']) {
    testWidgets(
      '$locale preview failure explains recovery and can be replaced',
      (tester) async {
        tester.view.physicalSize = const Size(320, 900);
        tester.view.devicePixelRatio = 1;
        tester.platformDispatcher.textScaleFactorTestValue = 1.6;
        addTearDown(tester.view.resetPhysicalSize);
        addTearDown(tester.view.resetDevicePixelRatio);
        addTearDown(tester.platformDispatcher.clearTextScaleFactorTestValue);
        var replacements = 0;
        var removals = 0;
        await show(
          tester,
          host(
            PhotoPanel(
              kind: PhotoKind.passport,
              photo: Photo(Uint8List.fromList([1, 2, 3])),
              onPick: () => replacements++,
              onRemove: () => removals++,
            ),
            locale: Locale(locale),
          ),
        );
        await decoded(tester, succeeds: false);
        final l = AppLocalizations.of(tester.element(find.byType(PhotoPanel)))!;
        expect(find.text(l.kycErrorPreview), findsOneWidget);
        expect(find.text(l.kycErrorUnreadable), findsNothing);
        expect(
          tester.getSemantics(find.text(l.kycErrorPreview)),
          matchesSemantics(isLiveRegion: true, label: l.kycErrorPreview),
        );
        final replace = find.byKey(const ValueKey('pick-passport'));
        await tester.ensureVisible(replace);
        await tester.tap(replace);
        final remove = find.text(l.kycRemove);
        await tester.ensureVisible(remove);
        await tester.tap(remove);
        expect(replacements, 1);
        expect(removals, 1);
        await show(
          tester,
          host(
            PhotoPanel(kind: PhotoKind.passport, photo: Photo(jpeg)),
            locale: Locale(locale),
          ),
        );
        await decoded(tester);
        expect(find.text(l.kycErrorPreview), findsNothing);
        expect(tester.widget<RawImage>(find.byType(RawImage)).image, isNotNull);
      },
    );
  }
}