import type { ViewProps } from "react-native";

export interface LibVlcPlayerViewRef {
  /**
   * Starts playback of the current player
   *
   * @returns A promise which resolves to `void`
   */
  readonly play: () => Promise<void>;
  /**
   * Pauses playback of the current player
   *
   * @returns A promise which resolves to `void`
   */
  readonly pause: () => Promise<void>;
  /**
   * Stops playback of the current player
   *
   * @returns A promise which resolves to `void`
   */
  readonly stop: () => Promise<void>;
  /**
   * Sets the time or position of the current player
   *
   * @param value - Must be `0` or greater
   * @param type - Defaults to time
   *
   * @returns A promise which resolves to `void`
   */
  readonly seek: (value: number, type?: "time" | "position") => Promise<void>;
  /**
   * Starts or stops recording the current media
   *
   * @param path - Must be a valid directory, or `undefined` to stop recording
   *
   * @returns A promise which resolves to `void`
   */
  readonly record: (path?: string) => Promise<void>;
  /**
   * Takes a snapshot of the current media
   *
   * @param path - Must be a valid directory
   *
   * @returns A promise which resolves to `void`
   */
  readonly snapshot: (path: string) => Promise<void>;
  /**
   * Posts an answer to a question dialog
   *
   * @param action - Which dialog action to perform
   *
   * @returns A promise which resolves to `void`
   */
  readonly postAction: (action: 1 | 2) => Promise<void>;
  /**
   * Posts a username and password to a login dialog
   *
   * @param username - Can't be empty
   * @param password - Can be empty
   * @param store - Whether to store the credentials
   *
   * @returns A promise which resolves to `void`
   */
  readonly postLogin: (username: string, password?: string, store?: boolean) => Promise<void>;
  /**
   * Dismisses the current dialog
   *
   * @returns A promise which resolves to `void`
   */
  readonly dismiss: () => Promise<void>;
  /**
   * Enters Picture-in-Picture (PiP) mode
   *
   * @note Config plugin has to be configured for PiP to work
   *
   * @returns A promise which resolves to `void`
   */
  readonly startPictureInPicture: () => Promise<void>;
  /**
   * Exits Picture-in-Picture (PiP) mode
   *
   * @platform ios
   *
   * @returns A promise which resolves to `void`
   */
  readonly stopPictureInPicture: () => Promise<void>;
}

export type LibVlcSource = string | number | null;

export type LibVlcSlaveSource = string | number;

export interface Slave {
  source: LibVlcSlaveSource;
  type: "audio" | "subtitle";
  selected?: boolean;
}

export interface Tracks {
  audio?: number;
  video?: number;
  subtitle?: number;
}

export interface Delays {
  audio?: number;
  subtitle?: number;
}

export type VideoAspectRatio = `${number}:${number}` | number | undefined;

/**
 * @hidden
 */
type NativeAspectRatioProps =
  | {
      aspectRatio: "auto";
      fallbackRatio: VideoAspectRatio;
    }
  | {
      aspectRatio?: VideoAspectRatio;
      fallbackRatio?: never;
    };

type AspectRatioProps =
  | {
      /**
       * Sets the container aspect ratio.
       *
       * When set to auto, a fallback ratio is required
       *
       * @default undefined
       */
      aspectRatio: "auto";
      /**
       * Sets the fallback aspect ratio
       *
       * @default undefined
       */
      fallbackRatio: VideoAspectRatio;
    }
  | {
      /**
       * Sets the container aspect ratio.
       *
       * When set to auto, a fallback ratio is required
       *
       * @default undefined
       */
      aspectRatio?: VideoAspectRatio;
      /**
       * Sets the fallback aspect ratio
       *
       * @default undefined
       */
      fallbackRatio?: never;
    };

export type VideoContentFit = "contain" | "cover" | "fill";

export type AudioMixingMode = "mixWithOthers" | "duckOthers" | "auto" | "doNotMix";

export interface NativeEventProps {
  target: number;
  timeStamp: number;
}

export interface NativeEvent<T> {
  nativeEvent: T & NativeEventProps;
}

export interface Buffering {
  value: number;
}

export interface Error {
  message: string;
}

export interface Dialog {
  title: string;
  text: string;
  type: "error" | "login" | "question";
  cancelText: string | null;
  action1Text: string | null;
  action2Text: string | null;
}

