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

import { bootAdmin, shutdownAdmin, wipeUser } from './support.js';
import {
  fnFandomJoin, fnFandomLeave, fnNebulaCreate, fnPlanetCreate, fnPrimaryFandomSet, isValidNebulaName,
} from '../src/account/account.js';

/** 성운 생성 → 가입 · 대표 팬덤 → 행성 탄생 — 원장 B-08 · B-09 · B-10 · C-15 · C-50. */
const UID = 'test-planet-create';
const OTHER = 'test-planet-create-other';
const db = () => getFirestore();

/** 이 파일이 만든 것만 지운다 — 같은 에뮬레이터를 쓰는 다른 테스트의 문서를 건드리지 않는다. */
const created = { fandoms: new Set<string>(), names: new Set<string>() };

async function call(fn: { run(request: never): unknown }, data: Record<string, unknown>, uid = UID) {
  const out = (await fn.run({ data, auth: { uid, token: {} } } as unknown as never)) as Record<string, unknown>;
  if (fn === fnNebulaCreate) {
    created.fandoms.add(out.fandomId as string);
    created.names.add(String(data.name).toLowerCase());
  }
  return out;
}

async function codeOf(run: () => Promise<unknown>): Promise<string> {
  try {
    await run();
  } catch (error) {
    return (error as { details?: { code?: string } }).details?.code ?? (error as { code?: string }).code ?? '?';
  }
  throw new Error('실패해야 하는 호출이 성공했습니다.');
}

const user = async (uid = UID) => (await db().doc(`users/${uid}`).get()).data() ?? {};
const fandom = async (id: string) => (await db().doc(`fandoms/${id}`).get()).data() ?? {};

beforeAll(() => { bootAdmin(); });
afterAll(async () => { await shutdownAdmin(); });
afterEach(async () => {
  for (const uid of [UID, OTHER]) {
    await wipeUser(uid);
    await db().recursiveDelete(db().collection(`users/${uid}/nebulaCreates`));
    await db().recursiveDelete(db().collection(`users/${uid}/memberships`));
    await db().doc(`users/${uid}`).delete();
  }
  for (const id of created.fandoms) await db().recursiveDelete(db().doc(`fandoms/${id}`));
  for (const name of created.names) await db().doc(`fandomNames/${name}`).delete();
  created.fandoms.clear();
  created.names.clear();
});

describe('성운 생성', () => {
  it('Stage0 공용 성운을 만들고 만든 사람이 창립 멤버 #001 · 대표 팬덤이 된다', async () => {
    const { fandomId, primaryChanged } = await call(fnNebulaCreate, { name: 'BTS RM' });
    const f = await fandom(fandomId as string);
    expect(f).toMatchObject({ name: 'BTS RM', stage: 0, founderUid: UID, memberCount: 1, growthPop: 0 });
    expect(f.nebulaDeadline.toMillis() - Date.now()).toBeGreaterThan(6.9 * 86_400_000);
    expect((await db().doc(`fandoms/${fandomId}/members/${UID}`).get()).get('memberNo')).toBe(1);
    expect((await db().doc(`users/${UID}/memberships/${fandomId}`).get()).exists).toBe(true);
    expect(primaryChanged).toBe(true);
    expect(await user()).toMatchObject({ primaryFandomId: fandomId, fandomId });
  });

  it('대표 변경 30일 대기 중이면 성운 · 멤버십만 만들고 대표는 그대로 둔다(C-15)', async () => {
    await db().doc(`users/${UID}`).set({
      primaryFandomId: 'old', fandomId: 'old', primaryChangedAt: Timestamp.fromMillis(Date.now() - 86_400_000),
    });
    const { fandomId, primaryChanged } = await call(fnNebulaCreate, { name: 'Cooldown' });
    expect(primaryChanged).toBe(false);
    expect(await user()).toMatchObject({ primaryFandomId: 'old', fandomId: 'old' });
    expect((await db().doc(`fandoms/${fandomId}/members/${UID}`).get()).exists).toBe(true);
  });

  it('같은 이름(대소문자 무시)은 E-FDM-01 · 하루 두 번째 생성은 E-FDM-02', async () => {
    await call(fnNebulaCreate, { name: 'Aurora' });
    expect(await codeOf(() => call(fnNebulaCreate, { name: 'aurora' }, OTHER))).toBe('E-FDM-01');
    expect(await codeOf(() => call(fnNebulaCreate, { name: 'Borealis' }))).toBe('E-FDM-02');
  });

  it('이름 규칙 — 2~20자 · 한글/영문/숫자/공백 · 연속·앞뒤 공백 불가', () => {
    expect(isValidNebulaName('방탄 소년단1')).toBe(true);
    for (const bad of ['A', ' AB', 'AB ', 'A  B', 'AB!', 'x'.repeat(21)]) {
      expect(isValidNebulaName(bad)).toBe(false);
    }
  });
});

