import {EControllerType} from "./Input";
import { EParentalFeature } from "./Parental";
import { EResult, Unregisterable } from "./shared";

export interface RemotePlay {
    /**
     * @param param1 TODO: Something about restrictions countries ? maybe it's games
     */
    BCanAcceptInviteForGame(gameId: string, param1: string): Promise<boolean>;
    BCanCreateInviteForGame(gameId: string, param1: boolean): Promise<boolean>;

    BRemotePlayTogetherGuestOnPhoneOrTablet(steam64Id: string, guestId: number): Promise<boolean>;

    BRemotePlayTogetherGuestSupported(): Promise<boolean>;

    // TODO: both calls have 1 arg, but it requires 2
    CancelInviteAndSession(steam64Id: string, param1: number): Promise<EResult>;

    CancelInviteAndSessionWithGuestID(steam64Id: string, guestId: number): Promise<EResult>;

    CancelRemoteClientPairing(): void;

    CloseGroup(): Promise<number>;

    CreateGroup(param0: string): Promise<EResult>;

    CreateInviteAndSession(steam64Id: string, param1: string): Promise<EResult>;

    CreateInviteAndSessionWithGuestID(steam64Id: string, guestId: number, param2: string): Promise<EResult>;

    GetClientID(): Promise<string>;

    // TODO: -1 no preference? no idea where the settings are anyway lol
    GetClientStreamingBitrate(): Promise<number>;
    GetClientStreamingQuality(): Promise<number>;
    GetControllerType(controllerIndex: number): Promise<EControllerType>;

    /**
     * @returns an integer from 0 to 100.
     */
    GetGameSystemVolume(): Promise<number>;

    GetPerUserInputSettings(steam64Id: string): Promise<RemotePlayInputSettings>;

    GetPerUserInputSettingsWithGuestID(steam64Id: string, guestId: number): Promise<RemotePlayInputSettings>;

    IdentifyController(nControllerIndex: number): void;

    InstallAudioDriver(): void;
    InstallInputDriver(): void;
    MoveControllerToSlot(controllerIndex: number, slot: number): void;
    RegisterForAdditionalParentalBlocks(callback: (blocks: EParentalFeature[]) => void): Unregisterable;
    RegisterForAudioDriverPrompt(callback: () => void): Unregisterable;

    /**
     * @todo no mentions of it in Steam code
     */
    RegisterForBitrateOverride: Unregisterable;
    RegisterForClearControllers(callback: () => void): Unregisterable;
    RegisterForControllerIndexSet(
      callback: (steamid: string, slot: number, guestid: number) => void
    ): Unregisterable;

    RegisterForDevicesChanges(callback: (devices: RemotePlayDevice[]) => void): Unregisterable;

    RegisterForGroupCreated(callback: (steamId: string, appId: string) => void): Unregisterable;
    RegisterForGroupDisbanded(callback: () => void): Unregisterable;
    RegisterForInputDriverPrompt(callback: () => void): Unregisterable;
    RegisterForInputDriverRestartNotice(callback: () => void): Unregisterable;

    RegisterForInputUsed(
        callback: (steam64Id: string, type: EClientUsedInputType, guestId: number) => void,
    ): Unregisterable; // only fires on host

    RegisterForInviteResult(
      callback: (
        steamId: string,
        param1: any,
        result: ERemoteClientLaunch,
      ) => void
    ): Unregisterable;

    RegisterForNetworkUtilizationUpdate(
        callback: (steam64Id: string, guestId: number, networkUtilization: number, networkDuration: number) => void,
    ): Unregisterable; // only fires on host

    RegisterForPlaceholderStateChanged(callback: (isShowingPlaceholder: boolean) => void): Unregisterable;

    RegisterForPlayerInputSettingsChanged(
      callback: (steamId: string, settings: RemotePlayInputSettings, guestId: number) => void
    ): Unregisterable;

    RegisterForQualityOverride(callback: (hostStreamingQualityOverride: number) => void): Unregisterable;

