const test = require('node:test');
const assert = require('node:assert/strict');

require('../src/common');

const originalWebBaseUrl = process.env.WEB_INTERNAL_URL;
const { resolveWebBaseUrl, resolveScreenCommandTargets, resolveSnapshotUpstreamBaseUrl, resolvePlayerSocketForDeviceId } = require('../src/player-bridge/index');

test.after(() => {
  if (originalWebBaseUrl === undefined) {
    delete process.env.WEB_INTERNAL_URL;
  } else {
    process.env.WEB_INTERNAL_URL = originalWebBaseUrl;
  }
});

test('resolveWebBaseUrl prefers WEB_INTERNAL_URL', () => {
  process.env.WEB_INTERNAL_URL = 'https://web.example.test/app/';

  const resolved = resolveWebBaseUrl({
    headers: {
      host: 'bridge.example.test',
      'x-forwarded-host': 'bridge.example.test',
      'x-forwarded-proto': 'https'
    },
    socket: { encrypted: true }
  });

  assert.equal(resolved, 'https://web.example.test/app');
});

test('resolveWebBaseUrl keeps external https hosts on the default port', () => {
  delete process.env.WEB_INTERNAL_URL;

  const resolved = resolveWebBaseUrl({
    headers: {
      host: 'bridge.example.test',
      'x-forwarded-host': 'bridge.example.test',
      'x-forwarded-proto': 'https'
    },
    socket: { encrypted: true }
  });

  assert.equal(resolved, 'https://bridge.example.test');
});

test('resolveScreenCommandTargets only returns open sockets for the requested screen', () => {
  const playerSockets = new Map([
    ['player-a', { readyState: 1 }],
    ['player-b', { readyState: 3 }],
    ['player-c', { readyState: 1 }]
  ]);
  const screenPlayerDeviceIds = new Map([
    ['demo-conference', ['player-a', 'player-b', 'player-a', 'player-missing']],
    ['other-screen', ['player-c']]
  ]);

  const targets = resolveScreenCommandTargets('demo-conference', playerSockets, screenPlayerDeviceIds);

  assert.deepEqual(targets.map(function (target) {
    return target.deviceId;
  }), ['player-a']);
});

test('resolveScreenCommandTargets falls back to a single open socket when the screen map is empty', () => {
  const playerSockets = new Map([
    ['player-a', { readyState: 1, playerDeviceId: 'player-a' }]
  ]);
  const screenPlayerDeviceIds = new Map();

  const targets = resolveScreenCommandTargets('demo-conference', playerSockets, screenPlayerDeviceIds);

  assert.deepEqual(targets.map(function (target) {
    return target.deviceId;
  }), ['player-a']);
});

test('resolveSnapshotUpstreamBaseUrl prefers a local internal player url', () => {
  assert.equal(resolveSnapshotUpstreamBaseUrl({
    public_base_url: 'https://pulse-dev-player.lzstealth.com',
    internal_base_url: 'http://player-dev:8081'
  }), 'http://player-dev:8081');
});

test('resolveSnapshotUpstreamBaseUrl falls back to the public player url for remote players', () => {
  assert.equal(resolveSnapshotUpstreamBaseUrl({
    public_base_url: 'https://remote-player.example',
    internal_base_url: 'https://pulse-dev-bridge.lzstealth.com'
  }), 'https://remote-player.example');
});

test('resolvePlayerSocketForDeviceId only returns the exact connected player socket', () => {
  const playerSocketA = { readyState: 1 };
  const playerSocketB = { readyState: 1 };
  const playerSockets = new Map([
    ['player-a', playerSocketA],
    ['player-b', playerSocketB]
  ]);

  assert.equal(resolvePlayerSocketForDeviceId(playerSockets, 'player-b'), playerSocketB);
  assert.equal(resolvePlayerSocketForDeviceId(playerSockets, 'player-missing'), null);
});