import assert from 'node:assert/strict';
import test from 'node:test';
import Fastify from 'fastify';
import type { Db } from 'mongodb';
import { registerGameApi, registerRoomApi } from '../src/server/game-api.js';
import type { GameSessionStore } from '../src/server/game-session-store.js';
import { createRankedService } from '../src/server/ranked-service.js';
import type { RoomStore } from '../src/server/rooms.js';
import type { Signaling } from '../src/server/signaling.js';
import { ManualClock } from './helpers.js';

function deferred() {
  let resolve!: () => void;
  const promise = new Promise<void>(done => { resolve = done; });
  return { promise, resolve };
}

// Only the persistence boundary is fake. Queue ownership, serialization, pairing,
// availability checks and HTTP routing all run through the production code.
function memoryDatabase(now: number) {
  const records: Record<string, Record<string, any>[]> = {
    game_sessions: [
      { _id: 'session-a', playerId: 'player-a', expiresAt: new Date(now + 60000) },
      { _id: 'session-b', playerId: 'player-b', expiresAt: new Date(now + 60000) },
    ],
    player_profiles: [], ranked_matches: [], rooms: [],
  };
  const matches = (doc: Record<string, any>, query: Record<string, any> = {}) =>
    Object.entries(query).every(([key, value]) => {
      if (value && typeof value === 'object' && '$gt' in value) return doc[key] > value.$gt;
      if (value && typeof value === 'object' && '$in' in value) {
        return (Array.isArray(doc[key]) ? doc[key] : [doc[key]]).some(item => value.$in.includes(item));
      }
      return Array.isArray(doc[key]) ? doc[key].includes(value) : doc[key] === value;
    });
  const db = { collection(name: string) {
    const data = records[name];
    return {
      async createIndex() {},
      async findOne(query: Record<string, any>) { return data.find(doc => matches(doc, query)) ?? null; },
      find(query?: Record<string, any>) {
        const rows = data.filter(doc => matches(doc, query));
        return {
          sort() { return this; }, limit() { return this; },
          async next() { return rows[0] ?? null; }, async toArray() { return rows; },
          async *[Symbol.asyncIterator]() { yield* rows; },
        };
      },
      async updateOne(query: Record<string, any>, update: Record<string, any>) {
        const doc = data.find(row => matches(row, query));
        if (doc) Object.assign(doc, update.$set ?? {});
        else data.push({ ...query, ...update.$setOnInsert, ...update.$set });
      },
    };
  } } as unknown as Db;
  return { db, records };
}

for (const url of ['/api/game-session/matches', '/api/rooms', '/api/rooms/join']) {
  test(`${url} reserves the player until its write completes before ranked pairing`, { timeout: 5000 }, async () => {
    const clock = new ManualClock(), { db, records } = memoryDatabase(clock.now());
    const ranked = await createRankedService(db, clock, 'test'), app = Fastify();
    const entered = deferred(), release = deferred();
    const regularMatch = { matchId: 'bot-match', requestId: 'request-a', mode: 'bot', expectedPreviousSeq: 0 };
    const room = { id: 'friend-room' };
    const write = async () => {
      entered.resolve();
      await release.promise;
      if (url === '/api/game-session/matches') records.game_sessions[0].activeMatch = regularMatch;
      else records.rooms.push({ _id: room.id, members: ['session-a'], open: true, expiresAt: new Date(clock.now() + 60000) });
      return url === '/api/game-session/matches' ? regularMatch : room;
    };
    const sessions = {
      async get() { return { gameSessionId: 'session-a', playerId: 'player-a' }; },
      register: write,
    } as unknown as GameSessionStore;
    const rooms = { create: write, join: write } as unknown as RoomStore;
    registerGameApi(app, sessions, undefined, ranked);
    registerRoomApi(app, sessions, rooms, { async notifyRoom() {} } as unknown as Signaling, ranked);
    try {
      await ranked.join('player-b', 'session-b');
      const regular = app.inject({ method: 'POST', url,
        headers: { authorization: `Bearer ${'a'.repeat(43)}`, 'x-game-session': 'session-a' },
        payload: url === '/api/game-session/matches' ? regularMatch : { requestId: 'request-a', code: 'ABCDEF' },
      }).then(response => response);
      await entered.promise;
      const pairing = ranked.join('player-a', 'session-a').then(
        status => ({ status, error: undefined }), error => ({ status: undefined, error }),
      );
      // Drain queued work while the regular-mode write is explicitly held open.
      // With the old check-then-write guard, ranked pairing completes in this gap.
      await new Promise<void>(resolve => setImmediate(resolve));
      release.resolve();
      assert.equal((await regular).statusCode, 200);
      const outcome = await pairing;
      assert.equal(outcome.error?.code, 'MATCH_PENDING', `ranked entered during the write: ${outcome.status?.status}`);
      assert.equal((await ranked.status('player-b', 'session-b')).status, 'queued');
    } finally {
      release.resolve();
      await app.close(); await ranked.close();
    }
  });
}