import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
import { FieldValue, getFirestore, Timestamp } from 'firebase-admin/firestore';

import { bootAdmin, shutdownAdmin, wipeUser } from './support.js';
import {
  fnTranslationMark, fnTranslationSettle, fnTranslationSubmit,
} from '../src/account/translation.js';
import { grantPop, reconcileUser, settlePendingGrant } from '../src/ledger/ledger.js';

/**
 * 참여형 번역 왕복 — 등록(보류 지급) → 마킹(자격 판정) → 24시간 뒤 정산(확정/해제).
 * 원장 B-63: 1건 5 POP · 24시간 확정대기 · 자기 마킹 제외 · 중복 0 · 일일상한.
 */

const AUTHOR = 'test-trn-author';
const COPIER = 'test-trn-copier';
const MARKER = 'test-trn-marker';
const NEWBIE = 'test-trn-newbie';
const OUTSIDER = 'test-trn-outsider';
const USERS = [AUTHOR, COPIER, MARKER, NEWBIE, OUTSIDER];
const TARGET = 'questions/test-trn-q1';
const POST = 'posts/test-trn-p1';
const CAMPAIGN = 'campaigns/test-trn-c1';
const HIDDEN_POST = 'posts/test-trn-hidden';
const REVIEW_CAMPAIGN = 'campaigns/test-trn-review';
const NO_FANDOM_CAMPAIGN = 'campaigns/test-trn-nofandom';
const DAY = 24 * 3600 * 1000;

type SubmitReq = Parameters<typeof fnTranslationSubmit.run>[0];
type MarkReq = Parameters<typeof fnTranslationMark.run>[0];
const submit = (uid: string, body: string, targetPath = TARGET) => fnTranslationSubmit.run({
  data: { targetPath, locale: 'en', body },
  auth: { uid, token: {} },
} as SubmitReq);
const mark = (uid: string, entryId: string, valid = true) => fnTranslationMark.run({
  data: { entryId, valid },
  auth: { uid, token: {} },
} as MarkReq);
const settle = () => fnTranslationSettle.run(
  { scheduleTime: new Date().toISOString() } as Parameters<typeof fnTranslationSettle.run>[0],
);
const age = (entryId: string, hours: number) => getFirestore()
  .doc(`translationEntries/${entryId}`)
  .update({ createdAt: Timestamp.fromMillis(Date.now() - hours * 3600 * 1000) });
const wallet = async (uid: string) =>
  (await getFirestore().doc(`users/${uid}/wallet/main`).get()).data() ?? {};

beforeAll(() => { bootAdmin(); });
afterAll(async () => { await shutdownAdmin(); });
beforeEach(async () => {
  const db = getFirestore();
  await Promise.all(USERS.map(wipeUser));
  const old = await db.collection('translationEntries')
    .where('targetPath', 'in', [TARGET, POST, `${POST}/comments/c1`, `${POST}/comments/hidden`, CAMPAIGN, NO_FANDOM_CAMPAIGN]).get();
  for (const d of old.docs) {
    const marks = await d.ref.collection('markings').get();
    await Promise.all(marks.docs.map((m) => m.ref.delete()));
    await d.ref.delete();
  }
  const counters = await db.collection('translationDaily').get();
  await Promise.all(counters.docs.filter((d) => USERS.includes(d.get('uid'))).map((d) => d.ref.delete()));
  const old2 = Timestamp.fromMillis(Date.now() - 2 * DAY);
  await Promise.all([
    db.doc(TARGET).set({ title: '질문', fandomId: 'trn-f1' }),
    db.doc(POST).set({ body: '글', fandomId: 'trn-f1', visibility: 'visible' }),
    db.doc(`${POST}/comments/c1`).set({ body: '댓글', visibility: 'visible' }),
    db.doc(`${POST}/comments/hidden`).set({ body: '가린 댓글', visibility: 'hidden' }),
    db.doc(HIDDEN_POST).set({ body: '가린 글', fandomId: 'trn-f1', visibility: 'hidden' }),
    db.doc(CAMPAIGN).set({ title: '캠페인', fandomId: 'trn-f1', status: 'funding' }),
    db.doc(REVIEW_CAMPAIGN).set({ title: '검수 중', fandomId: 'trn-f1', status: 'review' }),
    db.doc(NO_FANDOM_CAMPAIGN).set({ title: '팬덤 없음', status: 'funding' }),
    db.doc(`users/${AUTHOR}`).set({ createdAt: old2, fandomId: 'trn-f1', displayName: '김실명', nickname: '호떡이' }),
    db.doc(`users/${COPIER}`).set({ createdAt: old2, fandomId: 'trn-f1' }),
    db.doc(`users/${MARKER}`).set({ createdAt: old2, fandomId: 'trn-f1' }),
    db.doc(`users/${NEWBIE}`).set({ createdAt: Timestamp.now(), fandomId: 'trn-f1' }),
    db.doc(`users/${OUTSIDER}`).set({ createdAt: old2, fandomId: 'trn-f2' }),
  ]);
});

