import { EventEmitter } from "events";

declare type fetchOptions = {
  fetchLimit?: number;
  streamQuality?: string;
  rawCookies?: string;
  userAgents?: string[];
  skipAlbumLimit?: Boolean;
};

export type scrapperOptions = {
  fetchLyrics?: boolean | true;
  eventReturn?: { metadata?: any };
  ratelimit?: number;
  ignoreInternalError?: boolean | true;
  fetchOptions?: fetchOptions;
  streamDownload?: boolean | false;
  playersCompatibility?: boolean | false;
  waitforPromise?: Boolean | true;
};

export class extractorData extends EventEmitter {
  public constructor(
    rawQuer: String,
    __scrapperOptions: scrapperOptions,
    youtubedl: Object
  );
  public readonly id: String;
  public readonly tracks: Track[];
  public readonly album: Album | Boolean;
  public readonly totalTracks: Number | 0;
  public readonly destroyed: Boolean | false;
  public readonly stopped: Boolean | false;
  public readonly completedTracks: Number;
  get raw(): {
    totalTracks?: Number | 0;
    rawQuery?: String;
    options?: scrapperOptions;
    youtubedl?: Object;
    status?: Number | 0;
  };
  get completed(): Boolean;
  get tracksCount(): Number;
  get rawQuery(): String;
  get youtubedl(): Object;
  get options(): scrapperOptions;
  public filter(): Boolean;
  public destroy(deleteCaches?: Boolean | false): Boolean;
  public stop(): Boolean;
  public delete(): Boolean;
  public on<K extends keyof extractorDataEvents>(
    event: K,
    listener: (...args: extractorDataEvents[K]) => Awaitable<void>
  ): this;
  public on<S extends string | symbol>(
    event: Exclude<S, keyof extractorDataEvents>,
    listener: (...args: any[]) => Awaitable<void>
  ): this;
}

export class Track {
  public constructor(__scrapperOptions: scrapperOptions);
  public readonly __scrapperOptions: scrapperOptions;
  public getStream(
    extraStream: string,
    ignoreStreamError: boolean,
    __cacheMain: {},
    __streamCaches: { userAgents: string[] },
    reTryonRatelimit?: boolean | "true"
  ): Promise<Track> | undefined;
  public getLyrics(): Promise<string>;
  public download(
    videoResolution?: String | "2080p" | "1080p" | "720p" | "480p",
    createStreamOptions?: {
      fileName?: String | "musicVideo";
      directoryPath?: String | "mediaContents";
      returnStreamOnly?: Boolean | false;
      printLogs?: Boolean | true;
    }
  ): Promise<boolean | ReadableStream>;
  readonly albumId: String | number | undefined;
  readonly trackId: number;
  readonly url: string;
  readonly videoId: string | number;
  readonly title: string;
  readonly description: string;
  readonly author: { name: string; url: string };
  readonly extractorModel: {
    orignal:
      | string
      | "deezer"
      | "youtube"
      | "spotify"
      | "facebook"
      | "reverbnation"
      | "soundcloud"
      | "arbitary";
    custom: string | "play-dl";
  };
  readonly videoMetadata: {
    video: Object[];
    audio: string;
  };
  readonly duration: {
    ms: number;
    readable: string;
  };
  readonly thumbnail: {
    Id: string | number;
    url: string;
  };
  readonly channel: {
    name: string;
    Id: string | number;
    url: string;
  };
  readonly isLive: boolean;
  readonly ratings: {
    likes: number | string;
    dislikes: number | string;
  };
  readonly stream: {
    preview: string;
    streamUrl: string;
    buffer: string | ReadableStream<Buffer>;
    videoUrl: string;
    type: string;
    duration: {
      ms: number;
      readable: string;
    };
    videoId: string | number;
  };
  readonly downloaded: boolean;
  metadata: any;
  readonly lyrics:
    | string
    | ""
    | "Lyrics fetched from Un-Official Source , so limited Resources are expected";
  readonly album: Album | "Related Playlist or Album with Track";
  readonly raw: {} | "Unparsed and fetched Track Data from play-dl";
}

export class Album {
  readonly Id: Number | String | undefined;
  readonly name: String;
  readonly url: String;
  readonly description: String;
  readonly thumbnail: String;
  readonly tracksCount: Number;
  readonly channel:
    | {
        name: String;
        description: String;
        url: String;
        thumbnail: String;
      }
    | undefined;
  readonly views: Number;
  metadata: any;
}

export type Awaitable<T> = T | PromiseLike<T>;

export interface youtubedlEvents {
  extractorData: [extractorData];
  track: [
    orignal_extractor:
      | string
      | "deezer"
      | "youtube"
      | "spotify"
      | "facebook"
      | "reverbnation"
      | "soundcloud"
      | "arbitary",
    album: Album,
    track: Track,
    extractorData: extractorData,
    metadata: any
  ];
  album: [Album, extractorData];
}

export interface extractorDataEvents {
  track: [
    orignal_extractor:
      | string
      | "deezer"
      | "youtube"
      | "spotify"
      | "facebook"
      | "reverbnation"
      | "soundcloud"
      | "arbitary",
    album: Album,
    track: Track,
    metadata: any
  ];
  tracks: [tracks: Track[], album: Album, metadata: any];
  album: [Album];
}