import { describe, expect, it } from 'vitest';
import type { DialogueGraph, TileMapData } from '@rpg/engine';
import { TILES, buildMeadowsMap, buildPondsMap, buildZvenetsMap } from '../map';
import { AREAS } from '../locations';
import { validateContent, validateDialogue, validateLocations, validateNpcs } from '../validate';

/** Карта целиком из проходимой травы (или с одиночной стеной). */
function flatMap(w: number, h: number, wall?: { x: number; y: number }): TileMapData {
    const tiles = new Array(w * h).fill(TILES.GRASS);
    if (wall) tiles[wall.y * w + wall.x] = TILES.HOUSE;
    return { width: w, height: h, tiles, blocked: [TILES.WATER, TILES.TREE, TILES.TOWER, TILES.HOUSE] };
}

/** Карты всех локаций (как их грузит BootScene). */
function realMaps(): Map<string, TileMapData> {
    return new Map([
        ['meadows', buildMeadowsMap()],
        ['ponds', buildPondsMap()],
        ['zvenets', buildZvenetsMap()]
    ]);
}

describe('validateContent — реальный контент чист', () => {
    it('ошибок нет (warn допустим)', () => {
        const errs = validateContent(realMaps()).filter((i) => i.severity === 'error');
        expect(errs).toEqual([]);
    });
});

describe('validateDialogue', () => {
    it('битый start и битый next — ошибки', () => {
        const g: DialogueGraph = {
            start: 'нет',
            nodes: {
                a: { text: 'a', next: 'нет2' },
                b: { text: 'b', choices: [{ text: 'x', next: 'нет3' }] }
            }
        };
        const ids = validateDialogue('test', g).map((i) => i.id);
        expect(ids).toContain('dialogue-start');
        expect(ids).toContain('dialogue-next');
    });

    it('узел-сирота — warn, связный граф чист', () => {
        const ok: DialogueGraph = { start: 'a', nodes: { a: { text: 'a', next: 'b' }, b: { text: 'b', end: true } } };
        expect(validateDialogue('ok', ok)).toEqual([]);
        const orphan: DialogueGraph = { start: 'a', nodes: { a: { text: 'a', end: true }, dead: { text: 'x', end: true } } };
        expect(validateDialogue('orphan', orphan).map((i) => i.id)).toEqual(['dialogue-orphan']);
    });
});

describe('validateNpcs', () => {
    it('проходимая карта без NPC в стенах — чисто; стена под NPC ловится', () => {
        const maps = new Map([['zvenets', flatMap(28, 20)]]);
        expect(validateNpcs(maps)).toEqual([]);
        // NPCS статичен — подменяем карту: стена на тайле Ирвина даст 'in-wall'.
        const elder = AREAS.zvenets.npcs[0]!;
        const walled = new Map([['zvenets', flatMap(28, 20, { x: elder.tile.x, y: elder.tile.y })]]);
        const inv = validateNpcs(walled);
        expect(inv.some((i) => i.id === 'in-wall' && i.message.includes(elder.id))).toBe(true);
    });
});

describe('validateLocations', () => {
    it('переход в несуществующую область — ошибки target нет, guard на карту', () => {
        const maps = new Map([['meadows', flatMap(28, 28)]]);
        // AREAS статичен; проверяем чистую функцию через реальные данные:
        // meadows -> ponds/zvenets существуют, но их карт в maps нет —
        // guard на отсутствующую карту не роняет проверку.
        const inv = validateLocations(maps);
        expect(inv.every((i) => i.severity === 'warn' || i.where?.includes('meadows'))).toBe(true);
    });

    it('спавн в стене ловится', () => {
        const spawn = AREAS.meadows.spawn;
        const maps = new Map([['meadows', flatMap(28, 28, spawn)]]);
        const inv = validateLocations(maps);
        expect(inv.some((i) => i.id === 'in-wall' && i.message.includes('spawn'))).toBe(true);
    });
});