describe('번역 등록', () => {
  it('보상분은 예약 잔액으로 잡히고(G-05) 일일 카운터가 오른다', async () => {
    const first = await submit(AUTHOR, 'Hello fandom');
    expect(first).toMatchObject({ rewardPop: 5, excludedReason: null });
    const w = await wallet(AUTHOR);
    expect(w.activityBalance ?? 0).toBe(0);
    expect(w.pendingActivity).toBe(5);
    const today = (await getFirestore().collection('translationDaily')
      .where('uid', '==', AUTHOR).get()).docs[0]!;
    expect(today.get('count')).toBe(1);
  });

  it('같은 대상·언어 재등록은 E-TRN-05 · 남의 문장 복사는 보상 0 · 예약 없음', async () => {
    await submit(AUTHOR, 'Hello fandom');
    await expect(submit(AUTHOR, 'Hello again')).rejects.toMatchObject({ details: { code: 'E-TRN-05' } });
    expect(await submit(COPIER, 'Hello fandom')).toMatchObject({ rewardPop: 0, excludedReason: 'duplicate' });
    expect((await wallet(COPIER)).pendingActivity ?? 0).toBe(0);
  });

  it('번역 댓글은 글 경로(rootPath)와 작성자 표시명을 함께 남긴다 — 댓글 · 캠페인 대상 포함', async () => {
    const onComment = await submit(AUTHOR, 'Nice comment', `${POST}/comments/c1`);
    const onCampaign = await submit(AUTHOR, 'Cheer up', CAMPAIGN);
    const db = getFirestore();
    const a = await db.doc(`translationEntries/${onComment.entryId}`).get();
    expect(a.get('rootPath')).toBe(POST);
    expect(a.get('fandomId')).toBe('trn-f1');
    expect(a.get('authorName')).toBe('호떡이');
    const b = await db.doc(`translationEntries/${onCampaign.entryId}`).get();
    expect(b.get('rootPath')).toBe(CAMPAIGN);
    expect(b.get('fandomId')).toBe('trn-f1');
  });

  it('작성자 닉네임이 없으면 공급자 실명 대신 「팬」을 싣는다(M-7)', async () => {
    await getFirestore().doc(`users/${AUTHOR}`).update({ nickname: FieldValue.delete() });
    const { entryId } = await submit(AUTHOR, 'Hello fandom');
    const e = await getFirestore().doc(`translationEntries/${entryId}`).get();
    expect(e.get('authorName')).toBe('팬');
    expect(e.get('validCount')).toBe(0);
    expect(e.get('invalidCount')).toBe(0);
  });

  it('숨긴 글 · 숨긴 댓글 · 공개 전 캠페인은 없는 콘텐츠와 같은 E-TRN-03 이다', async () => {
    for (const target of [HIDDEN_POST, `${POST}/comments/hidden`, REVIEW_CAMPAIGN, `${HIDDEN_POST}/comments/x`]) {
      await expect(submit(AUTHOR, 'x', target)).rejects.toMatchObject({ details: { code: 'E-TRN-03' } });
    }
  });

  it('없는 콘텐츠와 허용 밖 경로는 같은 E-TRN-03 이다', async () => {
    await expect(submit(AUTHOR, 'x', 'questions/none-such')).rejects.toMatchObject({ details: { code: 'E-TRN-03' } });
    await expect(submit(AUTHOR, 'x', `users/${MARKER}`)).rejects.toMatchObject({ details: { code: 'E-TRN-03' } });
  });

  it('일일상한 3배(기본 30건)를 넘기면 E-TRN-02', async () => {
    const db = getFirestore();
    const { dayKey } = await import('../src/core/time.js');
    await db.doc(`translationDaily/${AUTHOR}_${dayKey(new Date())}`).set({ uid: AUTHOR, count: 30 });
    await expect(submit(AUTHOR, 'Hello')).rejects.toMatchObject({ details: { code: 'E-TRN-02' } });
  });
});