    RegisterForRemoteClientLaunchFailed(callback: (state: ERemoteClientLaunch) => void): Unregisterable;

    RegisterForRemoteClientStarted(callback: (steam64Id: string, appId: string) => void): Unregisterable; // only fires on client

    RegisterForRemoteClientStopped(callback: (steam64Id: string, appId: string) => void): Unregisterable; // only fires on client

    RegisterForRemoteDeviceAuthorizationCancelled(callback: () => void): Unregisterable;

    RegisterForRemoteDeviceAuthorizationRequested(callback: (device: string) => void): Unregisterable;

    RegisterForRemoteDevicePairingPINChanged(callback: (device: string, pin: string) => void): Unregisterable;

    RegisterForRestrictedSessionChanges(callback: (restrictedSession: boolean) => void): Unregisterable;

    RegisterForSessionStopped(callback: (steam64Id: string, guestId: number, avatarHash: string) => void): Unregisterable;

    RegisterForSessionStarted(callback: (steam64Id: string, gameId: string, guestId: number) => void): Unregisterable;

    RegisterForSessionStopped(callback: (steam64Id: string, guestId: number) => void): Unregisterable;

    RegisterForSettingsChanges(callback: (remotePlaySettings: RemotePlaySettings) => void): Unregisterable;

    SetClientStreamingBitrate(bitrate: number): void;

    SetClientStreamingQuality(quality: number): void;

    SetGameSystemVolume(volume: number): void;

    SetPerUserControllerInputEnabled(steam64Id: string, enabled: boolean): void;

    SetPerUserControllerInputEnabledWithGuestID(steam64Id: string, guestId: number, enabled: boolean): void;

    SetPerUserKeyboardInputEnabled(steam64Id: string, enabled: boolean): void;

    SetPerUserKeyboardInputEnabledWithGuestID(steam64Id: string, guestId: number, enabled: boolean): void;

    SetPerUserMouseInputEnabled(steam64Id: string, enabled: boolean): void;

    SetPerUserMouseInputEnabledWithGuestID(steam64Id: string, guestId: number, enabled: boolean): void;

    SetRemoteDeviceAuthorized(param0: boolean, param1: string): void;

    SetRemoteDevicePIN(pin: string): void;

    SetRemotePlayEnabled(enabled: boolean): void;

    /**
     * @param base64 Serialized base64 message from {@link StreamingClientConfig}.
     */
    SetStreamingClientConfig(base64: string, sessionId: number): void;
  
    /**
     * Enables advanced client options.
     */
    SetStreamingClientConfigEnabled(value: boolean): void;

    SetStreamingDesktopToRemotePlayTogetherEnabled(enabled: boolean): void;

    SetStreamingP2PScope(scope: EStreamP2PScope): void;

    /**
     * @param base64 Serialized base64 message from {@link StreamingServerConfig}.
     */
    SetStreamingServerConfig(base64: string, sessionId: number): void;

    /**
     * Enables advanced host options.
     */
    SetStreamingServerConfigEnabled(value: boolean): void;

    StopStreamingClient(): void;

    StopStreamingSession(id: number): void;
    StopStreamingSessionAndSuspendDevice(id: number): void;

    UnlockH264(): void;

    /**
     * Unpairs all devices.
     */
    UnpairRemoteDevices(): void;
}

export enum EClientUsedInputType {
    Keyboard,
    Mouse,
    Controller,
    Max,
}

export interface RemotePlayDevice {
    clientId: string;
    clientName: string;
    status: string; // "Connected", "Paired",
    formFactor: number;
    unStreamingSessionID: number;
    bCanSteamVR: boolean;
    bCanSuspend: boolean;
}

interface RemotePlayInputSettings {
  bKeyboardEnabled: true;
  bMouseEnabled: true;
  bControllerEnabled: true;
}