describe('가입 · 탈퇴 · 대표 팬덤', () => {
  it('두 번 가입해도 한 번만 센다 · 탈퇴도 한 번만 내린다 · 첫 가입 팬덤이 대표가 된다', async () => {
    const { fandomId } = await call(fnNebulaCreate, { name: 'Joinable' });
    const id = fandomId as string;
    expect((await call(fnFandomJoin, { fandomId: id }, OTHER)).joined).toBe(true);
    expect((await call(fnFandomJoin, { fandomId: id }, OTHER)).joined).toBe(false);
    expect(await fandom(id)).toMatchObject({ memberCount: 2, memberSeq: 2 });
    expect((await db().doc(`fandoms/${id}/members/${OTHER}`).get()).get('memberNo')).toBe(2);
    expect(await user(OTHER)).toMatchObject({ primaryFandomId: id });

    expect((await call(fnFandomLeave, { fandomId: id }, OTHER)).left).toBe(true);
    expect((await call(fnFandomLeave, { fandomId: id }, OTHER)).left).toBe(false);
    expect((await fandom(id)).memberCount).toBe(1);
    expect(await user(OTHER)).toMatchObject({ primaryFandomId: null, fandomId: '' });
    expect((await db().doc(`users/${OTHER}/memberships/${id}`).get()).exists).toBe(false);
    // LIVE 집계용 가입 목록 비정규화 — 가입 · 탈퇴 트랜잭션이 함께 유지한다.
    expect((await user(OTHER)).fandomIds).toEqual([]);
    expect((await user()).fandomIds).toEqual([id]);
  });

  it('없는 팬덤 가입 · 가입하지 않은 팬덤을 대표로 지정은 거부한다', async () => {
    expect(await codeOf(() => call(fnFandomJoin, { fandomId: 'missing-fandom' }))).toBe('E-PERM-01');
    const { fandomId } = await call(fnNebulaCreate, { name: 'NotMine' }, OTHER);
    expect(await codeOf(() => call(fnPrimaryFandomSet, { fandomId }))).toBe('E-PERM-01');
  });

  it('대표 변경은 무료 · 30일 안 재변경은 E-FDM-04 · 대기가 지나면 허용', async () => {
    const a = (await call(fnNebulaCreate, { name: 'Primary A' }, OTHER)).fandomId as string;
    await call(fnFandomJoin, { fandomId: a });
    // 대표가 없던 계정의 첫 지정(가입)은 변경이 아니라 대기 시각을 찍지 않는다.
    expect((await user()).primaryChangedAt).toBeUndefined();
    // 성운 생성 = 대표 변경(A → B). 여기서 대기가 시작된다.
    const b = (await call(fnNebulaCreate, { name: 'Primary B' })).fandomId as string;
    expect(await user()).toMatchObject({ primaryFandomId: b });
    expect((await user()).primaryChangedAt).toBeInstanceOf(Timestamp);
    expect(await codeOf(() => call(fnPrimaryFandomSet, { fandomId: a }))).toBe('E-FDM-04');

    await db().doc(`users/${UID}`).update({ primaryChangedAt: Timestamp.fromMillis(Date.now() - 31 * 86_400_000) });
    expect((await call(fnPrimaryFandomSet, { fandomId: a })).changed).toBe(true);
    expect(await user()).toMatchObject({ primaryFandomId: a, fandomId: a });
  });
});

