import { getLacuna } from '../__utils__/get-lacuna';
import { expectMatchesApiSchema } from '../__utils__/validate-schema';
import Lacuna from '../lacuna';

let lacuna: Lacuna;
let stats: string | undefined;

beforeAll(async () => {
  lacuna = await getLacuna();

  // Try to fetch the stats json and if it doesn't exist (ie, local dev, freshly deployed server)
  // then we can skip these tests.
  stats = await fetch(lacuna.config.serverUrl + 'server/server_overview.json', {
    method: 'GET',
  })
    .then((res) => (res.statusText === 'OK' ? res.text() : undefined))
    .catch(() => undefined);
});

test('credits', async () => {
  const { result } = await lacuna.stats.credits();

  expect(result).toBeDefined();
  expect(result![0]['Game Design']).toStrictEqual(['JT Smith', 'Jamie Vrbsky']);
  expectMatchesApiSchema('stats', 'credits', result);
});

test('empireRank', async () => {
  const { result } = await lacuna.stats.empireRank();

  expect(result?.empires.length).toBeGreaterThan(0);
  expect(result?.total_empires).toEqual(expect.any(Number));
  expect(result?.page_number).toEqual(expect.any(Number));
  expectMatchesApiSchema('stats', 'empire_rank', result);
});

test('findEmpireRank', async () => {
  const { result } = await lacuna.stats.findEmpireRank({
    sort_by: 'empire_size_rank',
    empire_name: process.env.LACUNA_TEST_EMPIRE_NAME,
  });

  expect(result?.empires[0].empire_name).toBe(process.env.LACUNA_TEST_EMPIRE_NAME);
  expectMatchesApiSchema('stats', 'find_empire_rank', result);
});

test.skip('allianceRank', async () => {
  // `sort_by` is optional per the spec, but the server's own default sort
  // errors out - see README "Spec Discrepancies".
  const { result } = await lacuna.stats.allianceRank({ sort_by: 'average_empire_size_rank' });

  expect(result?.alliances.length).toBeGreaterThan(0);
  expect(result?.total_alliances).toEqual(expect.any(Number));
  expectMatchesApiSchema('stats', 'alliance_rank', result);
});

test.skip('allianceRank with the default sort', async () => {
  const { error } = await lacuna.stats.allianceRank({} as never);

  // Documents the server-side bug the test above works around: with no
  // `sort_by` the ranking blows up inside Lacuna::RPC::Stats.
  expect(error).toBeDefined();
});

test.skip('findAllianceRank', async () => {
  const { result } = await lacuna.stats.findAllianceRank({
    sort_by: 'average_empire_size_rank',
    alliance_name: 'Sluts United',
  });

  expect(result?.alliances[0].alliance_name).toBe('Sluts United');
  expectMatchesApiSchema('stats', 'find_alliance_rank', result);
});

test('colonyRank', async () => {
  const { result } = await lacuna.stats.colonyRank();

  expect(result?.colonies.length).toBeGreaterThan(0);
  expectMatchesApiSchema('stats', 'colony_rank', result);
});

test('spyRank', async () => {
  const { result } = await lacuna.stats.spyRank();

  expect(result?.spies.length).toBeGreaterThan(0);
  expectMatchesApiSchema('stats', 'spy_rank', result);
});

test('weeklyMedalWinners', async () => {
  const { result } = await lacuna.stats.weeklyMedalWinners();

  expect(result?.winners.length).toBeGreaterThan(0);
  expectMatchesApiSchema('stats', 'weekly_medal_winners', result);
});

// server_overview is a static JSON file, not a JSON-RPC method, so there's no
// spec path to validate against - just assert the fetch + fixNumbers pipeline.
test('serverOverview', async () => {
  if (stats === undefined) {
    console.warn('Skipping: could not load server_overview.json');
    return;
  }

  const { result, error } = await lacuna.stats.serverOverview();

  expect(error).toBeUndefined();
  expect(result?.empires?.count).toEqual(expect.any(Number));
  expect(result?.buildings?.count).toEqual(expect.any(Number));
  // fixNumbers coerces the stringified `average_level` values the server sends.
  const someBuilding = Object.values(result?.buildings?.types ?? {})[0];
  if (someBuilding?.average_level !== undefined) {
    expect(typeof someBuilding.average_level).toBe('number');
  }
});