export interface RemotePlaySettings {
    bAV1DecodeAvailable: boolean;
    bHEVCDecodeAvailable: boolean;
    bRemotePlayDisabledBySystemPolicy: boolean;
    bRemotePlaySupported: boolean;
    bRemotePlayEnabled: boolean;
    eRemotePlayP2PScope: EStreamP2PScope;
    bRemotePlayServerConfigAvailable: boolean;
    bRemotePlayServerConfigEnabled: boolean;
    bRemotePlayClientConfigEnabled: boolean;
    unStreamingSessionID: number;
    strStreamingClientName: string;
    /**
     * If deserialized, returns {@link StreamingClientConfig}.
     */
    RemotePlayClientConfig: StreamingClientConfig;
    /**
     * If deserialized, returns {@link StreamingServerConfig}.
     */
    RemotePlayServerConfig: ArrayBuffer;
    nDefaultAudioChannels: number;
    nAutomaticResolutionX: number;
    nAutomaticResolutionY: number;
}

export interface StreamingClientConfig {
  quality?: EStreamQualityPreference;
  desired_resolution_x?: number;
  desired_resolution_y?: number;
  desired_framerate_numerator?: number;
  desired_framerate_denominator?: number;
  desired_bitrate_kbps?: number;
  enable_hardware_decoding?: boolean;
  enable_performance_overlay?: boolean;
  enable_video_streaming?: boolean;
  enable_audio_streaming?: boolean;
  enable_input_streaming?: boolean;
  audio_channels?: number;
  enable_video_hevc?: boolean;
  enable_performance_icons?: boolean;
  enable_microphone_streaming?: boolean;
  controller_overlay_hotkey?: string;
  enable_touch_controller_OBSOLETE?: boolean;
  p2p_scope?: EStreamP2PScope;
  enable_audio_uncompressed?: boolean;
  display_limit?: StreamVideoLimit;
  quality_limit?: StreamVideoLimit;
  runtime_limit?: StreamVideoLimit;
  decoder_limit: StreamVideoLimit[];
}

export interface StreamingServerConfig {
  change_desktop_resolution?: boolean;
  dynamically_adjust_resolution_OBSOLETE?: boolean;
  enable_capture_nvfbc?: boolean;
  enable_hardware_encoding_nvidia_OBSOLETE?: boolean;
  enable_hardware_encoding_amd_OBSOLETE?: boolean;
  enable_hardware_encoding_intel_OBSOLETE?: boolean;
  software_encoding_threads?: number;
  enable_traffic_priority?: boolean;
  host_play_audio?: EStreamHostPlayAudioPreference;
  enable_hardware_encoding?: boolean;
}

export interface StreamVideoLimit {
  codec?: EStreamVideoCodec;
  mode?: StreamVideoMode;
  bitrate_kbps?: number;
  burst_bitrate_kbps?: number;
}

export interface StreamVideoMode {
  width?: number;
  height?: number;
  refresh_rate?: number;
  refresh_rate_numerator?: number;
  refresh_rate_denominator?: number;
}

export enum ERemoteClientLaunch {
  OK = 1,
  Fail,
  RequiresUI,
  RequiresLaunchOption,
  RequiresEULA,
  Timeout,
  StreamTimeout,
  StreamClientFail,
  OtherGameRunning,
  DownloadStarted,
  DownloadNoSpace,
  DownloadFiltered,
  DownloadRequiresUI,
  AccessDenied,
  NetworkError,
  Progress,
  ParentalUnlockFailed,
  ScreenLocked,
  Unsupported,
  DisabledLocal,
  DisabledRemote,
  Broadcasting,
  Busy,
  DriversNotInstalled,
  TransportUnavailable,
  Canceled,
  Invisible,
  RestrictedCountry,
  Unauthorized,
}

export enum EStreamVideoCodec {
  None,
  Raw,
  VP8,
  VP9,
  H264,
  HEVC,
  ORBX1,
  ORBX2,
  AV1,
}

export enum EStreamHostPlayAudioPreference {
  Default,
  Always,
}

export enum EStreamQualityPreference {
  Automatic = -1,
  Fast = 1,
  Balanced,
  Beautiful,
}

export enum EStreamP2PScope {
    Automatic,
    Disabled,
    OnlyMe,
    Friends,
    Everyone,
}