describe('번역 마킹', () => {
  it('본인 E-TRN-01 · 가입 24시간 미만 · 다른 팬덤(라운지) E-TRN-04 · 두 번째 E-TRN-05', async () => {
    const { entryId } = await submit(AUTHOR, 'Hello fandom', POST);
    await expect(mark(AUTHOR, entryId)).rejects.toMatchObject({ details: { code: 'E-TRN-01' } });
    await expect(mark(NEWBIE, entryId)).rejects.toMatchObject({ details: { code: 'E-TRN-04' } });
    await expect(mark(OUTSIDER, entryId)).rejects.toMatchObject({ details: { code: 'E-TRN-04' } });
    await expect(mark(MARKER, entryId)).resolves.toMatchObject({ valid: true });
    await expect(mark(MARKER, entryId, false)).rejects.toMatchObject({ details: { code: 'E-TRN-05' } });
    // 마킹 수는 같은 트랜잭션에서 번역 문서에 오른다 — 실패한 두 번째 마킹은 세지 않는다.
    const e = await getFirestore().doc(`translationEntries/${entryId}`).get();
    expect(e.get('validCount')).toBe(1);
    expect(e.get('invalidCount')).toBe(0);
  });

  it('무효 마킹은 invalidCount 를 올린다 · 동시에 두 번 눌러도 한 번만 센다', async () => {
    const { entryId } = await submit(AUTHOR, 'Hello fandom', POST);
    const results = await Promise.allSettled([mark(MARKER, entryId, false), mark(MARKER, entryId, false)]);
    expect(results.filter((r) => r.status === 'fulfilled')).toHaveLength(1);
    const e = await getFirestore().doc(`translationEntries/${entryId}`).get();
    expect(e.get('invalidCount')).toBe(1);
    expect(e.get('validCount')).toBe(0);
  });

  it('등록 뒤 가려진 글의 번역은 마킹하지 못한다(E-TRN-03)', async () => {
    const { entryId } = await submit(AUTHOR, 'Hello fandom', `${POST}/comments/c1`);
    await getFirestore().doc(POST).update({ visibility: 'hidden' });
    await expect(mark(MARKER, entryId)).rejects.toMatchObject({ details: { code: 'E-TRN-03' } });
  });

  it('팬덤이 없는 캠페인의 번역은 아무도 마킹하지 못한다(E-TRN-04)', async () => {
    const { entryId } = await submit(AUTHOR, 'Cheer', NO_FANDOM_CAMPAIGN);
    await expect(mark(MARKER, entryId)).rejects.toMatchObject({ details: { code: 'E-TRN-04' } });
  });

  it('캠페인 번역은 그 팬덤 멤버만 마킹한다', async () => {
    const { entryId } = await submit(AUTHOR, 'Cheer', CAMPAIGN);
    await expect(mark(OUTSIDER, entryId)).rejects.toMatchObject({ details: { code: 'E-TRN-04' } });
    await expect(mark(MARKER, entryId)).resolves.toMatchObject({ valid: true });
  });

  it('INSIDE 번역은 다른 팬덤 회원도 마킹한다(Q-TR-04 권고 B안) · 가입 24시간은 그대로', async () => {
    const { entryId } = await submit(AUTHOR, 'Hello fandom');
    await expect(mark(NEWBIE, entryId)).rejects.toMatchObject({ details: { code: 'E-TRN-04' } });
    await expect(mark(OUTSIDER, entryId)).resolves.toMatchObject({ valid: true });
  });

  it('운영값을 끄면(A안) INSIDE 도 그 팬덤 멤버만 마킹한다', async () => {
    const policy = getFirestore().doc('config/policy');
    const before = await policy.get();
    await policy.set({ translationInsideAnyMember: false }, { merge: true });
    try {
      const { entryId } = await submit(AUTHOR, 'Hello fandom');
      await expect(mark(OUTSIDER, entryId)).rejects.toMatchObject({ details: { code: 'E-TRN-04' } });
    } finally {
      if (before.exists) await policy.set(before.data()!);
      else await policy.delete();
    }
  });

  it('팬덤 멤버 문서가 있으면 users.fandomId 가 달라도 마킹할 수 있다', async () => {
    const { entryId } = await submit(AUTHOR, 'Hello fandom', POST);
    await getFirestore().doc(`fandoms/trn-f1/members/${OUTSIDER}`).set({ uid: OUTSIDER });
    await expect(mark(OUTSIDER, entryId)).resolves.toMatchObject({ valid: true });
    await getFirestore().doc(`fandoms/trn-f1/members/${OUTSIDER}`).delete();
  });
});

