const test = require('node:test');
const assert = require('node:assert/strict');
const { setup, teardown, cleanup } = require('../helpers');

// Simple cookie jar for tests
function createJar() {
  return { cookies: [] };
}

function jarSet(jar, res) {
  const cookies = res.headers['set-cookie'];
  if (cookies && cookies.length) {
    jar.cookies = cookies.map((c) => c.split(';')[0]);
  }
}

function jarGet(jar) {
  return jar.cookies.join('; ');
}

function fetchJson(base, path, options = {}) {
  return new Promise((resolve, reject) => {
    const url = new URL(path, base);
    const opts = {
      method: options.method || 'GET',
      headers: {
        'Content-Type': 'application/json',
        ...(options.cookie ? { Cookie: options.cookie } : {}),
      },
    };
    const req = require('node:http').request(url, opts, (res) => {
      let data = '';
      res.on('data', (c) => { data += c; });
      res.on('end', () => {
        resolve({
          status: res.statusCode,
          headers: res.headers,
          body: data ? JSON.parse(data) : null,
        });
      });
    });
    req.on('error', reject);
    if (options.body) req.write(JSON.stringify(options.body));
    req.end();
  });
}

test('10.4 /api/auth/me returns username before and after hero creation', async () => {
  const baseUrl = await setup();
  const jar = createJar();
  try {
    // Register
    const regRes = await fetchJson(baseUrl, '/api/auth/register', {
      method: 'POST',
      body: { username: 'meuser', password: 'password123' },
    });
    assert.equal(regRes.status, 201);
    assert.equal(regRes.body.ok, true);
    assert.equal(regRes.body.data.user.username, 'meuser');
    jarSet(jar, regRes);

    // /me before hero: hasHero should be false, username should be 'meuser'
    const meRes1 = await fetchJson(baseUrl, '/api/auth/me', {
      cookie: jarGet(jar),
    });
    assert.equal(meRes1.status, 200);
    assert.equal(meRes1.body.ok, true);
    assert.equal(meRes1.body.data.user.username, 'meuser');
    assert.equal(meRes1.body.data.hasHero, false);

    // Create a hero
    const charRes = await fetchJson(baseUrl, '/api/character', {
      method: 'POST',
      cookie: jarGet(jar),
      body: { name: 'MyHero', class: 'warrior' },
    });
    assert.equal(charRes.status, 201);

    // /me after hero: hasHero should be true, username still 'meuser'
    const meRes2 = await fetchJson(baseUrl, '/api/auth/me', {
      cookie: jarGet(jar),
    });
    assert.equal(meRes2.status, 200);
    assert.equal(meRes2.body.ok, true);
    assert.equal(meRes2.body.data.user.username, 'meuser');
    assert.equal(meRes2.body.data.hasHero, true);
  } finally {
    await teardown();
    cleanup();
  }
});

test('10.4 /api/auth/login returns username and hasHero', async () => {
  const baseUrl = await setup();
  try {
    // Register + login without hero
    await fetchJson(baseUrl, '/api/auth/register', {
      method: 'POST',
      body: { username: 'logintest2', password: 'password123' },
    });
    const loginRes1 = await fetchJson(baseUrl, '/api/auth/login', {
      method: 'POST',
      body: { username: 'logintest2', password: 'password123' },
    });
    assert.equal(loginRes1.status, 200);
    assert.equal(loginRes1.body.ok, true);
    assert.equal(loginRes1.body.data.user.username, 'logintest2');
    assert.equal(loginRes1.body.data.hasHero, false);

    // Login again after creating a hero
    const jar = createJar();
    jarSet(jar, loginRes1);
    await fetchJson(baseUrl, '/api/character', {
      method: 'POST',
      cookie: jarGet(jar),
      body: { name: 'HeroTwo', class: 'mage' },
    });

    // Re-login to get fresh session
    const loginRes2 = await fetchJson(baseUrl, '/api/auth/login', {
      method: 'POST',
      body: { username: 'logintest2', password: 'password123' },
    });
    assert.equal(loginRes2.status, 200);
    assert.equal(loginRes2.body.ok, true);
    assert.equal(loginRes2.body.data.user.username, 'logintest2');
    assert.equal(loginRes2.body.data.hasHero, true);
  } finally {
    await teardown();
    cleanup();
  }
});

test('10.4 /api/auth/me returns non-empty username after register', async () => {
  const baseUrl = await setup();
  const jar = createJar();
  try {
    const regRes = await fetchJson(baseUrl, '/api/auth/register', {
      method: 'POST',
      body: { username: 'nonemptyuser', password: 'password123' },
    });
    assert.equal(regRes.status, 201);
    jarSet(jar, regRes);

    const meRes = await fetchJson(baseUrl, '/api/auth/me', {
      cookie: jarGet(jar),
    });
    assert.equal(meRes.status, 200);
    assert.ok(meRes.body.data.user.username.length > 0, 'username should be non-empty');
    assert.equal(meRes.body.data.user.username, 'nonemptyuser');
  } finally {
    await teardown();
    cleanup();
  }
});