import { afterAll, beforeAll, describe, expect, it } from 'vitest';

import {
    createGamePostgresConnector,
    type GamePrisma,
    type GamePrismaClient,
} from '@sammo-ts/infra';

import { createDatabaseTurnHooks } from '../src/turn/databaseHooks.js';
import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
import { loadTurnWorldFromDatabase } from '../src/turn/worldLoader.js';

const databaseUrl = process.env.SELECT_POOL_DATABASE_URL;
const integration = describe.skipIf(!databaseUrl);
const generalId = 990_904;
const cityId = 990_904;
const scenarioCode = 'select-pool-release-integration';

const assertDedicatedDatabase = (rawUrl: string): void => {
    const schema = new URL(rawUrl).searchParams.get('schema');
    if (!schema?.endsWith('select_pool_integration')) {
        throw new Error(`Refusing to mutate non-dedicated schema: ${schema ?? '(missing)'}`);
    }
};

integration('select pool release during general deletion', () => {
    let db: GamePrismaClient;
    let closeDb: (() => Promise<void>) | undefined;

    beforeAll(async () => {
        assertDedicatedDatabase(databaseUrl!);
        const connector = createGamePostgresConnector({ url: databaseUrl! });
        await connector.connect();
        db = connector.prisma;
        closeDb = () => connector.disconnect();

        await db.$executeRawUnsafe('DROP TABLE IF EXISTS "select_pool_delete_blocker"');
        await db.selectPoolEntry.deleteMany({
            where: { uniqueName: 'release-candidate' },
        });
        await db.general.deleteMany({ where: { id: generalId } });
        await db.city.deleteMany({ where: { id: cityId } });
        await db.worldState.deleteMany({ where: { scenarioCode } });

        await db.worldState.create({
            data: {
                scenarioCode,
                currentYear: 180,
                currentMonth: 1,
                tickSeconds: 300,
                config: {
                    npcMode: 2,
                    turnTermMinutes: 5,
                    stat: {
                        total: 165,
                        min: 15,
                        max: 80,
                        npcTotal: 165,
                        npcMax: 80,
                        npcMin: 15,
                        chiefMin: 40,
                    },
                    iconPath: '.',
                    map: {
                        targetGeneralPool: 'SPoolUnderU30',
                        generalPoolAllowOption: ['ego'],
                    },
                    const: {},
                    environment: {
                        mapName: 'che',
                        unitSet: 'che',
                    },
                },
                meta: {
                    hiddenSeed: 'select-pool-release-seed',
                    killturn: 5,
                    turntime: '2026-07-30T12:00:00.000Z',
                },
            },
        });
        await db.city.create({
            data: {
                id: cityId,
                name: '해제성',
                level: 5,
                nationId: 0,
                population: 10_000,
                populationMax: 20_000,
                agriculture: 1_000,
                agricultureMax: 2_000,
                commerce: 1_000,
                commerceMax: 2_000,
                security: 1_000,
                securityMax: 2_000,
                defence: 1_000,
                defenceMax: 2_000,
                wall: 1_000,
                wallMax: 2_000,
                region: 1,
            },
        });
        await db.general.create({
            data: {
                id: generalId,
                userId: 'select-pool-release-user',
                name: '해제대상',
                nationId: 0,
                cityId,
                troopId: 0,
                npcState: 0,
                affinity: 1,
                bornYear: 160,
                deadYear: 240,
                picture: 'default.jpg',
                imageServer: 0,
                leadership: 50,
                strength: 50,
                intel: 50,
                experience: 2_000,
                dedication: 2_000,
                officerLevel: 0,
                turnTime: new Date('2026-07-30T12:01:00.000Z'),
                age: 20,
                startAge: 20,
                personalCode: 'che_안전',
                specialCode: 'che_event_신산',
                special2Code: 'che_무쌍',
                meta: {
                    killturn: 5,
                    dex1: 100_000,
                    dex2: 100_000,
                    dex3: 100_000,
                    dex4: 100_000,
                    dex5: 100_000,
                },
            },
        });
        await db.selectPoolEntry.create({
            data: {
                uniqueName: 'release-candidate',
                ownerUserId: null,
                generalId,
                reservedUntil: null,
                info: {
                    uniqueName: 'release-candidate',
                    generalName: '해제대상',
                    leadership: 50,
                    strength: 50,
                    intel: 50,
                    specialDomestic: 'che_event_신산',
                    dex: [100_000, 100_000, 100_000, 100_000, 100_000],
                    imgsvr: 0,
                    picture: 'default.jpg',
                } as GamePrisma.InputJsonValue,
            },
        });
    });

    afterAll(async () => {
        if (!db) {
            await closeDb?.();
            return;
        }
        await db.$executeRawUnsafe('DROP TABLE IF EXISTS "select_pool_delete_blocker"');
        await db.selectPoolEntry.deleteMany({
            where: { uniqueName: 'release-candidate' },
        });
        await db.general.deleteMany({ where: { id: generalId } });
        await db.city.deleteMany({ where: { id: cityId } });
        await db.worldState.deleteMany({ where: { scenarioCode } });
        await closeDb?.();
    });

    it('round-trips independent event-domestic and war trait slots through a dirty flush', async () => {
        const loaded = await loadTurnWorldFromDatabase({ databaseUrl: databaseUrl! });
        const world = new InMemoryTurnWorld(loaded.state, loaded.snapshot, {
            schedule: { entries: [{ startMinute: 0, tickMinutes: 5 }] },
        });
        const before = world.getGeneralById(generalId);
        expect(before?.role).toMatchObject({
            specialDomestic: 'che_event_신산',
            specialWar: 'che_무쌍',
        });
        expect(world.updateGeneral(generalId, { gold: (before?.gold ?? 0) + 1 })).not.toBeNull();

        const hooks = await createDatabaseTurnHooks(databaseUrl!, world);
        try {
            await hooks.hooks.flushChanges?.({
                lastTurnTime: loaded.state.lastTurnTime.toISOString(),
                processedGenerals: 0,
                processedTurns: 0,
                durationMs: 0,
                partial: false,
            });
        } finally {
            await hooks.close();
        }

        await expect(db.general.findUniqueOrThrow({ where: { id: generalId } })).resolves.toMatchObject({
            specialCode: 'che_event_신산',
            special2Code: 'che_무쌍',
        });
        const reloaded = await loadTurnWorldFromDatabase({ databaseUrl: databaseUrl! });
        expect(
            reloaded.snapshot.generals.find((general) => general.id === generalId)?.role
        ).toMatchObject({
            specialDomestic: 'che_event_신산',
            specialWar: 'che_무쌍',
        });
    });

    it('rolls back a failed flush, then releases all Ref fields before deleting the general', async () => {
        const loaded = await loadTurnWorldFromDatabase({ databaseUrl: databaseUrl! });
        const world = new InMemoryTurnWorld(loaded.state, loaded.snapshot, {
            schedule: { entries: [{ startMinute: 0, tickMinutes: 5 }] },
        });
        expect(world.removeGeneral(generalId)).toBe(true);

        const hooks = await createDatabaseTurnHooks(databaseUrl!, world);
        try {
            await db.$executeRawUnsafe(`
                CREATE TABLE "select_pool_delete_blocker" (
                    "general_id" INTEGER PRIMARY KEY
                        REFERENCES "general"("id") ON DELETE RESTRICT
                )
            `);
            await db.$executeRawUnsafe(
                `INSERT INTO "select_pool_delete_blocker" ("general_id") VALUES (${generalId})`
            );

            await expect(
                hooks.hooks.flushChanges?.({
                    lastTurnTime: loaded.state.lastTurnTime.toISOString(),
                    processedGenerals: 0,
                    processedTurns: 0,
                    durationMs: 0,
                    partial: false,
                })
            ).rejects.toThrow();
            await expect(db.general.findUnique({ where: { id: generalId } })).resolves.not.toBeNull();
            await expect(
                db.selectPoolEntry.findUniqueOrThrow({
                    where: { uniqueName: 'release-candidate' },
                })
            ).resolves.toMatchObject({
                generalId,
                ownerUserId: null,
                reservedUntil: null,
            });

            await db.$executeRawUnsafe('DROP TABLE "select_pool_delete_blocker"');
            await hooks.hooks.flushChanges?.({
                lastTurnTime: loaded.state.lastTurnTime.toISOString(),
                processedGenerals: 0,
                processedTurns: 0,
                durationMs: 0,
                partial: false,
            });

            await expect(db.general.findUnique({ where: { id: generalId } })).resolves.toBeNull();
            await expect(
                db.selectPoolEntry.findUniqueOrThrow({
                    where: { uniqueName: 'release-candidate' },
                })
            ).resolves.toMatchObject({
                generalId: null,
                ownerUserId: null,
                reservedUntil: null,
            });
        } finally {
            await hooks.close();
        }
    });
});