import 'package:fake_cloud_firestore/fake_cloud_firestore.dart';
import 'package:cloud_firestore/cloud_firestore.dart' show SetOptions, Timestamp;
import 'package:fancake/core/data/backend.dart';
import 'package:fancake/features/quest/quest_data.dart';
import 'package:fancake/features/quest/quest_evidence.dart';
import 'package:fancake/features/quest/quest_repository_firestore.dart';
import 'package:firebase_auth_mocks/firebase_auth_mocks.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:shared_preferences/shared_preferences.dart';

/// 퀘스트 서버 연동 계층 — 화면 대조 원장 F4 의 데이터 경로.
///
/// **무엇을 읽어 무엇으로 옮기는지**와 **어느 함수를 부르는지**를 본다. 규칙이 틀리면
/// 화면은 조용히 0 을 그리거나 엉뚱한 함수를 불러 지급이 일어나므로, 눈으로는 잡히지
/// 않는다. 지급 자체의 판정은 서버 쪽 `firebase/functions/test/quest_e2e.test.ts` 가 본다.

const _uid = 'u-quest';

/// Cloud Functions 호출을 기록하는 경계. 실제 함수는 에뮬레이터에서 따로 검증한다.
class _RecordingBackend extends Backend {
  _RecordingBackend(FakeFirebaseFirestore db, {Map<String, dynamic>? reply})
    : _reply =
          reply ?? const {'txId': 'tx-1', 'balanceAfter': 60, 'rewarded': 10},
      super(
        firestore: db,
        auth: MockFirebaseAuth(
          signedIn: true,
          mockUser: MockUser(uid: _uid, displayName: '테스터'),
        ),
      );

  final Map<String, dynamic> _reply;
  final List<({String name, Map<String, dynamic> payload})> calls = [];

  @override
  Future<Map<String, dynamic>> call(
    String name, [
    Map<String, dynamic> payload = const {},
  ]) async {
    calls.add((name: name, payload: payload));
    return _reply;
  }
}

String _today() => DateTime.now()
    .toUtc()
    .add(const Duration(hours: 9))
    .toIso8601String()
    .substring(0, 10);

Future<FakeFirebaseFirestore> _seed() async {
  final db = FakeFirebaseFirestore();
  await db.doc('users/$_uid').set({'uid': _uid, 'fandomId': 'bts'});
  // 걸음 목표는 운영값이다 — 앱에 하드코딩하지 않는다(별첨 B 「운영값 관리 원칙」).
  await db.doc('config/policy').set({
    'stepsGoal': 10000,
    'stepsPop': 50,
    'attendPop': 10,
  });
  await db.doc('quests/attend').set({
    'type': 'attend',
    'title': '오늘의 출석',
    'rewardPop': 50,
    'dailyLimit': 1,
  });
  await db.doc('quests/steps').set({
    'type': 'walk',
    'title': '만보기',
    'rewardPop': 50,
    'dailyLimit': 1,
  });
  await db.doc('quests/place').set({
    'type': 'location',
    'title': '팝업 방문',
    'rewardPop': 100,
    'dailyLimit': 1,
    'placeId': 'hongdae',
  });
  await db.doc('quests/stream').set({
    'type': 'streaming',
    'title': '신곡 완청',
    'rewardPop': 10,
    'dailyLimit': 1,
  });
  return db;
}

QuestCard _card(List<QuestCard> cards, String id) =>
    cards.firstWhere((c) => c.id == id);