export interface Time {
  value: number;
}

export interface Position {
  value: number;
}

export interface MediaTrack {
  id: number;
  name: string;
}

export interface MediaTracks {
  audio: MediaTrack[];
  video: MediaTrack[];
  subtitle: MediaTrack[];
}

export interface Recording {
  path: string | null;
  isRecording: boolean;
}

export interface Snapshot {
  path: string;
}

export interface Video {
  width: number;
  height: number;
  frameRate: number;
  bitrate: number;
}

export interface Media {
  length: number;
  seekable: boolean;
}

export interface Metadata {
  title: string | null;
  artist: string | null;
  album: string | null;
  artworkURL: string | null;
}

export interface MediaInfo {
  video: Video;
  media: Media;
  metadata: Metadata;
}

/**
 * @hidden
 */
type BufferingListener = (event: NativeEvent<Buffering>) => void;

/**
 * @hidden
 */
type PlayingListener = () => void;

/**
 * @hidden
 */
type PausedListener = () => void;

/**
 * @hidden
 */
type StoppedListener = () => void;

/**
 * @hidden
 */
type EncounteredErrorListener = (event: NativeEvent<Error>) => void;

/**
 * @hidden
 */
type DialogDisplayListener = (event: NativeEvent<Dialog>) => void;

/**
 * @hidden
 */
type TimeChangedListener = (event: NativeEvent<Time>) => void;

/**
 * @hidden
 */
type PositionChangedListener = (event: NativeEvent<Position>) => void;

/**
 * @hidden
 */
type ESAddedListener = (event: NativeEvent<MediaTracks>) => void;

/**
 * @hidden
 */
type RecordChangedListener = (event: NativeEvent<Recording>) => void;

/**
 * @hidden
 */
type SnapshotTakenListener = (event: NativeEvent<Snapshot>) => void;

/**
 * @hidden
 */
type FirstPlayListener = (event: NativeEvent<MediaInfo>) => void;

/**
 * @hidden
 */
type ForegroundListener = () => void;

/**
 * @hidden
 */
type BackgroundListener = () => void;

/**
 * @hidden
 */
type PictureInPictureStartListener = () => void;

/**
 * @hidden
 */
type PictureInPictureStopListener = () => void;

/**
 * @hidden
 */
export type LibVlcPlayerViewNativeProps = ViewProps &
  NativeAspectRatioProps & {
    ref?: React.Ref<LibVlcPlayerViewRef>;
    source?: LibVlcSource;
    options?: string[];
    slaves?: Slave[];
    tracks?: Tracks;
    delays?: Delays;
    scale?: number;
    contentFit?: VideoContentFit;
    rate?: number;
    time?: number;
    volume?: number;
    mute?: boolean;
    audioMixingMode?: AudioMixingMode;
    repeat?: boolean;
    autoplay?: boolean;
    pictureInPicture?: boolean;
    onBuffering?: BufferingListener;
    onPlaying?: PlayingListener;
    onPaused?: PausedListener;
    onStopped?: StoppedListener;
    onEncounteredError?: EncounteredErrorListener;
    onDialogDisplay?: DialogDisplayListener;
    onTimeChanged?: TimeChangedListener;
    onPositionChanged?: PositionChangedListener;
    onESAdded?: ESAddedListener;
    onRecordChanged?: RecordChangedListener;
    onSnapshotTaken?: SnapshotTakenListener;
    onFirstPlay?: FirstPlayListener;
    onForeground?: ForegroundListener;
    onBackground?: BackgroundListener;
    onPictureInPictureStart?: PictureInPictureStartListener;
    onPictureInPictureStop?: PictureInPictureStopListener;
  };

