// End-to-end "Definition of playable" flow — NOTES.md §7.
// register → log in → create hero → see stats/energy → hunt → gain XP/gold/loot → level up → equip → buy/sell shop → start+claim expedition → leaderboard → log out → log back in → persistence check.
const { describe, it, before, after } = require('node:test');
const assert = require('node:assert/strict');
const fs = require('fs');
const path = require('path');
const os = require('os');

describe('e2e: Definition of playable', () => {
  let BASE, cookie, userSeq = 0;
  let db, tmpDir, srv;

  before(async () => {
    process.env.NODE_ENV = 'test';

    // Manual setup matching helpers.js pattern
    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'emberfall-e2e-'));
    const dbPath = path.join(tmpDir, 'e2e.db');
    process.env.DB_PATH = dbPath;

    // Clear require cache for all src/ and scripts/
    const root = path.resolve(__dirname, '..');
    for (const id of Object.keys(require.cache)) {
      if (id.startsWith(path.join(root, '..') + path.sep) || id.startsWith(path.join(root, '../scripts') + path.sep)) {
        delete require.cache[id];
      }
    }

    const { runMigrations } = require('../../scripts/migrate');
    runMigrations();

    const dbModule = require('../../src/db');
    db = dbModule.getDb();

    const { createApp } = require('../../src/app');
    const app = createApp();

    const port = await new Promise((resolve, reject) => {
      srv = app.listen(0, () => resolve(srv.address().port));
      srv.on('error', reject);
    });
    BASE = `http://localhost:${port}`;

    // Seed a trivial zone/monster for guaranteed wins (hero always wins).
    db.prepare(`INSERT OR IGNORE INTO zones (id, slug, name, description, min_level, energy_cost) VALUES (999, 't-e2e', 'Test Zone', 'e2e', 1, 10)`).run();
    db.prepare(`INSERT OR IGNORE INTO monsters (id, zone_id, name, level, hp, attack, defense, speed, xp, gold_min, gold_max, weight) VALUES (999, 999, 'Slime', 1, 10, 1, 0, 1, 100, 5, 10, 100)`).run();
    // Get a stackable item for loot drops
    const lootItem = db.prepare('SELECT id FROM items WHERE stackable = 1 LIMIT 1').get();
    if (lootItem) {
      db.prepare('INSERT INTO loot_table (monster_id, item_id, chance_pct, qty_min, qty_max) VALUES (?, ?, 100, 1, 1)').run(999, lootItem.id);
    }
  });

  after(async () => {
    try { db.close(); } catch (_) {}
    try {
      await new Promise((r) => { if (srv) srv.close(r); else r(); });
    } catch (_) {}
    try { fs.rmSync(tmpDir, { recursive: true }); } catch (_) {}
  });

  async function api(path, opts = {}) {
    const headers = { 'Content-Type': 'application/json', ...(opts.headers || {}) };
    if (cookie && !opts.noCookie) headers['Cookie'] = cookie;
    const res = await fetch(`${BASE}${path}`, {
      method: opts.method || 'GET',
      headers,
      body: opts.body ? JSON.stringify(opts.body) : undefined,
      redirect: 'manual',
    });
    const setCookie = res.headers.get('set-cookie');
    if (setCookie) cookie = setCookie.split(';')[0];
    const ct = res.headers.get('content-type') || '';
    let data;
    if (ct.includes('application/json')) data = await res.json();
    else data = await res.text();
    return { status: res.status, data, headers: res.headers };
  }

  async function registerAndLogin(username, password) {
    const r1 = await api('/api/auth/register', { method: 'POST', body: { username, password } });
    assert.ok([200, 201].includes(r1.status), `register ${username}: ${JSON.stringify(r1.data)}`);
    const r2 = await api('/api/auth/login', { method: 'POST', body: { username, password } });
    assert.equal(r2.status, 200, `login ${username}: ${JSON.stringify(r2.data)}`);
    return cookie;
  }

  async function loginOnly(username, password) {
    const r = await api('/api/auth/login', { method: 'POST', body: { username, password } });
    assert.equal(r.status, 200, `login ${username}: ${JSON.stringify(r.data)}`);
    return cookie;
  }

  it('full playable flow: register → login → create hero → stats → hunt → level → equip → shop → expedition → leaderboard → logout → login → persistence', async () => {
    userSeq += 1;
    const username = `e2euser${userSeq}`;
    const password = 'password123';
    const heroName = `Hero${userSeq}`;

    // 1. REGISTER
    // 2. LOGIN
    await registerAndLogin(username, password);

    // 3. CREATE HERO
    const createRes = await api('/api/character', { method: 'POST', body: { name: heroName, class: 'warrior' } });
    assert.ok([200, 201].includes(createRes.status), `create hero: ${JSON.stringify(createRes.data)}`);
    assert.ok(createRes.data.ok);
    const charId = createRes.data.data.id;

    // 4. SEE STATS/ENERGY
    const charRes = await api('/api/character');
    assert.equal(charRes.status, 200);
    assert.ok(charRes.data.ok);
    const charData = charRes.data.data;
    assert.equal(charData.character.name, heroName);
    assert.equal(charData.character.class, 'warrior');
    assert.ok(charData.energy.current != null, 'Should have energy');
    assert.ok(charData.derived != null, 'Should have derived stats');
    assert.ok(charData.derived.maxHp != null, 'Should have maxHp');

    // 5. HUNT (hero should win against slime)
    const huntRes = await api('/api/hunt', { method: 'POST', body: { zoneId: 999 } });
    assert.equal(huntRes.status, 200, `hunt: ${JSON.stringify(huntRes.data)}`);
    assert.ok(huntRes.data.ok);
    const huntData = huntRes.data.data;
    assert.equal(huntData.winner, 'hero', 'Hero should win');
    assert.ok(huntData.rounds && huntData.rounds.length > 0, 'Should have rounds');
    assert.ok(huntData.xpGained > 0, 'Should gain XP');
    assert.ok(huntData.goldGained >= 0, 'Should gain gold');

    // 6. HUNT MORE TO ACCUMULATE XP (100 XP needed to level 1→2)
    let leveledUp = false;
    for (let i = 0; i < 6; i++) {
      const h2 = await api('/api/hunt', { method: 'POST', body: { zoneId: 999 } });
      assert.equal(h2.status, 200, `hunt #${i}: ${JSON.stringify(h2.data)}`);
      assert.ok(h2.data.ok);
      if (h2.data.data.leveledUp) leveledUp = true;
    }
    // Verify XP increased
    const charAfter = await api('/api/character');
    assert.ok(charAfter.data.data.character.xp >= 0, 'XP should be >= 0');

    // 7. CHECK INVENTORY (should have loot)
    const invRes = await api('/api/inventory');
    assert.equal(invRes.status, 200);
    assert.ok(invRes.data.ok);

    // 8. EQUIP ITEM (if we have unequipped equipment items, equip to weapon slot)
    const invData = invRes.data.data.items || [];
    if (invData.length > 0) {
      const unequipped = invData.find((item) => !item.equipped && item.type !== 'consumable');
      if (unequipped) {
        const equipRes = await api('/api/inventory/equip', { method: 'POST', body: { itemId: unequipped.itemId, slot: unequipped.slot || 'weapon' } });
        assert.equal(equipRes.status, 200, `equip: ${JSON.stringify(equipRes.data)}`);
        const inv2 = await api('/api/inventory');
        const equippedItem = inv2.data.data.items.find((i) => i.inventoryId === unequipped.inventoryId);
        assert.ok(equippedItem && equippedItem.equipped, 'Item should now be equipped');
      }
    }

    // 9. BUY FROM SHOP
    const shopRes = await api('/api/shop');
    assert.equal(shopRes.status, 200);
    assert.ok(shopRes.data.ok);
    const stock = shopRes.data.data.stock || [];
    const heroGold = charAfter.data.data.character.gold || 0;
    if (stock.length > 0) {
      const buyable = stock.find((s) => s.buyPrice <= heroGold);
      if (buyable) {
        const buyRes = await api('/api/shop/buy', { method: 'POST', body: { itemId: buyable.itemId, quantity: 1 } });
        assert.equal(buyRes.status, 200, `buy: ${JSON.stringify(buyRes.data)}`);
        assert.ok(buyRes.data.ok, `Buy should succeed: ${JSON.stringify(buyRes.data)}`);
      }
    }

    // 10. SELL AN ITEM VIA SHOP (if we have material-type items)
    const invAfterBuy = await api('/api/inventory');
    const itemsToSell = (invAfterBuy.data.data.items || []).filter((item) => !item.equipped && item.type === 'material');
    if (itemsToSell.length > 0) {
      // POST /api/shop/sell requires { itemId, quantity }
      const sellRes = await api('/api/shop/sell', { method: 'POST', body: { itemId: itemsToSell[0].itemId, quantity: 1 } });
      assert.ok([200, 400].includes(sellRes.status), `sell status ${sellRes.status}: ${JSON.stringify(sellRes.data)}`);
    }

    // 11. START + CLAIM EXPEDITION
    const expDefs = await api('/api/expeditions/defs');
    assert.equal(expDefs.status, 200);
    const defs = expDefs.data.data || [];
    let activeExpId = null;
    if (defs.length > 0) {
      const startRes = await api('/api/expeditions/start', { method: 'POST', body: { defId: defs[0].id } });
      assert.equal(startRes.status, 200, `start expedition: ${JSON.stringify(startRes.data)}`);
      assert.ok(startRes.data.ok);
      activeExpId = startRes.data.data.expedition.id;

      // Check active
      const activeRes = await api('/api/expeditions/active');
      assert.equal(activeRes.status, 200);
      assert.ok(activeRes.data.ok);
      assert.ok(activeRes.data.data != null, 'Should have active expedition');

      // Fast-forward time past ends_at by updating the expedition in DB
      if (activeExpId) {
        const time = require('../../src/utils/time');
        // Set ends_at to 10 minutes ago
        db.prepare('UPDATE expeditions SET ends_at = ? WHERE id = ?').run(time.now() - 600_000, activeExpId);
      }

      // Claim
      const claimRes = await api('/api/expeditions/claim', { method: 'POST', body: { expeditionId: activeExpId } });
      assert.equal(claimRes.status, 200, `claim expedition: ${JSON.stringify(claimRes.data)}`);
      assert.ok(claimRes.data.ok);

      // Verify no active expedition left
      const activeAfter = await api('/api/expeditions/active');
      assert.equal(activeAfter.status, 200);
      assert.ok(activeAfter.data.data == null, 'No active expedition after claim');
    }

    // 12. SEE LEADERBOARD (level, gold, kills)
    const lbLevel = await api('/api/leaderboard?type=level');
    assert.equal(lbLevel.status, 200);
    assert.ok(lbLevel.data.ok);
    assert.ok(Array.isArray(lbLevel.data.data.entries), 'Level leaderboard should have entries array');

    const lbGold = await api('/api/leaderboard?type=gold');
    assert.equal(lbGold.status, 200);
    assert.ok(lbGold.data.ok);

    const lbKills = await api('/api/leaderboard?type=kills');
    assert.equal(lbKills.status, 200);
    assert.ok(lbKills.data.ok);

    // 13. LOG OUT
    const logoutRes = await api('/api/auth/logout', { method: 'POST' });
    assert.equal(logoutRes.status, 200);

    // 14. LOG BACK IN (just login, not register)
    await loginOnly(username, password);

    // 15. VERIFY PERSISTENCE
    const charPersist = await api('/api/character');
    assert.equal(charPersist.status, 200);
    assert.equal(charPersist.data.data.character.name, heroName);
    assert.equal(charPersist.data.data.character.class, 'warrior');
    assert.ok(charPersist.data.data.energy.current >= 0, 'Energy should have regenerated');
    assert.ok(charPersist.data.data.character.gold >= 0, 'Gold should be non-negative');
    assert.ok(charPersist.data.data.character.xp >= 0, 'XP should persist');
  });
});