void main() {
  TestWidgetsFlutterBinding.ensureInitialized();

  setUp(() {
    // 걸음 기준선은 단말에 남는다. 회차마다 빈 저장소에서 시작해야 값이 겹치지 않는다.
    SharedPreferences.setMockInitialValues({});
  });

  group('퀘스트 목록 — Firestore 구현', () {
    test('UGC 퀘스트의 제출 건 조회가 거부돼도 목록 전체는 뜬다 (2026-10-04 실기기)', () async {
      // 제출 건 읽기를 막은 규칙 — 배포 전 규칙에서 없는 문서 get 이 permission-denied 였다.
      final db = FakeFirebaseFirestore(securityRules: '''
service cloud.firestore {
  match /databases/{database}/documents {
    match /quests/{id} { allow read, write: if true; }
    match /config/{id} { allow read, write: if true; }
    match /users/{document=**} { allow read, write: if true; }
  }
}''');
      await db.doc('quests/attend').set({'type': 'attend', 'title': '출석', 'dailyLimit': 1});
      await db.doc('quests/ugc').set({
        'type': 'community', 'title': '내가 만든 퀘스트', 'authorUid': 'someone',
        'status': 'published', 'goal': 1,
      });
      final cards = await FirestoreQuestRepository(_RecordingBackend(db)).load();
      expect(cards.map((c) => c.id).toSet(), {'attend', 'ugc'});
      expect(_card(cards, 'ugc').stage, QuestStage.notStarted);
    });

    test('정의 문서를 카드로 옮기고 유형을 별칭까지 읽는다', () async {
      final db = await _seed();
      final cards = await FirestoreQuestRepository(
        _RecordingBackend(db),
      ).load();

      expect(cards.map((c) => c.id).toSet(), {
        'attend',
        'steps',
        'place',
        'stream',
      });
      expect(_card(cards, 'steps').type, QuestType.steps);
      expect(_card(cards, 'place').type, QuestType.place);
      // 출석은 문서의 50 이 아니라 서버가 지급하는 config/policy.attendPop 이다.
      expect(_card(cards, 'attend').rewardPop, 10);
      // 걸음 목표는 `config/policy` 에서 온다. 나머지 유형은 일일 한도가 목표다.
      expect(_card(cards, 'steps').goal, 10000);
      expect(_card(cards, 'attend').goal, 1);
      expect(_card(cards, 'attend').stage, QuestStage.notStarted);
    });

    test('당일 한도를 채우면 보상완료로 본다', () async {
      final db = await _seed();
      await db.doc('users/$_uid/questProgress/attend').set({
        'count': 1,
        'dayKey': _today(),
      });
      final cards = await FirestoreQuestRepository(
        _RecordingBackend(db),
      ).load();
      expect(_card(cards, 'attend').stage, QuestStage.rewarded);
    });

    test('어제 진행분은 오늘로 세지 않는다', () async {
      final db = await _seed();
      await db.doc('users/$_uid/questProgress/attend').set({
        'count': 1,
        'dayKey': '2026-01-01',
      });
      final cards = await FirestoreQuestRepository(
        _RecordingBackend(db),
      ).load();
      expect(_card(cards, 'attend').stage, QuestStage.notStarted);
    });

    test('닫힌 퀘스트는 감추고 기간 필드가 없는 문서는 그대로 보여 준다', () async {
      final db = await _seed();
      await db.doc('quests/closed').set({
        'type': 'attend',
        'title': '지난 이벤트',
        'rewardPop': 10,
        'active': false,
      });
      final cards = await FirestoreQuestRepository(
        _RecordingBackend(db),
      ).load();
      expect(cards.map((c) => c.id), isNot(contains('closed')));
      // 시연 데이터에도 Admin 문서에도 없는 필드를 근거로 감추지 않는다.
      expect(cards.map((c) => c.id), contains('attend'));
    });

    test('비활성 문서가 첫 페이지를 채워도 11번째 이후 퀘스트가 보인다 (2026-10-06 실기기)', () async {
      final db = FakeFirebaseFirestore();
      // 문서 ID 순으로 앞 10건이 비활성(daily-*) — 걸러낸 뒤 개수로 끝을 판정하면 뒤가 사라진다.
      for (var i = 0; i < 10; i++) {
        await db.doc('quests/a-daily-$i').set({'type': 'attend', 'title': 'd$i', 'active': false});
      }
      await db.doc('quests/z-music').set({'type': 'music_shake', 'title': '박자 맞춰 흔들기'});
      final repo = FirestoreQuestRepository(_RecordingBackend(db));
      final first = await repo.load();
      expect(first.map((c) => c.id), contains('z-music'));
      // 10장보다 적으면 끝 — 다음 페이지는 비어 있다.
      expect(first.length, lessThan(10));
      expect(await repo.more(offset: first.length), isEmpty);
    });

    test('보이는 퀘스트가 10건을 넘으면 다음 페이지에서 11번째부터 온다', () async {
      final db = FakeFirebaseFirestore();
      for (var i = 0; i < 12; i++) {
        await db.doc('quests/q${i.toString().padLeft(2, '0')}').set({'type': 'attend', 'title': 'q$i'});
      }
      final repo = FirestoreQuestRepository(_RecordingBackend(db));
      final first = await repo.load();
      expect(first, hasLength(10));
      final next = await repo.more(offset: first.length);
      expect(next, hasLength(2));
      expect({...first, ...next}.map((c) => c.id).toSet(), hasLength(12));
    });

    test('내가 만든 퀘스트는 내 퀘스트 상태로 온다', () async {
      final db = await _seed();
      await db.doc('quests/mine').set({
        'type': 'attend',
        'title': '내가 만든 것',
        'rewardPop': 10,
        'authorUid': _uid,
      });
      final cards = await FirestoreQuestRepository(
        _RecordingBackend(db),
      ).load();
      expect(_card(cards, 'mine').stage, QuestStage.mine);
      expect(_card(cards, 'mine').author, QuestAuthor.user);
    });
  });

  group('퀘스트 참여 — 지급은 전부 Cloud Functions 를 지난다', () {
    test('출석은 fnQuestAttend 를 부르고 서버 값을 그대로 옮긴다', () async {
      final db = await _seed();
      final backend = _RecordingBackend(db);
      final repo = FirestoreQuestRepository(backend);
      final cards = await repo.load();

      final reward = await repo.verify(_card(cards, 'attend'));
      expect(backend.calls.single.name, 'fnQuestAttend');
      expect(reward.rewardedPop, 10);
      expect(reward.balanceAfter, 60);
    });

    test('걸음은 하루 기준선 대비 오늘치를 보낸다', () async {
      final db = await _seed();
      final backend = _RecordingBackend(db);
      final repo = FirestoreQuestRepository(
        backend,
        // 부팅 이후 누적값이 들어온다. 그대로 보내면 며칠 켜 둔 단말이 공짜로 통과한다.
        stepCount: () => Stream.fromIterable([40_000, 45_000, 50_400]),
      );
      final cards = await repo.load();
      final card = _card(cards, 'steps');

      expect(await repo.progressStream(card).toList(), [0, 5_000, 10_400]);
      await repo.verify(card);
      expect(backend.calls.single.name, 'fnQuestVerifySteps');
      expect(backend.calls.single.payload['steps'], 10_400);
      // 진행 문서와 일일 한도를 퀘스트 단위로 세도록 문서 ID 를 함께 보낸다.
      expect(backend.calls.single.payload['questId'], 'steps');
      // 집계 축은 소속 팬덤이다 — `activityLogs.fandomId`(설계서 §2.1).
      expect(backend.calls.single.payload['fandomId'], 'bts');
      expect(backend.calls.single.payload['occurredAt'], isA<String>());
    });

    test('Health 가 있으면 그 날 0시부터의 합계를 센서보다 먼저 쓴다 (B-02)', () async {
      final db = await _seed();
      final backend = _RecordingBackend(db);
      final repo = FirestoreQuestRepository(
        backend,
        todaySteps: () async => 7_300,
        stepCount: () => Stream.fromIterable([40_000]),
      );
      final card = _card(await repo.load(), 'steps');
      expect(await repo.progressStream(card).first, 7_300);
      await repo.verify(card);
      expect(backend.calls.single.payload['steps'], 7_300);
    });

    test('앱을 껐다 켜도 오늘치가 0 으로 돌아가지 않는다', () async {
      final db = await _seed();
      // 첫 실행 — 기준선 40,000 을 잡고 5,000 걷는다.
      final first = FirestoreQuestRepository(
        _RecordingBackend(db),
        stepCount: () => Stream.fromIterable([40_000, 45_000]),
      );
      final card = _card(await first.load(), 'steps');
      expect(await first.progressStream(card).toList(), [0, 5_000]);

      // 앱을 다시 열었다. 저장소도 기준선도 새로 만들지만 단말에 남은 값을 읽는다.
      final backend = _RecordingBackend(db);
      final second = FirestoreQuestRepository(
        backend,
        stepCount: () => Stream.fromIterable([46_200]),
      );
      expect(await second.progressStream(card).toList(), [6_200]);
      await second.verify(card);
      expect(backend.calls.single.payload['steps'], 6_200);
    });

    test('출석도 퀘스트 문서 ID 를 함께 보낸다', () async {
      final db = await _seed();
      final backend = _RecordingBackend(db);
      final repo = FirestoreQuestRepository(backend);
      final cards = await repo.load();

      await repo.verify(_card(cards, 'attend'));
      expect(backend.calls.single.payload['questId'], 'attend');
    });

    test('걸음 수를 아직 세지 못했으면 서버를 부르지 않는다', () async {
      final db = await _seed();
      final backend = _RecordingBackend(db);
      final repo = FirestoreQuestRepository(backend);
      final cards = await repo.load();

      await expectLater(
        repo.verify(_card(cards, 'steps')),
        throwsA(
          isA<BackendException>().having((e) => e.code, 'code', 'E-QST-01'),
        ),
      );
      expect(backend.calls, isEmpty);
    });

    test('위치는 좌표와 모의 위치 여부를 함께 보낸다', () async {
      final db = await _seed();
      final backend = _RecordingBackend(db);
      final repo = FirestoreQuestRepository(
        backend,
        placeFix: () async => const PlaceFix(
          lat: 37.5563,
          lng: 126.9236,
          accuracyM: 12,
          mocked: true,
        ),
      );
      final cards = await repo.load();
      await repo.verify(_card(cards, 'place'));

      final call = backend.calls.single;
      expect(call.name, 'fnQuestVerifyPlace');
      expect(call.payload['placeId'], 'hongdae');
      expect(call.payload['questId'], 'place');
      expect(call.payload['lat'], 37.5563);
      // 판정은 서버가 한다. 앱은 모의 위치 여부를 감추지도, 스스로 막지도 않는다.
      expect(call.payload['mocked'], isTrue);
    });

    test('위치 Quest 의 인증 방법을 상세에 싣고 QR 은 GPS 와 함께 보낸다 (C-03 · PRD-05)', () async {
      final db = await _seed();
      final backend = _RecordingBackend(db);
      final repo = FirestoreQuestRepository(
        backend,
        placeFix: () async =>
            const PlaceFix(lat: 37.5, lng: 126.9, accuracyM: 5, mocked: false),
      );
      // 수단을 적지 않은 운영 Quest 는 GPS 하나.
      expect((await repo.detail('place')).verifyMethods, ['gps']);
      await db.doc('quests/place').update({'verifyMethods': ['gps', 'qr']});
      await db.doc('questSecrets/place').set({'authorUid': 'other', 'qrCode': 'secret'});
      final detail = await repo.detail('place');
      expect(detail.verifyMethods, ['gps', 'qr']);
      expect(detail.qrCode, isNull, reason: '참여자에게는 QR 값을 주지 않는다');

      await repo.verify(detail.card, proof: const PlaceProof(qr: 'scanned'));
      final call = backend.calls.single;
      expect(call.payload['qr'], 'scanned');
      expect(call.payload['lat'], 37.5);
      expect(call.payload.containsKey('photo'), isFalse);
    });

    test('장소가 등록되지 않은 위치 퀘스트는 서버를 부르지 않는다', () async {
      final db = await _seed();
      await db.doc('quests/place').set({
        'type': 'location',
        'title': '장소 미등록',
        'rewardPop': 100,
        'dailyLimit': 1,
      });
      final backend = _RecordingBackend(db);
      final repo = FirestoreQuestRepository(backend);
      final cards = await repo.load();

      await expectLater(
        repo.verify(_card(cards, 'place')),
        throwsA(
          isA<BackendException>().having((e) => e.code, 'code', 'E-QST-03'),
        ),
      );
      expect(backend.calls, isEmpty);
    });

    test('시청 · 스트리밍은 무보상 참여 함수만 부른다(C-04) — 보상은 0', () async {
      final db = await _seed();
      final backend = _RecordingBackend(db, reply: const {'rewarded': 0, 'remaining': 0});
      final repo = FirestoreQuestRepository(backend);
      final card = _card(await repo.load(), 'stream');

      expect(card.type.verifiable, isTrue);
      // 문서에 rewardPop 10 이 남아 있어도 화면에 보상을 약속하지 않는다.
      expect(card.rewardPop, 0);
      final reward = await repo.verify(card);
      expect(backend.calls.single.name, 'fnQuestStreamParticipate');
      expect(backend.calls.single.payload, {'questId': 'stream'});
      expect(reward.rewardedPop, 0);
    });

    test('Music Shake — 영상 · BPM · 구간 수를 퀘스트에서 읽고 판정표 · 곡 ID 를 서버에 보낸다', () async {
      final db = await _seed();
      await db.doc('config/policy').set({
        'musicShake': {'perfectWindow': 0.1, 'goodWindow': 0.4, 'pop': 3},
      }, SetOptions(merge: true));
      await db.doc('quests/shake').set({
        'type': 'musicshake', 'title': '응원 흔들기', 'dailyLimit': 1,
        'totalSegments': 3, 'bpm': 120, 'firstBeatMs': 17000,
        'link': {'url': 'https://youtu.be/WMweEpGlu_U', 'title': 'BTS - Butter'},
      });
      final backend = _RecordingBackend(db);
      final repo = FirestoreQuestRepository(backend);
      final card = _card(await repo.load(), 'shake');
      expect(card.type.verifiable, isTrue);
      // Figma 「목표BPM」 — 목표 줄은 곡 BPM 이다. 보상은 운영값 musicShake.pop.
      expect(card.goal, 120);
      expect(card.rewardPop, 3);

      final setup = await repo.musicShakeSetup('shake');
      expect(setup.videoId, 'WMweEpGlu_U');
      expect(setup.title, 'BTS - Butter');
      expect((setup.bpm, setup.segments), (120.0, 3));
      expect(setup.firstBeat, const Duration(seconds: 17));
      expect((setup.windows.perfect, setup.windows.good), (0.1, 0.4));

      // 판을 끝내기 전에는 서버를 부르지 않는다.
      await expectLater(repo.verify(card), throwsA(isA<BackendException>()));
      expect(backend.calls, isEmpty);

      repo.recordShake(ShakeJudge(bpm: 120, segments: 3, firstBeat: setup.firstBeat, windows: setup.windows)
        ..add(setup.firstBeat));
      await repo.verify(card);
      final call = backend.calls.single;
      expect(call.name, 'fnQuestVerifyMusicShake');
      expect(call.payload['questId'], 'shake');
      expect(call.payload['trackId'], 'WMweEpGlu_U');
      expect(call.payload['totalSegments'], 3);
      expect(call.payload['firstBeatMs'], 17000);
      expect(call.payload['judgement'], {'perfect': 1, 'good': 0, 'miss': 2, 'maxCombo': 1});
    });

    test('Music Shake — 영상 · BPM · 구간 수가 없으면 판을 열지 않는다(값을 지어내지 않는다)', () async {
      final db = await _seed();
      await db.doc('quests/shake').set({'type': 'musicshake', 'title': '흔들기', 'totalSegments': 3});
      final repo = FirestoreQuestRepository(_RecordingBackend(db));
      await expectLater(repo.musicShakeSetup('shake'), throwsA(isA<BackendException>()));
      expect(_card(await repo.load(), 'shake').goal, 0);
    });

    test('생성은 fn-quest-create 로 — 종료일은 날짜 + 그 시각의 UTC 오프셋(C-06)', () async {
      final db = await _seed();
      final backend = _RecordingBackend(db, reply: const {'questId': 'q-new'});
      final repo = FirestoreQuestRepository(backend);
      final id = await repo.create(
        QuestDraft(
          clientSeq: 's1',
          activityKey: 'vote',
          title: '투표',
          rewardPop: 5,
          participants: 10,
          endDate: DateTime(2026, 10, 3),
          url: 'https://x.com/a',
          manualTitle: '제목',
        ),
      );
      expect(id, 'q-new');
      final call = backend.calls.single;
      expect(call.name, 'fnQuestCreate');
      expect(call.payload, containsPair('endDate', '2026-10-03'));
      expect(call.payload, containsPair('capacity', 10));
      expect(call.payload, containsPair('manualTitle', '제목'));
      expect(
        call.payload['utcOffsetMinutes'],
        DateTime(2026, 10, 3, 23, 59, 59).timeZoneOffset.inMinutes,
      );
      // 앱은 quests 에 직접 쓰지 않는다.
      expect((await db.collection('quests').get()).docs, hasLength(4));
    });

    test(
      '분류 마스터 — 노출 · ugcAllowed · 순서를 따르고 만들 활동이 없는 분류는 감춘다(C-01)',
      () async {
        final db = await _seed();
        await db.doc('config/policy').update({
          'ugcFeeMin': 20,
          'ugcMaxDays': 14,
        });
        await db.doc('config/questCatalog').set({
          'categories': [
            {'key': 'location', 'label': '특정 위치', 'order': 2, 'visible': true},
            {'key': 'planet', 'label': '행성 활동', 'order': 1, 'visible': true},
            {'key': 'health', 'label': '건강', 'order': 3, 'visible': true},
            {'key': 'community', 'label': '커뮤니티', 'order': 4, 'visible': false},
          ],
          'activities': [
            {
              'key': 'sns',
              'categoryKey': 'planet',
              'order': 2,
              'visible': true,
              'ugcAllowed': true,
              'inputSchema': [
                {'field': 'link', 'required': true},
              ],
            },
            {
              'key': 'vote',
              'categoryKey': 'planet',
              'order': 1,
              'visible': true,
              'ugcAllowed': true,
              'inputSchema': [
                {'field': 'link', 'required': true},
              ],
            },
            {
              'key': 'youtube',
              'categoryKey': 'planet',
              'order': 3,
              'visible': true,
              'ugcAllowed': false,
            },
            {
              'key': 'walk',
              'categoryKey': 'health',
              'order': 1,
              'visible': true,
              'ugcAllowed': false,
            },
            {
              'key': 'location',
              'categoryKey': 'location',
              'order': 1,
              'visible': true,
              'ugcAllowed': true,
              'inputSchema': [
                {'field': 'place', 'required': true},
              ],
            },
            {
              'key': 'qr',
              'categoryKey': 'location',
              'order': 2,
              'visible': true,
              'ugcAllowed': false,
            },
            {
              'key': 'community',
              'categoryKey': 'community',
              'order': 1,
              'visible': true,
              'ugcAllowed': true,
            },
          ],
        });
        final catalog = await FirestoreQuestRepository(
          _RecordingBackend(db),
        ).catalog();
        expect(catalog.categories.map((c) => c.id), ['planet', 'location']);
        expect(catalog.categories.first.activities.map((a) => a.key), [
          'vote',
          'sns',
        ]);
        expect(catalog.categories.first.activities.first.fields, {'link'});
        expect(catalog.categories.last.activities.single.fields, {'place'});
        expect(catalog.feeOf(50), 20);
        // Q-UQ-02 권고 A안 — 보상 없는 Quest 는 수수료 0.
        expect(catalog.feeOf(0), 0);
        expect(catalog.maxDays, 14);
      },
    );

    test('제출 · 검토 · 수정은 각 함수로만 간다', () async {
      final db = await _seed();
      final backend = _RecordingBackend(db);
      final repo = FirestoreQuestRepository(backend);
      await repo.submit('q1', url: 'https://x.com/p', text: '');
      await repo.review(
        'q1_u',
        approve: false,
        reason: '불명확',
        resubmitAllowed: true,
      );
      await repo.edit('q1', title: 't', description: 'd');
      expect(backend.calls.map((c) => c.name), [
        'fnQuestSubmit',
        'fnQuestReview',
        'fnQuestEdit',
      ]);
      expect(backend.calls.first.payload, {
        'questId': 'q1',
        'url': 'https://x.com/p',
      });
      expect(backend.calls[1].payload, {
        'submissionId': 'q1_u',
        'action': 'reject',
        'reason': '불명확',
        'resubmitAllowed': true,
      });
    });

    test('마감이 지난 남의 사용자 생성 Quest 는 목록에서 빠진다(G-04)', () async {
      final db = await _seed();
      await db.doc('quests/ugc-old').set({
        'type': 'vote',
        'title': '지난 투표',
        'authorUid': 'someone',
        'status': 'published',
        'endsAt': DateTime.now().subtract(const Duration(minutes: 1)),
      });
      await db.doc('quests/ugc-live').set({
        'type': 'vote',
        'title': '진행 투표',
        'authorUid': 'someone',
        'status': 'published',
        'endsAt': DateTime.now().add(const Duration(hours: 3)),
        'capacity': 5,
      });
      final cards = await FirestoreQuestRepository(
        _RecordingBackend(db),
      ).load(limit: 20);
      expect(cards.map((c) => c.id), isNot(contains('ugc-old')));
      final live = _card(cards, 'ugc-live');
      expect(live.type, QuestType.vote);
      expect(live.author, QuestAuthor.user);
      expect(live.capacity, 5);
    });
  });

  group('진행 상태 저장 · 일시 정지 · 최신순 (원장 C-83 · 명세 518:88395)', () {
    Future<FakeFirebaseFirestore> shakeSeed() async {
      final db = await _seed();
      await db.doc('quests/shake').set({
        'type': 'musicshake', 'title': '응원 흔들기', 'dailyLimit': 1,
        'totalSegments': 60, 'bpm': 120,
        'link': {'url': 'https://youtu.be/WMweEpGlu_U'},
      });
      return db;
    }

    test('목록은 createdAt 내림차순으로 서버 정렬해 커서로 이어 읽는다', () async {
      final db = FakeFirebaseFirestore();
      await db.doc('users/$_uid').set({'uid': _uid});
      await db.doc('config/policy').set({'attendPop': 10});
      for (var i = 0; i < 12; i++) {
        await db.doc('quests/q$i').set({
          'type': 'attend', 'title': 'Q$i', 'dailyLimit': 1,
          'createdAt': Timestamp.fromMillisecondsSinceEpoch(1000000 + i * 1000),
        });
      }
      final repo = FirestoreQuestRepository(_RecordingBackend(db));
      final first = await repo.load();
      final next = await repo.more(offset: first.length);
      expect([...first, ...next].map((c) => c.id).toList(),
          [for (var i = 11; i >= 0; i--) 'q$i']);
    });

    test('Music Shake 세션 — 화면 밖 진행중은 일시 정지 · 진행완료는 보상받기 · 진행중 탭이 받는다', () async {
      final db = await shakeSeed();
      final ref = db.doc('users/$_uid/questProgress/shake');
      final repo = FirestoreQuestRepository(_RecordingBackend(db));

      await ref.set({'session': {'state': 'inProgress', 'progress': 43, 'total': 60, 'firstBeatMs': 0}});
      var card = _card(await repo.load(), 'shake');
      // 앱이 꺼진 진행중도 진행 화면 밖이므로 일시 정지다.
      expect(card.stage, QuestStage.paused);
      expect(card.stage.buttonLabel, '이어하기');
      expect(QuestTab.inProgress.accepts(card), isTrue);

      await ref.set({'session': {
        'state': 'completed', 'progress': 60, 'total': 60, 'firstBeatMs': 0,
        'judgement': {'perfect': 50, 'good': 5, 'miss': 5, 'maxCombo': 30},
      }});
      card = _card(await repo.load(), 'shake');
      expect(card.stage, QuestStage.completed);
      expect(QuestTab.inProgress.accepts(card), isTrue);
    });

    test('목록에서 바로 받는 Music Shake 는 서버 세션의 판정표를 보낸다', () async {
      final db = await shakeSeed();
      await db.doc('users/$_uid/questProgress/shake').set({'session': {
        'state': 'completed', 'progress': 60, 'total': 60, 'firstBeatMs': 0,
        'judgement': {'perfect': 50, 'good': 5, 'miss': 5, 'maxCombo': 30},
      }});
      final backend = _RecordingBackend(db);
      final repo = FirestoreQuestRepository(backend);
      await repo.verify(_card(await repo.load(), 'shake'));
      final call = backend.calls.single;
      expect(call.name, 'fnQuestVerifyMusicShake');
      expect(call.payload['totalSegments'], 60);
      expect(call.payload['judgement'], {'perfect': 50, 'good': 5, 'miss': 5, 'maxCombo': 30});
    });

    test('Walk 는 일시 정지 없이 오늘 걸음으로 진행중 · 진행완료를 낸다(C-62)', () async {
      final db = await _seed();
      await db.doc('users/$_uid/questProgress/steps').set({
        'session': {'state': 'inProgress', 'progress': 0, 'total': 10000},
      });
      var steps = 4_000;
      final repo = FirestoreQuestRepository(
        _RecordingBackend(db),
        todaySteps: () async => steps,
      );
      var card = _card(await repo.load(), 'steps');
      expect((card.stage, card.progress), (QuestStage.inProgress, 4_000));
      steps = 10_200; // 화면 밖에서 걸었다.
      card = _card(await repo.load(), 'steps');
      expect((card.stage, card.progress), (QuestStage.completed, 10_200));
    });

    test('진행 상태는 fnQuestProgress 로만 쓰고 중단은 none 이다', () async {
      final db = await _seed();
      final backend = _RecordingBackend(db);
      final repo = FirestoreQuestRepository(backend);
      await repo.advance('shake', QuestStage.paused,
          session: const QuestSession(
            state: QuestStage.paused, progress: 43, total: 60,
            position: Duration(milliseconds: 21500), hits: [0.1, -1],
          ));
      await repo.advance('steps', QuestStage.notStarted);
      expect(backend.calls.map((c) => c.name), ['fnQuestProgress', 'fnQuestProgress']);
      expect(backend.calls.first.payload, {
        'questId': 'shake', 'state': 'paused', 'progress': 43, 'total': 60,
        'positionMs': 21500, 'hits': [0.1, -1.0],
      });
      expect(backend.calls.last.payload, {'questId': 'steps', 'state': 'none'});
    });

    test('캡슐은 가장 최근에 멈춘 Quest 1건이다(QA 3-34)', () async {
      final db = await shakeSeed();
      await db.doc('quests/shake2').set({
        'type': 'musicshake', 'title': '두 번째', 'totalSegments': 30, 'bpm': 100,
      });
      await db.doc('users/$_uid/questProgress/shake').set({'session': {
        'state': 'paused', 'progress': 43, 'total': 60, 'firstBeatMs': 0,
        'updatedAt': Timestamp.fromMillisecondsSinceEpoch(2000),
      }});
      await db.doc('users/$_uid/questProgress/shake2').set({'session': {
        'state': 'paused', 'progress': 3, 'total': 30, 'firstBeatMs': 0,
        'updatedAt': Timestamp.fromMillisecondsSinceEpoch(1000),
      }});
      final repo = FirestoreQuestRepository(_RecordingBackend(db));
      final card = await repo.pausedQuest();
      expect(card?.id, 'shake');
      expect((card?.session?.progress, card?.session?.total), (43, 60));
    });

    test('운영값이 바뀐 옛 Music Shake 판은 일시 정지로 보이지 않고 시작하기다 (10/6)', () async {
      final db = await shakeSeed();
      await db.doc('quests/shake').update({'firstBeatMs': 24276});
      await db.doc('users/$_uid/questProgress/shake').set({'session': {
        'state': 'paused', 'progress': 43, 'total': 60, 'firstBeatMs': 0,
      }});
      final repo = FirestoreQuestRepository(_RecordingBackend(db));
      final card = _card(await repo.load(), 'shake');
      expect((card.stage, card.session, card.staleShake), (QuestStage.notStarted, null, true));
      expect(await repo.pausedQuest(), isNull);
      // 맞는 판은 그대로 일시 정지다.
      await db.doc('users/$_uid/questProgress/shake').set({'session': {
        'state': 'paused', 'progress': 43, 'total': 60, 'firstBeatMs': 24276,
      }});
      final ok = _card(await repo.load(), 'shake');
      expect((ok.stage, ok.staleShake), (QuestStage.paused, false));
    });
  });
}