export type LibVlcPlayerViewProps = ViewProps &
  AspectRatioProps & {
    /**
     * Allows getting a ref to the component instance.
     *
     * Once the component unmounts, React will set `ref.current` to `null`
     *
     * @see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}
     */
    ref?: React.RefObject<LibVlcPlayerViewRef | null>;
    /**
     * Sets the source of the media to be played, or `null` to release the player
     */
    source: LibVlcSource;
    /**
     * Sets the options to initialize the media with
     *
     * @see {@link https://wiki.videolan.org/VLC_command-line_help/ VideoLAN Wiki}
     *
     * @example
     *
     * ```tsx
     * const options = ["--network-caching=1000"];
     *
     * <LibVlcPlayerView
     *   {...props}
     *   options={options}
     * />
     * ```
     *
     * @default []
     */
    options?: string[];
    /**
     * Sets the player audio and subtitle slaves
     *
     * @example
     *
     * ```tsx
     * const slaves = [
     *   {
     *     source: "file://path/to/subtitle.srt",
     *     type: "subtitle",
     *     selected: true,
     *   },
     * ];
     *
     * <LibVlcPlayerView
     *   {...props}
     *   slaves={slaves}
     * />
     * ```
     *
     * @default []
     */
    slaves?: Slave[];
    /**
     * Sets the player audio, video, and subtitle track indexes
     *
     * @example
     *
     * ```tsx
     * const tracks = {
     *   audio: -1,
     *   video: 1,
     *   subtitle: 1,
     * };
     *
     * <LibVlcPlayerView
     *   {...props}
     *   tracks={tracks}
     * />
     * ```
     *
     * @default undefined
     */
    tracks?: Tracks;
    /**
     * Sets the player audio and subtitle delay values in microseconds
     *
     * @example
     *
     * ```tsx
     * const delays = {
     *   audio: 500_000,
     *   subtitle: 1_000_000,
     * };
     *
     * <LibVlcPlayerView
     *   {...props}
     *   delays={delays}
     * />
     * ```
     *
     * @default undefined
     */
    delays?: Delays;
    /**
     * Sets the player scaling factor
     *
     * @default 0
     */
    scale?: number;
    /**
     * Sets how the video should be scaled to fit in the container
     *
     * @default "contain"
     */
    contentFit?: VideoContentFit;
    /**
     * Sets the player playback rate
     *
     * @default 1
     */
    rate?: number;
    /**
     * Sets the initial player time in milliseconds. Must be `0` or greater
     *
     * @default 0
     */
    time?: number;
    /**
     * Sets the player volume. Must be between `0` and `100`
     *
     * @default 100
     */
    volume?: number;
    /**
     * Sets the player volume to `0` when `true` and restores previous volume when `false`
     *
     * @default false
     */
    mute?: boolean;
    /**
     * Determines how the player will interact with other audio playing in the system
     *
     * @default "auto"
     */
    audioMixingMode?: AudioMixingMode;
    /**
     * Determines whether the media should repeat once ended
     *
     * @default false
     */
    repeat?: boolean;
    /**
     * Determines whether the media should autoplay once created
     *
     * @default true
     */
    autoplay?: boolean;
    /**
     * Determines whether the player should allow Picture-in-Picture (PiP) mode
     *
     * @default false
     */
    pictureInPicture?: boolean;
    /**
     * Called after the `Buffering` player event
     */
    onBuffering?: (event: Buffering) => void;
    /**
     * Called after the `Playing` player event
     */
    onPlaying?: () => void;
    /**
     * Called after the `Paused` player event
     */
    onPaused?: () => void;
    /**
     * Called after the `Stopped` player event
     */
    onStopped?: () => void;
    /**
     * Called after the `EncounteredError` player event
     */
    onEncounteredError?: (event: Error) => void;
    /**
     * Called after a dialog needs to be displayed
     */
    onDialogDisplay?: (event: Dialog) => void;
    /**
     * Called after the `TimeChanged` player event
     */
    onTimeChanged?: (event: Time) => void;
    /**
     * Called after the `PositionChanged` player event
     */
    onPositionChanged?: (event: Position) => void;
    /**
     * Called after the `ESAdded` player event
     */
    onESAdded?: (event: MediaTracks) => void;
    /**
     * Called after the `RecordChanged` player event
     */
    onRecordChanged?: (event: Recording) => void;
    /**
     * Called after a media snapshot is taken
     */
    onSnapshotTaken?: (event: Snapshot) => void;
    /**
     * Called after the player first playing event
     */
    onFirstPlay?: (event: MediaInfo) => void;
    /**
     * Called after the player enters the foreground
     */
    onForeground?: () => void;
    /**
     * Called after the player enters the background
     */
    onBackground?: () => void;
    /**
     * Called after the player enters Picture-in-Picture (PiP) mode
     */
    onPictureInPictureStart?: () => void;
    /**
     * Called after the player exits Picture-in-Picture (PiP) mode
     */
    onPictureInPictureStop?: () => void;
  };