import 'reflect-metadata';
import { getMetadataArgsStorage } from 'typeorm';
import { Combat } from '../../combat/entities/combat.entity';
import { HuntEncounter } from '../../hunting/entities/hunt-encounter.entity';
import { HuntEncounterStatus } from '../../hunting/hunt-encounter-status.enum';

describe('encounter status schema', () => {
  it('stores the encounter status as a non-nullable enum on hunt_encounters', () => {
    const metadata = getMetadataArgsStorage();
    const column = metadata.columns.find(
      (candidate) =>
        candidate.target === HuntEncounter &&
        candidate.propertyName === 'status',
    );

    expect(column).toBeDefined();
    expect(column?.options.type).toBe('enum');
    expect(column?.options.enum).toBe(HuntEncounterStatus);
    expect(column?.options.enumName).toBe('hunt_encounter_status_enum');
    expect(column?.options.nullable).toBeFalsy();
  });

  it('drops consumedAt, whose gate the encounter status replaces', () => {
    const metadata = getMetadataArgsStorage();
    const column = metadata.columns.find(
      (candidate) =>
        candidate.target === HuntEncounter &&
        candidate.propertyName === 'consumedAt',
    );

    expect(column).toBeUndefined();
  });

  it('allows repeated combats per encounter so a lost fight can be retried', () => {
    const metadata = getMetadataArgsStorage();
    const index = metadata.indices.find(
      (candidate) =>
        candidate.target === Combat &&
        candidate.columns?.includes('huntEncounterId'),
    );

    expect(index).toBeDefined();
    const indexMetadata = index as typeof index & {
      options?: { unique?: boolean };
      unique?: boolean;
    };
    expect(indexMetadata?.options?.unique ?? indexMetadata?.unique).toBeFalsy();
  });
});