import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { PartyService } from '../src/services/PartyService';

describe('PartyService', () => {
  it('create() sets mediaType and seeds the host as the first member', () => {
    const party = PartyService.create('u-alice', 'Alice', 'ep1', 'S01E01 - Pilote', '/img/ep1', [
      { itemId: 'ep1', itemName: 'S01E01 - Pilote', itemImageUrl: '/img/ep1' },
      { itemId: 'ep2', itemName: 'S01E02 - Suite', itemImageUrl: '/img/ep2' }
    ], 'video');

    assert.equal(party.mediaType, 'video');
    assert.equal(party.members.size, 1);
    assert.equal(party.hostUserId, 'u-alice');
    assert.equal(party.burnInSubtitleIndex, null, 'no burn-in stream until the host picks one');
    assert.equal(party.burnInAudioIndex, null);
  });

  it('advanceQueue moves through the fixed queue and stops at the end', () => {
    const party = PartyService.create('u-alice', 'Alice', 'ep1', 'S01E01', '/img/ep1', [
      { itemId: 'ep1', itemName: 'S01E01', itemImageUrl: '/img/ep1' },
      { itemId: 'ep2', itemName: 'S01E02', itemImageUrl: '/img/ep2' }
    ], 'video');

    assert.equal(PartyService.advanceQueue(party), true);
    assert.equal(party.itemId, 'ep2');
    assert.equal(PartyService.advanceQueue(party), false, 'nothing left after the last item');
  });

  it('advanceQueue clears the party\'s burn-in choice - a new item\'s stream indices mean nothing on the old one', () => {
    const party = PartyService.create('u-alice', 'Alice', 'ep1', 'S01E01', '/img/ep1', [
      { itemId: 'ep1', itemName: 'S01E01', itemImageUrl: '/img/ep1' },
      { itemId: 'ep2', itemName: 'S01E02', itemImageUrl: '/img/ep2' }
    ], 'video');
    party.burnInSubtitleIndex = '4';
    party.burnInAudioIndex = '2';

    PartyService.advanceQueue(party);

    assert.equal(party.burnInSubtitleIndex, null);
    assert.equal(party.burnInAudioIndex, null);
  });

  it('leave(): a non-host leaving neither destroys the party nor hands off', () => {
    const party = PartyService.create('u-alice', 'Alice', 'm1', 'Un Film', '/img/m1', null, 'video');
    PartyService.join(party, 'u-bob', 'Bob');

    const result = PartyService.leave(party, 'u-bob');
    assert.equal(result.destroyed, false);
    assert.equal(result.hostChanged, false);
  });

  it('leave(): the host leaving with someone left hands off, and party.hostUserId actually updates', () => {
    const party = PartyService.create('u-alice', 'Alice', 'm1', 'Un Film', '/img/m1', null, 'video');
    PartyService.join(party, 'u-bob', 'Bob');

    const result = PartyService.leave(party, 'u-alice');
    assert.equal(result.hostChanged, true);
    assert.equal(result.newHostUserId, 'u-bob');
    assert.equal(party.hostUserId, 'u-bob');
  });

  it('leave(): the last member leaving destroys the party', () => {
    const party = PartyService.create('u-alice', 'Alice', 'm1', 'Un Film', '/img/m1', null, 'video');

    const result = PartyService.leave(party, 'u-alice');
    assert.equal(result.destroyed, true);
    assert.equal(PartyService.getById(party.id), null);
  });

  it('join() is idempotent: re-joining an existing member returns it as-is instead of resetting it', () => {
    const party = PartyService.create('u-alice', 'Alice', 'm1', 'Un Film', '/img/m1', null, 'video');
    const bob = PartyService.join(party, 'u-bob', 'Bob');
    bob.isPaused = false;
    bob.positionTicks = 12345;
    bob.deviceId = 'device-1';

    // The REST "Rejoindre" route (and a second device/tab's socket "join")
    // call this every time regardless of whether the caller is already a
    // member - this must not reset any of the live state just set above
    // (see this method's own comment for the crash that used to cause).
    const bobAgain = PartyService.join(party, 'u-bob', 'Bob');
    assert.equal(bobAgain, bob, 'must be the exact same member object, not a fresh one');
    assert.equal(bobAgain.isPaused, false, 'a re-join must not reset live state');
    assert.equal(bobAgain.positionTicks, 12345);
    assert.equal(bobAgain.deviceId, 'device-1');
    assert.equal(party.members.size, 2, 'still exactly one entry for bob, not a duplicate');
  });

  it('removeIdleParties sweeps a party whose lastActivityUtc is past the cutoff', () => {
    const party = PartyService.create('u-dave', 'Dave', 'm1', 'Un Film', '/img/m1', null, 'video');
    party.lastActivityUtc = Date.now() - 5 * 60 * 60 * 1000;

    PartyService.removeIdleParties(4 * 60 * 60 * 1000);
    assert.equal(PartyService.getById(party.id), null);
  });

  it('toPublicState reports youAreHost for the creator, and music:null for a video party', () => {
    const party = PartyService.create('u-eve', 'Eve', 'm2', 'Un Autre Film', '/img/m2', null, 'video');
    const state = PartyService.toPublicState(party, 'u-eve');

    assert.equal(state.youAreHost, true);
    assert.equal(state.music, null);
  });

  it('toPublicState exposes the party\'s current burn-in choice - a late joiner\'s getParty must see it too', () => {
    const party = PartyService.create('u-eve', 'Eve', 'm2', 'Un Autre Film', '/img/m2', null, 'video');
    party.burnInSubtitleIndex = '4';
    party.burnInAudioIndex = '2';

    const state = PartyService.toPublicState(party, 'u-eve');

    assert.equal(state.burnInSubtitleIndex, '4');
    assert.equal(state.burnInAudioIndex, '2');
  });
});