/* eslint-disable @typescript-eslint/member-ordering */
import { Injectable, inject } from '@angular/core';
import { ServerDirectoryService } from '../services/server-directory.service';

@Injectable({ providedIn: 'root' })
export class ServerDirectoryFacade {
  private readonly service = inject(ServerDirectoryService);

  readonly servers = this.service.servers;
  readonly activeServers = this.service.activeServers;
  readonly hasMissingDefaultServers = this.service.hasMissingDefaultServers;
  readonly activeServer = this.service.activeServer;

  awaitInitialServerHealthCheck(
    ...args: Parameters<ServerDirectoryService['awaitInitialServerHealthCheck']>
  ): ReturnType<ServerDirectoryService['awaitInitialServerHealthCheck']> {
    return this.service.awaitInitialServerHealthCheck(...args);
  }

  addServer(
    ...args: Parameters<ServerDirectoryService['addServer']>
  ): ReturnType<ServerDirectoryService['addServer']> {
    return this.service.addServer(...args);
  }

  ensureServerEndpoint(
    ...args: Parameters<ServerDirectoryService['ensureServerEndpoint']>
  ): ReturnType<ServerDirectoryService['ensureServerEndpoint']> {
    return this.service.ensureServerEndpoint(...args);
  }

  findServerByUrl(
    ...args: Parameters<ServerDirectoryService['findServerByUrl']>
  ): ReturnType<ServerDirectoryService['findServerByUrl']> {
    return this.service.findServerByUrl(...args);
  }

  removeServer(
    ...args: Parameters<ServerDirectoryService['removeServer']>
  ): ReturnType<ServerDirectoryService['removeServer']> {
    return this.service.removeServer(...args);
  }

  restoreDefaultServers(
    ...args: Parameters<ServerDirectoryService['restoreDefaultServers']>
  ): ReturnType<ServerDirectoryService['restoreDefaultServers']> {
    return this.service.restoreDefaultServers(...args);
  }

  setActiveServer(
    ...args: Parameters<ServerDirectoryService['setActiveServer']>
  ): ReturnType<ServerDirectoryService['setActiveServer']> {
    return this.service.setActiveServer(...args);
  }

  deactivateServer(
    ...args: Parameters<ServerDirectoryService['deactivateServer']>
  ): ReturnType<ServerDirectoryService['deactivateServer']> {
    return this.service.deactivateServer(...args);
  }

  updateServerStatus(
    ...args: Parameters<ServerDirectoryService['updateServerStatus']>
  ): ReturnType<ServerDirectoryService['updateServerStatus']> {
    return this.service.updateServerStatus(...args);
  }

  ensureEndpointVersionCompatibility(
    ...args: Parameters<ServerDirectoryService['ensureEndpointVersionCompatibility']>
  ): ReturnType<ServerDirectoryService['ensureEndpointVersionCompatibility']> {
    return this.service.ensureEndpointVersionCompatibility(...args);
  }

  resolveRoomEndpoint(
    ...args: Parameters<ServerDirectoryService['resolveRoomEndpoint']>
  ): ReturnType<ServerDirectoryService['resolveRoomEndpoint']> {
    return this.service.resolveRoomEndpoint(...args);
  }

  normaliseRoomSignalSource(
    ...args: Parameters<ServerDirectoryService['normaliseRoomSignalSource']>
  ): ReturnType<ServerDirectoryService['normaliseRoomSignalSource']> {
    return this.service.normaliseRoomSignalSource(...args);
  }

  buildRoomSignalSelector(
    ...args: Parameters<ServerDirectoryService['buildRoomSignalSelector']>
  ): ReturnType<ServerDirectoryService['buildRoomSignalSelector']> {
    return this.service.buildRoomSignalSelector(...args);
  }

  getFallbackRoomEndpoints(
    ...args: Parameters<ServerDirectoryService['getFallbackRoomEndpoints']>
  ): ReturnType<ServerDirectoryService['getFallbackRoomEndpoints']> {
    return this.service.getFallbackRoomEndpoints(...args);
  }

  setSearchAllServers(
    ...args: Parameters<ServerDirectoryService['setSearchAllServers']>
  ): ReturnType<ServerDirectoryService['setSearchAllServers']> {
    return this.service.setSearchAllServers(...args);
  }

  testServer(
    ...args: Parameters<ServerDirectoryService['testServer']>
  ): ReturnType<ServerDirectoryService['testServer']> {
    return this.service.testServer(...args);
  }

  testAllServers(
    ...args: Parameters<ServerDirectoryService['testAllServers']>
  ): ReturnType<ServerDirectoryService['testAllServers']> {
    return this.service.testAllServers(...args);
  }