describe('창립자 탈퇴 승계 · 대표 팬덤 자동 지정(원장 C-100 · C-101 · S20)', () => {
  const setPolicy = (patch: Record<string, unknown>) => db().doc('config/policy').set(patch, { merge: true });
  const THIRD = 'test-planet-create-third';
  afterEach(async () => {
    await db().doc('config/policy').set({ primaryOnLeave: FieldValue.delete() }, { merge: true });
    await wipeUser(THIRD);
    await db().recursiveDelete(db().collection(`users/${THIRD}/memberships`));
    await db().recursiveDelete(db().collection(`users/${OTHER}/notifications`));
    await db().recursiveDelete(db().collection(`users/${THIRD}/notifications`));
  });

  it('탄생 전 창립자 탈퇴 허용 → 가장 먼저 가입한 남은 멤버가 탄생 권한자 · 알림 · 이전 창립자 탄생 거부 · 순번 비재사용', async () => {
    const id = (await call(fnNebulaCreate, { name: 'Founder Go' })).fandomId as string;
    await call(fnFandomJoin, { fandomId: id }, OTHER);
    await call(fnFandomJoin, { fandomId: id }, THIRD);
    // 가입 시각을 OTHER < THIRD 로 못박는다.
    await db().doc(`fandoms/${id}/members/${OTHER}`).update({ joinedAt: Timestamp.fromMillis(Date.now() - 2 * 86_400_000) });
    await db().doc(`fandoms/${id}/members/${THIRD}`).update({ joinedAt: Timestamp.fromMillis(Date.now() - 86_400_000) });

    const out = await call(fnFandomLeave, { fandomId: id });
    expect(out).toMatchObject({ left: true, founderUid: OTHER });
    expect(await fandom(id)).toMatchObject({ founderUid: OTHER, memberCount: 2, memberSeq: 3 });
    const notes = await db().collection(`users/${OTHER}/notifications`).get();
    expect(notes.docs.map((d) => d.get('title'))).toEqual(['「Founder Go」 성운의 행성 탄생 권한을 이어받았어요.']);

    await db().doc(`fandoms/${id}`).update({ memberCount: 10, growthPop: 1_000 });
    const pick = { fandomId: id, planetType: 'shape1', colorKey: 'blue' };
    expect(await codeOf(() => call(fnPlanetCreate, pick))).toBe('E-PERM-01');

    // 떠난 창립자가 다시 가입해도 #001 이 아니라 다음 순번(#4)을 받는다.
    await call(fnFandomJoin, { fandomId: id });
    expect((await db().doc(`fandoms/${id}/members/${UID}`).get()).get('memberNo')).toBe(4);
    expect((await fandom(id)).founderUid).toBe(OTHER);
    await call(fnPlanetCreate, pick, OTHER);
    expect((await fandom(id)).stage).toBe(1);
  });

  it('창립자 혼자인 성운 — 탈퇴 허용 · 성운 유지 · 탄생 권한은 비웠다가 다음 가입자에게(S20)', async () => {
    const id = (await call(fnNebulaCreate, { name: 'Founder Alone' })).fandomId as string;
    expect(await call(fnFandomLeave, { fandomId: id })).toMatchObject({ left: true, founderUid: null });
    expect(await fandom(id)).toMatchObject({ stage: 0, memberCount: 0, founderUid: null, name: 'Founder Alone' });

    await call(fnFandomJoin, { fandomId: id }, OTHER);
    expect((await fandom(id)).founderUid).toBe(OTHER);
    // 이미 권한자가 있으면 다음 가입자는 이어받지 않는다.
    await call(fnFandomJoin, { fandomId: id }, THIRD);
    expect((await fandom(id)).founderUid).toBe(OTHER);
  });

  it('탄생 뒤 창립자 탈퇴는 탄생 권한을 건드리지 않는다', async () => {
    const id = (await call(fnNebulaCreate, { name: 'Founder Born' })).fandomId as string;
    await call(fnFandomJoin, { fandomId: id }, OTHER);
    await db().doc(`fandoms/${id}`).update({ stage: 1 });
    expect(await call(fnFandomLeave, { fandomId: id })).not.toHaveProperty('founderUid');
    expect((await fandom(id)).founderUid).toBe(UID);
    expect((await db().collection(`users/${OTHER}/notifications`).get()).empty).toBe(true);
  });

  /** A(대표) · B · C 에 가입 — 가입 시각은 B < C 로 못박는다. */
  async function joinThree(): Promise<[string, string, string]> {
    const ids: string[] = [];
    for (const name of ['leave-a', 'leave-b', 'leave-c']) {
      // 성운 생성은 하루 1회라 정식 행성 문서를 직접 둔다.
      const id = `test-planet-create-${name}`;
      await db().doc(`fandoms/${id}`).set({ name, stage: 1, founderUid: OTHER, memberCount: 0 });
      created.fandoms.add(id);
      await call(fnFandomJoin, { fandomId: id });
      ids.push(id);
    }
    const [a, b, c] = ids as [string, string, string];
    await db().doc(`users/${UID}/memberships/${b}`).update({ joinedAt: Timestamp.fromMillis(Date.now() - 2 * 86_400_000) });
    await db().doc(`users/${UID}/memberships/${c}`).update({ joinedAt: Timestamp.fromMillis(Date.now() - 86_400_000) });
    expect(await user()).toMatchObject({ primaryFandomId: a });
    return [a, b, c];
  }

  it('대표 팬덤을 떠나면 가장 최근 가입 팬덤이 대표 · 대기에 세지 않는다 · 남은 팬덤이 없으면 비운다', async () => {
    const [a, b, c] = await joinThree();
    expect((await call(fnFandomLeave, { fandomId: a })).primaryFandomId).toBe(c);
    expect(await user()).toMatchObject({ primaryFandomId: c, fandomId: c });
    expect((await user()).primaryChangedAt).toBeUndefined();
    // 자동 지정 직후에도 사용자가 바로 바꿀 수 있다.
    expect((await call(fnPrimaryFandomSet, { fandomId: b })).changed).toBe(true);

    await call(fnFandomLeave, { fandomId: c }); // 대표가 아니면 대표는 그대로
    expect(await user()).toMatchObject({ primaryFandomId: b });
    await call(fnFandomLeave, { fandomId: b });
    expect(await user()).toMatchObject({ primaryFandomId: null, fandomId: '' });
  });

  it('primaryOnLeave — earliest 는 가장 먼저 가입한 팬덤 · none 은 비워 둔다', async () => {
    const [a, b] = await joinThree();
    await setPolicy({ primaryOnLeave: 'earliest' });
    await call(fnFandomLeave, { fandomId: a });
    expect(await user()).toMatchObject({ primaryFandomId: b });
    await setPolicy({ primaryOnLeave: 'none' });
    await call(fnFandomLeave, { fandomId: b });
    expect(await user()).toMatchObject({ primaryFandomId: null });
  });
});