describe('번역 정산', () => {
  it('유효 마킹 1건 이상이면 예약이 사용 가능으로 옮겨지고 대사가 맞는다', async () => {
    const { entryId } = await submit(AUTHOR, 'Hello fandom');
    await mark(MARKER, entryId);
    await age(entryId, 25);
    await settle();
    expect((await getFirestore().doc(`translationEntries/${entryId}`).get()).get('status')).toBe('confirmed');
    const w = await wallet(AUTHOR);
    expect(w.activityBalance).toBe(5);
    expect(w.pendingActivity).toBe(0);
    expect((await reconcileUser(AUTHOR)).ok).toBe(true);
  });

  it('24시간 전이거나 마킹이 모자라면 pending 을 유지한다', async () => {
    const { entryId } = await submit(AUTHOR, 'Hello fandom');
    await settle();
    await age(entryId, 25);
    await settle();
    expect((await getFirestore().doc(`translationEntries/${entryId}`).get()).get('status')).toBe('pending');
    expect((await wallet(AUTHOR)).pendingActivity).toBe(5);
  });

  it('최대 대기(72시간)를 넘기면 예약을 해제하고 excluded 로 닫는다', async () => {
    const { entryId } = await submit(AUTHOR, 'Hello fandom');
    await age(entryId, 73);
    await settle();
    const entry = await getFirestore().doc(`translationEntries/${entryId}`).get();
    expect(entry.get('status')).toBe('excluded');
    expect(entry.get('excludedReason')).toBe('unverified');
    const w = await wallet(AUTHOR);
    expect(w.activityBalance ?? 0).toBe(0);
    expect(w.pendingActivity).toBe(0);
    expect((await reconcileUser(AUTHOR)).ok).toBe(true);
  });

  it('보상 0 건은 예약 없이 excluded 로 닫는다', async () => {
    await submit(AUTHOR, 'Hello fandom');
    const { entryId } = await submit(COPIER, 'Hello fandom');
    await age(entryId, 25);
    await settle();
    expect((await getFirestore().doc(`translationEntries/${entryId}`).get()).get('status')).toBe('excluded');
    expect((await wallet(COPIER)).activityBalance ?? 0).toBe(0);
  });
});

describe('보류 지급 정산 — settlePendingGrant', () => {
  const key = 'trn:ledger-unit';

  it('확정은 한 번뿐이고, 확정 뒤 해제 요청은 기존 결과를 돌려준다', async () => {
    await grantPop({ uid: AUTHOR, popType: 'activity', amount: 7, reasonCode: 'TRANSLATION', idempotencyKey: key, pending: true });
    await settlePendingGrant({ uid: AUTHOR, idempotencyKey: key, outcome: 'confirm' });
    await settlePendingGrant({ uid: AUTHOR, idempotencyKey: key, outcome: 'release' });
    const w = await wallet(AUTHOR);
    expect(w.activityBalance).toBe(7);
    expect(w.pendingActivity).toBe(0);
    expect((await reconcileUser(AUTHOR)).ok).toBe(true);
  });

  it('보류가 아닌 지급은 정산할 수 없다', async () => {
    await grantPop({ uid: AUTHOR, popType: 'activity', amount: 7, reasonCode: 'TRANSLATION', idempotencyKey: `${key}:x` });
    await expect(settlePendingGrant({ uid: AUTHOR, idempotencyKey: `${key}:x`, outcome: 'confirm' }))
      .rejects.toMatchObject({ details: { code: 'E-POP-02' } });
  });
});

describe('캠페인 응원 게시판 댓글 번역', () => {
  const OPEN = 'campaigns/test-trn-c2';
  const DRAFT = 'campaigns/test-trn-c3';
  beforeEach(async () => {
    const db = getFirestore();
    const old = await db.collection('translationEntries')
      .where('targetPath', '==', `${OPEN}/comments/ok`).get();
    await Promise.all(old.docs.map((d) => d.ref.delete()));
    await Promise.all([
      db.doc(OPEN).set({ status: 'funding', fandomId: 'trn-f1' }),
      db.doc(`${OPEN}/comments/ok`).set({ body: '응원', visibility: 'visible' }),
      db.doc(`${OPEN}/comments/hidden`).set({ body: '숨김', visibility: 'hidden' }),
      db.doc(DRAFT).set({ status: 'review', fandomId: 'trn-f1' }),
      db.doc(`${DRAFT}/comments/ok`).set({ body: '응원', visibility: 'visible' }),
    ]);
  });

  it('공개 캠페인의 보이는 댓글에만 달고, 루트는 캠페인이다', async () => {
    const { entryId } = await submit(AUTHOR, 'Cheer', `${OPEN}/comments/ok`);
    const entry = await getFirestore().doc(`translationEntries/${entryId}`).get();
    expect(entry.get('rootPath')).toBe(OPEN);
    expect(entry.get('fandomId')).toBe('trn-f1');
    for (const path of [`${OPEN}/comments/hidden`, `${DRAFT}/comments/ok`, `${OPEN}/comments/none`]) {
      await expect(submit(AUTHOR, 'x', path)).rejects.toMatchObject({ details: { code: 'E-TRN-03' } });
    }
  });
});