  getApiBaseUrl(
    ...args: Parameters<ServerDirectoryService['getApiBaseUrl']>
  ): ReturnType<ServerDirectoryService['getApiBaseUrl']> {
    return this.service.getApiBaseUrl(...args);
  }

  getWebSocketUrl(
    ...args: Parameters<ServerDirectoryService['getWebSocketUrl']>
  ): ReturnType<ServerDirectoryService['getWebSocketUrl']> {
    return this.service.getWebSocketUrl(...args);
  }

  searchServers(
    ...args: Parameters<ServerDirectoryService['searchServers']>
  ): ReturnType<ServerDirectoryService['searchServers']> {
    return this.service.searchServers(...args);
  }

  getServers(
    ...args: Parameters<ServerDirectoryService['getServers']>
  ): ReturnType<ServerDirectoryService['getServers']> {
    return this.service.getServers(...args);
  }

  getFeaturedServers(
    ...args: Parameters<ServerDirectoryService['getFeaturedServers']>
  ): ReturnType<ServerDirectoryService['getFeaturedServers']> {
    return this.service.getFeaturedServers(...args);
  }

  getTrendingServers(
    ...args: Parameters<ServerDirectoryService['getTrendingServers']>
  ): ReturnType<ServerDirectoryService['getTrendingServers']> {
    return this.service.getTrendingServers(...args);
  }

  getServer(
    ...args: Parameters<ServerDirectoryService['getServer']>
  ): ReturnType<ServerDirectoryService['getServer']> {
    return this.service.getServer(...args);
  }

  findServerAcrossActiveEndpoints(
    ...args: Parameters<ServerDirectoryService['findServerAcrossActiveEndpoints']>
  ): ReturnType<ServerDirectoryService['findServerAcrossActiveEndpoints']> {
    return this.service.findServerAcrossActiveEndpoints(...args);
  }

  registerServer(
    ...args: Parameters<ServerDirectoryService['registerServer']>
  ): ReturnType<ServerDirectoryService['registerServer']> {
    return this.service.registerServer(...args);
  }

  updateServer(
    ...args: Parameters<ServerDirectoryService['updateServer']>
  ): ReturnType<ServerDirectoryService['updateServer']> {
    return this.service.updateServer(...args);
  }

  unregisterServer(
    ...args: Parameters<ServerDirectoryService['unregisterServer']>
  ): ReturnType<ServerDirectoryService['unregisterServer']> {
    return this.service.unregisterServer(...args);
  }

  getServerUsers(
    ...args: Parameters<ServerDirectoryService['getServerUsers']>
  ): ReturnType<ServerDirectoryService['getServerUsers']> {
    return this.service.getServerUsers(...args);
  }

  requestJoin(
    ...args: Parameters<ServerDirectoryService['requestJoin']>
  ): ReturnType<ServerDirectoryService['requestJoin']> {
    return this.service.requestJoin(...args);
  }

  createInvite(
    ...args: Parameters<ServerDirectoryService['createInvite']>
  ): ReturnType<ServerDirectoryService['createInvite']> {
    return this.service.createInvite(...args);
  }

  getInvite(
    ...args: Parameters<ServerDirectoryService['getInvite']>
  ): ReturnType<ServerDirectoryService['getInvite']> {
    return this.service.getInvite(...args);
  }

  kickServerMember(
    ...args: Parameters<ServerDirectoryService['kickServerMember']>
  ): ReturnType<ServerDirectoryService['kickServerMember']> {
    return this.service.kickServerMember(...args);
  }

  banServerMember(
    ...args: Parameters<ServerDirectoryService['banServerMember']>
  ): ReturnType<ServerDirectoryService['banServerMember']> {
    return this.service.banServerMember(...args);
  }

  unbanServerMember(
    ...args: Parameters<ServerDirectoryService['unbanServerMember']>
  ): ReturnType<ServerDirectoryService['unbanServerMember']> {
    return this.service.unbanServerMember(...args);
  }

  notifyLeave(
    ...args: Parameters<ServerDirectoryService['notifyLeave']>
  ): ReturnType<ServerDirectoryService['notifyLeave']> {
    return this.service.notifyLeave(...args);
  }

  updateUserCount(
    ...args: Parameters<ServerDirectoryService['updateUserCount']>
  ): ReturnType<ServerDirectoryService['updateUserCount']> {
    return this.service.updateUserCount(...args);
  }

  sendHeartbeat(
    ...args: Parameters<ServerDirectoryService['sendHeartbeat']>
  ): ReturnType<ServerDirectoryService['sendHeartbeat']> {
    return this.service.sendHeartbeat(...args);
  }
}
