import 'dart:async';
import 'dart:convert';

import 'package:hepan_everyday/services/diagnostic_log.dart';
import 'package:hepan_everyday/services/school_page_diagnostic.dart';
import 'package:hepan_everyday/features/school/school_page_adapter.dart';

import 'package:flutter_test/flutter_test.dart';
import 'package:webview_flutter_platform_interface/webview_flutter_platform_interface.dart';
import 'package:hepan_everyday/features/school/school_session.dart';
import 'package:hepan_everyday/domain/school_term.dart';
import 'package:hepan_everyday/features/school/school_exam_adapter.dart';

import '../support/fake_school_web.dart';
import 'exam_adapter_test.dart' show examHtml;
import 'recognized_timetable_test.dart' show fixture;

void main() {
  TestWidgetsFlutterBinding.ensureInitialized();
  late FakeSchoolPlatform platform;
  late SchoolSession session;
  setUp(() {
    platform = FakeSchoolPlatform();
    WebViewPlatform.instance = platform;
    session = SchoolSession();
  });
  tearDown(() => session.dispose());
  void navigate(String url) {
    platform.web.url = url;
    platform.delegate.started(url);
    platform.delegate.finished(url);
  }

  testWidgets(
    'graduate parser rejection keeps its reason instead of becoming a network timeout',
    (tester) async {
      addTearDown(SchoolPageDiagnostic.instance.clear);
      session.connectionState = SchoolConnectionState.connected;
      await session.openTimetable(term: SchoolTerm(73));
      platform.web.javascript = (_) async => schoolPageEvidence(
        topUrl: platform.web.url!,
        html: fixture().replaceFirst('1-3周', '未知周'),
      );
      await tester.runAsync(() async {
        navigate(SchoolTerm(73).timetableUri.toString());
        await flushSchoolEvents();
      });
      expect(session.message, contains('上课周次'));
      await tester.pump(const Duration(seconds: 46));
      expect(session.message, contains('上课周次'));
      expect(session.message, isNot(contains('查找超时')));
      expect(session.pendingDraft, isNull);
      final log = utf8.decode(await DiagnosticLog.instance.export());
      expect(log, contains('"code":"weeks_invalid"'));
      expect(log, contains('"column":5'));
      expect(log, isNot(contains('示例集成电路')));
      SchoolPageDiagnostic.instance.clear();
    },
  );
  testWidgets('a new graduate page never inherits an old parsing reason', (
    tester,
  ) async {
    addTearDown(SchoolPageDiagnostic.instance.clear);
    session.connectionState = SchoolConnectionState.connected;
    await session.openTimetable(term: SchoolTerm(73));
    platform.web.javascript = (_) async => schoolPageEvidence(
      topUrl: platform.web.url!,
      html: fixture().replaceFirst('1-3周', '未知周'),
    );
    await tester.runAsync(() async {
      navigate(SchoolTerm(73).timetableUri.toString());
      await flushSchoolEvents();
    });
    expect(session.message, contains('上课周次'));
    platform.web.javascript = (_) async =>
        schoolPageEvidence(topUrl: platform.web.url!);
    await tester.runAsync(() async {
      navigate(SchoolTerm(72).timetableUri.toString());
      await flushSchoolEvents();
    });
    await tester.pump(const Duration(seconds: 46));
    expect(session.message, contains('查找超时'));
    expect(session.message, isNot(contains('上课周次')));
    SchoolPageDiagnostic.instance.clear();
  });

  test(
    'graduate auto read retains HTML after leaving and clears on next query',
    () async {
      final cache = SchoolPageDiagnostic.instance;
      addTearDown(cache.clear);
      await session.openTimetable(term: SchoolTerm(73));
      platform.web.javascript = (_) async =>
          schoolPageEvidence(topUrl: platform.web.url!, html: fixture());
      navigate(SchoolSession.timetableUrl.toString());
      await flushSchoolEvents();
      expect(session.pendingDraft, isNotNull);
      expect(cache.export(), isNotNull);
      session.setReadingActive(false);
      expect(cache.export(), isNotNull);
      await session.openExams(term: SchoolTerm(73));
      expect(cache.export(), isNull);
    },
  );

  test(
    'failed graduate manual parse retains HTML and logout clears it',
    () async {
      final cache = SchoolPageDiagnostic.instance;
      addTearDown(cache.clear);
      await session.openTimetable(term: SchoolTerm(73));
      platform.web.url = SchoolSession.timetableUrl.toString();
      platform.web.javascript = (_) async => schoolPageEvidence(
        topUrl: platform.web.url!,
        html: fixture().replaceFirst('1-3周', '未知周'),
      );
      await expectLater(
        session.readTimetable(),
        throwsA(isA<UnsupportedSchoolLayout>()),
      );
      expect(cache.export(), isNotNull);
      expect(utf8.decode(cache.export()!), contains('未知周'));
      session.invalidateAuthentication();
      expect(cache.export(), isNull);
    },
  );

  test('graduate exam read retains the recognized exam fragment', () async {
    final cache = SchoolPageDiagnostic.instance;
    addTearDown(cache.clear);
    await session.openExams(term: SchoolTerm(73));
    platform.web.javascript = (_) async => schoolPageEvidence(
      topUrl: platform.web.url!,
      html: examHtml(),
      kind: 'exams',
    );
    navigate(SchoolSession.examUrl.toString());
    await flushSchoolEvents();
    expect(session.pendingExams, isNotNull);
    expect(cache.export(), isNotNull);
    expect(
      SchoolExamAdapter.extract(utf8.decode(cache.export()!))
          .records
          .single
          .name,
      '矩阵理论',
    );
    await session.logout();
    expect(cache.export(), isNull);
  });

  test(
    'stale graduate probe cannot replace the current diagnostic attachment',
    () async {
      final cache = SchoolPageDiagnostic.instance;
      addTearDown(cache.clear);
      await session.openTimetable(term: SchoolTerm(73));
      final old = Completer<Object>();
      platform.web.javascript = (_) => old.future;
      const home = 'https://yjsjy.uestc.edu.cn/pyxx/home/index';
      navigate(home);
      await flushSchoolEvents();
      platform.web.javascript = (_) async => schoolPageEvidence(
        topUrl: platform.web.url!,
        html: fixture().replaceAll('示例楼B212', '当前教室A101'),
      );
      navigate(SchoolSession.timetableUrl.toString());
      await flushSchoolEvents();
      final current = cache.export();
      expect(current, isNotNull);
      old.complete(schoolPageEvidence(topUrl: home, html: fixture()));
      await flushSchoolEvents();
      expect(cache.export(), current);
      expect(utf8.decode(cache.export()!), contains('当前教室A101'));
    },
  );

  for (final manual in [false, true]) {
    test(
      'logout during final URL check rejects stale ${manual ? 'manual' : 'automatic'} HTML',
      () async {
        final cache = SchoolPageDiagnostic.instance;
        addTearDown(cache.clear);
        await session.openTimetable(term: SchoolTerm(73));
        final url = SchoolSession.timetableUrl.toString();
        platform.web.url = url;
        platform.web.javascript = (_) async =>
            schoolPageEvidence(topUrl: url, html: fixture());
        final waitingUrl = Completer<String?>();
        var reads = 0;
        platform.web.readCurrentUrl = () async {
          reads++;
          if (reads == (manual ? 2 : 3)) return waitingUrl.future;
          return platform.web.url;
        };
        final operation = manual
            ? expectLater(
                session.readTimetable(),
                throwsA(isA<UnsupportedSchoolLayout>()),
              )
            : session.readCurrentPage();
        await flushSchoolEvents();
        expect(reads, manual ? 2 : 3);
        session.invalidateAuthentication();
        waitingUrl.complete(url);
        await operation;
        expect(cache.export(), isNull);
        expect(session.pendingDraft, isNull);
      },
    );
  }

  test('login diagnostic breadcrumbs distinguish probe and network failures without raw details', () async {
    await session.openTimetable(term: SchoolTerm(73));
    session.setReadingActive(true);
    platform.web.javascript = (_) async => throw StateError('PRIVATE_TICKET');
    navigate('https://yjsjy.uestc.edu.cn/pyxx/home/index');
    await flushSchoolEvents();
    var log = utf8.decode(await DiagnosticLog.instance.export());
    expect(log, contains('school_probe_failed'));
    expect(log, isNot(contains('PRIVATE_TICKET')));
    platform.delegate.resourceError(
      WebResourceError(
        errorCode: -2,
        description: 'PRIVATE_NETWORK_DETAIL',
        isForMainFrame: true,
        url: platform.web.url,
      ),
    );
    await flushSchoolEvents();
    log = utf8.decode(await DiagnosticLog.instance.export());
    expect(log, contains('web_resource_error'));
    expect(log, contains('"status":-2'));
    expect(log, isNot(contains('PRIVATE_NETWORK_DETAIL')));
  });

  test('graduate logout function automatically opens timetable without an exit anchor', () async {
    await session.openTimetable(term: SchoolTerm(73));
    platform.web.javascript = (script) async =>
        script.contains("typeof window.logout")
        ? schoolPageEvidence(topUrl: platform.web.url!, authenticated: true)
        : false;
    navigate('http://yjsjy.uestc.edu.cn/pyxx/home/index');
    await flushSchoolEvents();
    expect(platform.web.loads.last, SchoolSession.timetableUrl.toString());
  });

  test('manual graduate page reads recognized embedded timetable instead of restarting login', () async {
    await session.openTimetable(term: SchoolTerm(73));
    const home = 'https://yjsjy.uestc.edu.cn/pyxx/home/index';
    platform.web.url = home;
    platform.web.javascript = (_) async => schoolPageEvidence(
      topUrl: home,
      html: fixture(),
      documentUrl: SchoolSession.timetableUrl.toString(),
    );
    final draft = await session.readTimetable();
    expect(draft.courses.length, 4);
    expect(platform.web.loads.length, 1);
  });

  test(
    'closed authentication screen ignores later page-finished callbacks',
    () async {
      await session.openTimetable(term: SchoolTerm(73));
      session.setReadingActive(true);
      session.setReadingActive(false);
      platform.web.javascript = (_) async =>
          schoolPageEvidence(topUrl: platform.web.url!, html: fixture());
      navigate(SchoolSession.timetableUrl.toString());
      await flushSchoolEvents();
      expect(session.pendingDraft, isNull);
      expect(session.finding, isFalse);
    },
  );

  test(
    'asynchronous timetable DOM is imported without another navigation',
    () async {
      await session.openTimetable(term: SchoolTerm(73));
      session.setReadingActive(true);
      var ready = false;
      platform.web.javascript = (_) async => schoolPageEvidence(
        topUrl: platform.web.url!,
        html: ready ? fixture() : null,
      );
      navigate(SchoolSession.timetableUrl.toString());
      await flushSchoolEvents();
      expect(session.pendingDraft, isNull);
      expect(session.finding, isTrue);
      ready = true;
      await Future<void>.delayed(const Duration(milliseconds: 850));
      await flushSchoolEvents();
      expect(session.pendingDraft!.courses.length, 4);
      expect(platform.web.loads.length, 1);
    },
  );

  test('stale script response cannot cancel polling on a newer page', () async {
    await session.openTimetable(term: SchoolTerm(73));
    session.setReadingActive(true);
    final old = Completer<Object>();
    platform.web.javascript = (_) => old.future;
    navigate('https://yjsjy.uestc.edu.cn/pyxx/home/index');
    await flushSchoolEvents();
    var ready = false;
    platform.web.javascript = (_) async => schoolPageEvidence(
      topUrl: platform.web.url!,
      html: ready ? fixture() : null,
    );
    navigate(SchoolSession.timetableUrl.toString());
    await flushSchoolEvents();
    old.complete(
      schoolPageEvidence(
        topUrl: 'https://yjsjy.uestc.edu.cn/pyxx/home/index',
        authenticated: true,
        html: fixture(),
      ),
    );
    await flushSchoolEvents();
    ready = true;
    await Future<void>.delayed(const Duration(milliseconds: 850));
    await flushSchoolEvents();
    expect(session.pendingDraft?.courses.length, 4);
  });

  test('external document evidence cannot become a school import', () async {
    await session.openTimetable(term: SchoolTerm(73));
    platform.web.url = SchoolSession.timetableUrl.toString();
    for (final url in [
      'https://evil.test/pyxx/pygl/xskbcx/index/1',
      'https://yjsjy.uestc.edu.cn:444/pyxx/pygl/xskbcx/index/1',
      'http://yjsjy.uestc.edu.cn/pyxx/pygl/xskbcx/index/1',
      'https://user@yjsjy.uestc.edu.cn/pyxx/pygl/xskbcx/index/1',
    ]) {
      platform.web.javascript = (_) async => schoolPageEvidence(
        topUrl: platform.web.url!,
        documentUrl: url,
        html: fixture(),
      );
      await expectLater(session.readTimetable(), throwsA(isA<Exception>()));
    }
    expect(session.pendingDraft, isNull);
  });

  test('read-current recovery imports a frame and never reloads SSO', () async {
    await session.openTimetable(term: SchoolTerm(73));
    const home = 'http://yjsjy.uestc.edu.cn/pyxx/home/index';
    platform.web.url = home;
    platform.web.javascript = (_) async => schoolPageEvidence(
      topUrl: home,
      documentUrl: home,
      authenticated: true,
      html: fixture(),
    );
    await session.readCurrentPage();
    expect(session.pendingDraft?.courses.length, 4);
    expect(platform.web.loads.length, 1);
  });

  test(
    'authenticated graduate root dashboard automatically opens timetable',
    () async {
      await session.openTimetable(term: SchoolTerm(73));
      const home = 'http://yjsjy.uestc.edu.cn/pyxx?targetUrl=-1';
      final decision = await platform.delegate.navigation(
        const NavigationRequest(url: home, isMainFrame: true),
      );
      expect(decision, NavigationDecision.navigate);
      platform.web.javascript = (_) async =>
          schoolPageEvidence(topUrl: home, authenticated: true);
      navigate(home);
      await flushSchoolEvents();
      expect(platform.web.loads.last, SchoolSession.timetableUrl.toString());
    },
  );

  test(
    'obsolete automatic request failure preserves a newer pending import',
    () async {
      await session.openTimetable(term: SchoolTerm(73));
      final oldRequest = Completer<void>();
      platform.web.request = (_) => oldRequest.future;
      platform.web.javascript = (_) async =>
          schoolPageEvidence(topUrl: platform.web.url!, authenticated: true);
      navigate('https://yjsjy.uestc.edu.cn/pyxx/home/index');
      await flushSchoolEvents();
      platform.web.javascript = (_) async =>
          schoolPageEvidence(topUrl: platform.web.url!, html: fixture());
      navigate(SchoolSession.timetableUrl.toString());
      await flushSchoolEvents();
      final fresh = session.pendingDraft;
      expect(fresh, isNotNull);
      oldRequest.completeError(StateError('obsolete request failure'));
      await flushSchoolEvents();
      expect(session.pendingDraft, same(fresh));
      expect(session.message, '读取成功，正在保存…');
    },
  );

  test('actual session follows service login then reads exam HTML', () async {
    await session.openExams(term: SchoolTerm(73));
    expect(platform.web.loads.single, SchoolSession.authUrl.toString());
    navigate('https://idas.uestc.edu.cn/authserver/login?service=graduate');
    await flushSchoolEvents();
    expect(session.connectionState, SchoolConnectionState.authenticating);
    expect(session.finding, isFalse);
    platform.web.javascript = (_) async => schoolPageEvidence(
      topUrl: platform.web.url!,
      authenticated: true,
      html: platform.web.url == SchoolSession.examUrl.toString()
          ? examHtml()
          : null,
      kind: 'exams',
    );
    navigate('http://yjsjy.uestc.edu.cn/pyxx/home/index');
    await flushSchoolEvents();
    expect(platform.web.loads.last, SchoolSession.examUrl.toString());
    expect(session.finding, isTrue);
    navigate(SchoolSession.examUrl.toString());
    await flushSchoolEvents();
    expect(session.pendingExams!.records.single.name, '矩阵理论');
    expect(session.connectionState, SchoolConnectionState.connected);
  });
  test(
    'obsolete main-frame error cannot interrupt a newer exam read',
    () async {
      await session.openExams(term: SchoolTerm(73));
      platform.web.javascript = (_) async => schoolPageEvidence(
        topUrl: platform.web.url!,
        html: examHtml(),
        kind: 'exams',
      );
      navigate(SchoolSession.examUrl.toString());
      await flushSchoolEvents();
      platform.delegate.resourceError(
        const WebResourceError(
          errorCode: -2,
          description: 'old request',
          isForMainFrame: true,
          url: 'https://yjsjy.uestc.edu.cn/pyxx/pygl/xskbcx/index/1',
        ),
      );
      await flushSchoolEvents();
      expect(session.finding, isTrue);
      expect(session.message, '读取成功，正在保存…');
    },
  );
  test(
    'open waits for logout so old clearing cannot blank the new login',
    () async {
      await session.openTimetable(term: SchoolTerm(73));
      platform.cookies.clearing = Completer<bool>();
      final closing = session.logout();
      await flushSchoolEvents();
      final reopening = session.openExams(term: SchoolTerm(73));
      await flushSchoolEvents();
      platform.cookies.clearing!.complete(true);
      await closing;
      await reopening;
      expect(session.hasOpened, isTrue);
      expect(platform.web.loads.last, SchoolSession.authUrl.toString());
      expect(session.requestingExams, isTrue);
    },
  );
  test(
    'acknowledging an old saved draft preserves a newer pending import',
    () async {
      await session.openExams(term: SchoolTerm(73));
      final old = SchoolExamAdapter.extract(examHtml());
      session.pendingExams = old;
      final generation = session.pageGeneration;
      await session.openExams(term: SchoolTerm(73));
      final newer = SchoolExamAdapter.extract(examHtml(room: '品学楼A101'));
      session.pendingExams = newer;
      expect(
        session.saved(success: true, generation: generation, exams: old),
        isFalse,
      );
      expect(session.pendingExams, same(newer));
      expect(
        session.saved(
          success: true,
          generation: session.pageGeneration,
          exams: newer,
        ),
        isTrue,
      );
      expect(session.pendingExams, isNull);
    },
  );
  test(
    'native logout failure is reported and subsequent login can recover',
    () async {
      await session.openTimetable(term: SchoolTerm(73));
      session.connectionState = SchoolConnectionState.connected;
      platform.cookies.clearing = Completer<bool>();
      final closing = session.logout();
      final result = closing.then((_) => true, onError: (_) => false);
      platform.cookies.clearing!.completeError(
        StateError('cookie clearing failed'),
      );
      expect(await result, isTrue);
      expect(session.connectionState, isNot(SchoolConnectionState.connected));
      expect(session.message, contains('退出未完成'));
      await session.openExams(term: SchoolTerm(73));
      expect(platform.web.loads.last, SchoolSession.authUrl.toString());
    },
  );
  test('university HTTP identity redirect upgrades to HTTPS with service preserved', () async {
    await session.openTimetable(term: SchoolTerm(73));
    const redirect =
        'http://idas.uestc.edu.cn/authserver/login?service=http%3A%2F%2Fyjsjy.uestc.edu.cn%2Fpyxx%2Fjzsso%2Flogin';
    final decision = await platform.delegate.navigation(
      const NavigationRequest(url: redirect, isMainFrame: true),
    );
    expect(decision, NavigationDecision.prevent);
    final opened = Uri.parse(platform.web.loads.last);
    expect(opened.host, 'idas.uestc.edu.cn');
    expect(opened.scheme, 'https');
    expect(opened.query, Uri.parse(redirect).query);
  });
}