describe('행성 탄생', () => {
  async function nebula(members: number, pop: number): Promise<string> {
    const { fandomId } = await call(fnNebulaCreate, { name: `N${members}x${pop}` });
    await db().doc(`fandoms/${fandomId}`).update({ memberCount: members, growthPop: pop });
    return fandomId as string;
  }
  const pick = (fandomId: string) => ({ fandomId, planetType: 'shape2', colorKey: 'gold' });

  it('없는 성운은 거부 · 한쪽 조건만 채우면 E-FDM-03(B-10)', async () => {
    expect(await codeOf(() => call(fnPlanetCreate, pick('missing-nebula')))).toBe('E-PERM-01');
    const id = await nebula(9, 5_000);
    expect(await codeOf(() => call(fnPlanetCreate, pick(id)))).toBe('E-FDM-03');
    await db().doc(`fandoms/${id}`).update({ memberCount: 10, growthPop: 999 });
    expect(await codeOf(() => call(fnPlanetCreate, pick(id)))).toBe('E-FDM-03');
  });

  it('7일 목표는 설정이 켜졌을 때만 막는다(nebulaConversionDeadlineEnforced)', async () => {
    const id = await nebula(10, 1_000);
    await db().doc(`fandoms/${id}`).update({ nebulaDeadline: Timestamp.fromMillis(Date.now() - 1_000) });
    await db().doc('config/policy').set({ nebulaConversionDeadlineEnforced: true }, { merge: true });
    try {
      expect(await codeOf(() => call(fnPlanetCreate, pick(id)))).toBe('E-FDM-03');
    } finally {
      await db().doc('config/policy').update({ nebulaConversionDeadlineEnforced: FieldValue.delete() });
    }
    await call(fnPlanetCreate, pick(id));
    expect((await fandom(id)).stage).toBe(1);
  });

  it('10명 + 1,000 POP 이면 Stage1 이 되고 형태·컬러는 한 번만 저장된다(C-50)', async () => {
    const id = await nebula(10, 1_000);
    expect(await codeOf(() => call(fnPlanetCreate, pick(id), OTHER))).toBe('E-PERM-01');
    await call(fnPlanetCreate, pick(id));
    expect(await fandom(id)).toMatchObject({ stage: 1, planetType: 'shape2', colorKey: 'gold' });
    expect((await db().doc(`fandoms/${id}/planets/planet`).get()).get('ownerUid')).toBe(UID);
    // 두 번째 생성(= 외형 변경 시도)은 거부된다.
    expect(await codeOf(() => call(fnPlanetCreate, { ...pick(id), colorKey: 'red' }))).toBe('E-POP-03');
  });

  it('팔레트 밖 형태·색은 받지 않는다', async () => {
    const id = await nebula(10, 1_000);
    expect(await codeOf(() => call(fnPlanetCreate, { ...pick(id), colorKey: '#123456' })))
      .toBe('invalid-argument');
  });
});