import {
  ChannelEvent,
  channelEventCallback,
  ChannelMode,
  ChannelOptions,
  ChannelParams,
  ChannelState,
  ChannelStateChange,
  ErrorInfo,
  InboundMessage,
  Message,
  messageCallback,
  MessageFilter,
  PaginatedResult,
  RealtimeChannel,
  RealtimeHistoryParams,
  RealtimePresence,
} from 'ably';

// TODO: replace with/use according RPC classes from UTS Pub/Sub when different UTS packages are made composable
export class RpcRealtimeChannel implements RealtimeChannel {
  private readonly _instanceId: string;

  constructor(instanceId: string) {
    this._instanceId = instanceId;
  }

  get name(): string {
    throw new Error('Getter not implemented.');
  }
  get errorReason(): ErrorInfo {
    throw new Error('Getter not implemented.');
  }
  get state(): ChannelState {
    throw new Error('Getter not implemented.');
  }
  get params(): ChannelParams {
    throw new Error('Getter not implemented.');
  }
  get modes(): ChannelMode[] {
    throw new Error('Getter not implemented.');
  }
  get presence(): RealtimePresence {
    throw new Error('Getter not implemented.');
  }
  unsubscribe(event: string, listener: messageCallback<InboundMessage>): void;
  unsubscribe(events: Array<string>, listener: messageCallback<InboundMessage>): void;
  unsubscribe(event: string): void;
  unsubscribe(events: Array<string>): void;
  unsubscribe(filter: MessageFilter, listener?: messageCallback<InboundMessage>): void;
  unsubscribe(listener: messageCallback<InboundMessage>): void;
  unsubscribe(): void;
  unsubscribe(filter?: unknown, listener?: unknown): void {
    throw new Error('Method not implemented.');
  }
  attach(): Promise<ChannelStateChange | null> {
    throw new Error('Method not implemented.');
  }
  detach(): Promise<void> {
    throw new Error('Method not implemented.');
  }
  history(params?: RealtimeHistoryParams): Promise<PaginatedResult<InboundMessage>> {
    throw new Error('Method not implemented.');
  }
  setOptions(options: ChannelOptions): Promise<void> {
    throw new Error('Method not implemented.');
  }
  subscribe(event: string, listener?: messageCallback<InboundMessage>): Promise<ChannelStateChange | null>;
  subscribe(events: Array<string>, listener?: messageCallback<InboundMessage>): Promise<ChannelStateChange | null>;
  subscribe(filter: MessageFilter, listener?: messageCallback<InboundMessage>): Promise<ChannelStateChange | null>;
  subscribe(callback: messageCallback<InboundMessage>): Promise<ChannelStateChange | null>;
  subscribe(filter: unknown, listener?: unknown): Promise<import('ably').ChannelStateChange | null> {
    throw new Error('Method not implemented.');
  }
  publish(name: string, data: any): Promise<void>;
  publish(messages: Message[]): Promise<void>;
  publish(message: Message): Promise<void>;
  publish(name: unknown, data?: unknown): Promise<void> {
    throw new Error('Method not implemented.');
  }
  whenState(targetState: ChannelState): Promise<ChannelStateChange | null> {
    throw new Error('Method not implemented.');
  }
  on(event: ChannelEvent, callback: channelEventCallback): void;
  on(events: ChannelEvent[], callback: channelEventCallback): void;
  on(callback: channelEventCallback): void;
  on(events: unknown, callback?: unknown): void {
    throw new Error('Method not implemented.');
  }
  once(event: ChannelEvent, callback: channelEventCallback): void;
  once(callback: channelEventCallback): void;
  once(event: ChannelEvent): Promise<ChannelStateChange>;
  once(): Promise<ChannelStateChange>;
  once(event?: unknown, callback?: unknown): void | Promise<import('ably').ChannelStateChange> {
    throw new Error('Method not implemented.');
  }
  off(event: ChannelEvent, callback: channelEventCallback): void;
  off(callback: channelEventCallback): void;
  off(): void;
  off(event?: unknown, callback?: unknown): void {
    throw new Error('Method not implemented.');
  }
  listeners(eventName?: ChannelEvent | undefined): channelEventCallback[] | null {
    throw new Error('Method not implemented.');
  }
}