// Route screen refresh commands to the physical player hosting each screen.

function createNotifyPlayerScreens(forwardPlayerCommand, getScreenConnections, forwardPlayerCommandToBaseUrl, resolvePlayerBaseUrl, forwardPlayerCommandToDevice) {
  if (typeof forwardPlayerCommand !== 'function') {
    throw new Error('createNotifyPlayerScreens requires a player command sender.');
  }

  return function notifyPlayerScreens(slugs, commandOrPayload) {
    const uniqueSlugs = Array.from(new Set((slugs || []).map(function (slug) {
      return String(slug || '').trim();
    }).filter(Boolean)));

    if (!uniqueSlugs.length) {
      return Promise.resolve(0);
    }

    return Promise.allSettled(uniqueSlugs.map(async function (slug) {
      // A screen may have connections on multiple players after a remote move or reconnect.
      if (typeof getScreenConnections === 'function' && typeof forwardPlayerCommandToBaseUrl === 'function') {
        const screenState = await getScreenConnections(slug);
        const connections = Array.isArray(screenState && screenState.connections) ? screenState.connections : [];
        const deviceIds = Array.from(new Set(connections.map(function (connection) {
          return String(connection && connection.playerDeviceId || '').trim();
        }).filter(Boolean)));
        const playerBaseUrls = Array.from(new Set(connections.map(function (connection) {
          if (String(connection && connection.playerDeviceId || '').trim()) {
            return '';
          }
          return String(connection && connection.playerPublicBaseUrl || '').trim().replace(/\/$/, '');
        }).filter(Boolean)));
        const deviceResults = deviceIds.length && typeof forwardPlayerCommandToDevice === 'function'
          ? await Promise.all(deviceIds.map(function (deviceId) {
            return forwardPlayerCommandToDevice(deviceId, {
              command: commandOrPayload || 'refresh',
              screenSlug: slug
            });
          }))
          : [];
        let baseUrlResults = [];
        if (playerBaseUrls.length) {
          const resolvedPlayerBaseUrls = typeof resolvePlayerBaseUrl === 'function'
            ? await Promise.all(playerBaseUrls.map(function (playerBaseUrl) { return resolvePlayerBaseUrl(playerBaseUrl); }))
            : playerBaseUrls;
          baseUrlResults = await Promise.all(resolvedPlayerBaseUrls.filter(Boolean).map(function (playerBaseUrl) {
            return forwardPlayerCommandToBaseUrl(playerBaseUrl, slug, commandOrPayload || 'refresh');
          }));
        }
        if (deviceResults.length || baseUrlResults.length) {
          return deviceResults.concat(baseUrlResults);
        }
      }
      return forwardPlayerCommand(slug, commandOrPayload || 'refresh');
    })).then(function (results) {
      const successful = results.filter(function (result) {
        return result.status === 'fulfilled' && (!result.value || result.value.ok !== false);
      }).length;
      return successful;
    });
  };
}

module.exports = { createNotifyPlayerScreens };