import EventEmitter$1 from 'eventemitter3';
import { BrowserDeviceManager, IScreenConstraints } from 'media-device';

interface IProfile {
    width: number;
    height: number;
    frameRate: number;
    maxBitrate: number;
}
interface IAudioProfile {
    sampleRate: number;
    channelCount: number;
    maxBitrate: number;
}

interface IListenerMap {
    [s: string]: any;
}
type MapToList<T, V extends keyof T> = {
    [K in V]: T[K][];
};
declare class EventEmitter<T extends IListenerMap> {
    _eventMap: MapToList<T, keyof T>;
    listeners<K extends keyof T>(type: K): MapToList<T, keyof T>[K];
    emit<K extends keyof T>(type: K, ...args: any[]): boolean;
    off<K extends keyof T>(type: K, fn: T[K]): this;
    removeAllListeners<K extends keyof T>(type?: K): this;
    on<K extends keyof T>(type: K, fn: T[K]): this;
    once<K extends keyof T>(type: K, fn: T[K]): this;
}

declare class Stream extends EventEmitter<IMediaEvent> {
    protected audiotrack?: MediaStreamTrack;
    protected videotrack?: MediaStreamTrack;
    protected element?: HTMLMediaElement;
    protected mediastream?: MediaStream;
    protected traceid: string;
    protected reporter?: IReporter;
    id: string;
    constructor();
    set traceId(value: string);
    get traceId(): string;
    get mediaElement(): HTMLMediaElement | undefined;
    setReporter(reporter: IReporter): void;
    play(element: HTMLMediaElement): void;
    stop(): void;
}

interface IAudioMixer {
    trackList: MediaStreamTrack[];
    useGainNode?: boolean;
}
declare class AudioMixer {
    protected audioTrackArr: MediaStreamTrack[];
    protected useGainNode: boolean;
    protected audioContext: AudioContext;
    protected audioDestination: MediaStreamAudioDestinationNode;
    protected audioSource: MediaStreamAudioSourceNode[];
    protected gainNode: GainNode | null;
    protected audioTrack: MediaStreamTrack | null;
    constructor(props: IAudioMixer);
    destroy(): void;
    updateTrackList(trackList: MediaStreamTrack[]): void;
    getMixedAudioTrack(): MediaStreamTrack;
    private connectNode;
    private disconnectSourceNode;
}

interface IProps {
    video: HTMLVideoElement;
}
declare class CanvasRenderer {
    private activeRenderer;
    private canvas;
    private video;
    private ms?;
    constructor(props: IProps);
    get mediaStream(): MediaStream;
    start(): void;
    stop(): void;
    private initCanvas;
    private initRenderer;
    private render;
    resize(width: number, height: number): void;
}

/**
 * 推流使用的Stream
 */
declare class LocalStream extends Stream {
    protected deviceManager: BrowserDeviceManager;
    protected mediastream: MediaStream;
    protected videoProfile: string;
    protected screenProfile: string;
    protected audioProfile: string;
    protected pc?: RTCPeerConnection;
    protected audioMixer?: AudioMixer;
    protected canvasRenderer?: CanvasRenderer;
    micAudioTrack?: MediaStreamTrack;
    screenAudioTrack?: MediaStreamTrack;
    hasVideo: boolean;
    hasScreen: boolean;
    isCustomStream: boolean;
    screenSurfaceType: string | undefined;
    VideoProfileMap: Map<string, IProfile>;
    ScreenProfileMap: Map<string, IProfile>;
    AudioProfileMap: Map<string, IAudioProfile>;
    constructor();
    get mediaStream(): MediaStream;
    get audioTrack(): MediaStreamTrack | undefined;
    get videoTrack(): MediaStreamTrack | undefined;
    /**
     * 对外 API，可以和 hasVideo/hasScreen 并列使用
     */
    get hasAudio(): boolean;
    getVideoProfile(): string;
    getScreenProfile(): string;
    getAudioProfile(): string;
    /**
     * 初始化localstream
     * 优先判断video的配置，如果需要使用屏幕共享，需要把video设置为false
     * @param config
     */
    init(config: IStreamConfig): Promise<void>;
    initWithRetry(config: IStreamConfig, res?: () => void, rej?: (reason?: any) => void): Promise<void>;
    private initMicAudio;
    private initCameraVideo;
    private initMicCamera;
    private initScreenVideoAudio;
    private tryMixMicAndScreenAudio;
    private initTracks;
    private tryToSetProfile;
    private stopAllTracks;
    private resetLocalStream;
    setEncodeParam(pc: RTCPeerConnection, kind?: string): void;
    private setVideoEncodeParams;
    private setAudioEncodeParams;
    play(element: HTMLVideoElement, config?: {
        autoplay?: boolean;
        canvasStream?: boolean;
    }): void;
    setVideoProfile(profile: string): Promise<unknown>;
    setScreenProfile(profile: string): Promise<unknown>;
    setAudioProfile(profile: string): Promise<unknown>;
    enableAudio(): boolean;
    disableAudio(): boolean;
    enableVideo(): boolean;
    disableVideo(): boolean;
    stop(): void;
    mergeStream(newStream: LocalStream): void;
    deleteTracks(trackType: {
        video?: boolean;
        audio?: boolean;
    }): void;
    protected createCustomStream(stream?: MediaStream): Promise<void>;
    protected releaseMediaStream(): void;
    /**
     * 同时获取音频和视频的时候，是否需要等待视频获取完成
     * @param config
     * @protected
     */
    protected hasVideoTrackReady(config: IStreamConfig): boolean;
    protected hasScreenAudioConfig(config: IStreamConfig): boolean | MediaTrackConstraints;
    protected hasAudioTrackReady(config: IStreamConfig): boolean;
    /**
     * has config mic audio and audio track is ready
     */
    protected hasMicAudioAndReady(config: IStreamConfig): MediaStreamTrack;
    protected hasScreenAudioAndReady(config: IStreamConfig): MediaStreamTrack;
    protected addTrackListener(): void;
    protected listenVideoEnded(): void;
    private listenAudioEnded;
    protected handleVideoTrackEnded(): void;
    protected handleAudioTrackEnded(): void;
}

/**
 * 【参数】- LocalStream - 【init()】创建本地流配置参数
 */
interface IStreamConfig {
    audio?: MediaTrackConstraints | boolean;
    video?: MediaTrackConstraints | boolean;
    screen?: IScreenConstraints | boolean;
    /** 自定义流 */
    custom?: boolean;
    mediaStream?: MediaStream;
    skipProfile?: boolean;
}
/**
 * 【EVENT】- media 媒体事件
 */
interface IMediaEvent {
    onAutoPlayError: () => void;
    onCanPlay: () => void;
    onReplaceTrack: () => void;
    videoTrackEnded: () => void;
    audioTrackEnded: () => void;
    mediaElementBinded: () => void;
    micAudioTrackEnded: () => void;
    screenAudioTrackEnded: () => void;
}
/**
 * RTSReporter 方法定义接口
 */
interface IReporter {
    reportVideoProfile(profile: string): void;
    reportScreenProfile(profile: string): void;
    reportAudioProfile(profile: string): void;
    reportEnableAudio(): void;
    reportDisableAudio(): void;
    reportEnableVideo(): void;
    reportDisableVideo(): void;
    reportStop(type: number): void;
    reportPlay(type: string): void;
}

declare global {
    interface Window {
        AliRTS: any;
        define: any;
        mozRTCPeerConnection: any;
        webkitAudioContext: any;
        WeixinJSBridge: any;
    }
    interface RTCConfiguration {
        googCpuOveruseDetection?: boolean;
    }
    interface RTCRtpParameters {
        encodings: RTCRtpEncodingParameters[];
    }
}

declare enum AliRtcRawDataStreamType {
    /** 相机流 */
    AliRtcSdkStreamTypeCapture = 0,
    /** 屏幕共享流 */
    AliRtcSdkStreamTypeScreen = 1
}

declare enum VideoStreamSource {
    Camera = 0,
    Screen = 1,
    Image = 2
}
declare enum AudioStreamSource {
    Microphone = 0,
    Screen = 1,
    Mixed = 2
}
/**
 * ------------------    模式    ----- 采样率  -----  声道  -----  码率（kbps）  -----
 *
 * standard:           标准音质         48000       单声道          64
 *
 * high:                 高音质         48000       单声道         128
 *
 * standard-stereo:   立体声音质         48000       双声道         80
 *
 * high-stereo:       立体声高音质       48000       双声道         192
 */
type AudioProfileKey = 'standard' | 'high' | 'standard-stereo' | 'high-stereo';

interface AliRtcLocalStreamListener {
    videotrackended: () => void;
    audiotrackended: () => void;
}
declare class AliRtcLocalStreamInfo extends EventEmitter$1<AliRtcLocalStreamListener> {
    type: AliRtcRawDataStreamType;
    originVideoTrack?: MediaStreamTrack;
    videoSource?: VideoStreamSource;
    private _videoMuted;
    originAudioTrack?: MediaStreamTrack;
    audioSource?: AudioStreamSource;
    private _audioMuted;
    private _targetVideoTrack?;
    private _targetDualVideoTrack?;
    private _targetAudioTrack?;
    private _publishVideoStream?;
    private _publishDualVideoStream?;
    private _publishAudioStream?;
    private _previewStream?;
    plugins: AliRtcPlugin[];
    private _profileManager?;
    cameraVideoConstraints?: MediaTrackConstraints;
    micAudioConstraints?: MediaTrackConstraints;
    private get profileManager();
    get audioProfile(): AudioProfileKey;
    constructor(type: AliRtcRawDataStreamType);
    private onVideoTrackEnded;
    private onAudioTrackEnded;
    updateSource(newStream: LocalStream, newVideoSource?: VideoStreamSource, newAudioSource?: AudioStreamSource): Promise<void>;
    get currentProfile(): string;
    get currentVideoTrack(): MediaStreamTrack;
    get currentDualVideoTrack(): MediaStreamTrack;
    get publishVideoStream(): LocalStream;
    get publishDualVideoStream(): LocalStream;
    get currentAudioTrack(): MediaStreamTrack;
    get publishAudioStream(): LocalStream;
    get previewStream(): LocalStream | undefined;
    /**
     * 更新 VideoTrack
     * @param videoTrack
     */
    updateVideoTrack(videoTrack?: MediaStreamTrack, force?: boolean): Promise<void>;
    /**
     * 更新 DualVideoTrack
     * @param videoTrack
     * @param force
     */
    updateDualVideoTrack(videoTrack?: MediaStreamTrack, force?: boolean): Promise<void>;
    /**
     * 更新 AudioTrack
     * @param audioTrack
     */
    updateAudioTrack(audioTrack?: MediaStreamTrack, force?: boolean): Promise<void>;
    /**
     * 设置音频流静音
     * @param muted
     */
    setAudioMuted(muted: boolean): void;
    get isAudioMuted(): boolean;
    /**
     * 设置视频流静音
     * @param muted
     */
    setVideoMuted(muted: boolean): void;
    get isVideoMuted(): boolean;
    process(localStreamInfos: AliRtcLocalStreamInfo[]): Promise<void>;
    /**
     * 停止视频流
     */
    stopVideo(): void;
    /**
     * 停止音频流
     */
    stopAudio(): void;
    /**
     * 停止视频流和音频流
     */
    stop(): void;
    /**
     * 应该在执行完 plugin 后调用
     * @param profileName
     * @param profileValue
     */
    updateVideoProfile(profileName?: string, profileValue?: Partial<IProfile>, skipConstraints?: boolean): Promise<void>;
    get videoProfile(): string;
    setVideoContentHint(hint?: string): void;
    /**
     * 应该在执行完 plugin 后调用
     * @param profileName
     */
    updateAudioProfile(profileKey: AudioProfileKey): Promise<void>;
    /**
     * 复制视频 profile 到指定 LocalStream
     * @param publishStream
     */
    cloneVideoProfile(publishStream: LocalStream): Promise<void>;
    /**
     * 复制音频 profile 到指定 LocalStream
     * @param publishStream
     */
    cloneAudioProfile(publishStream: LocalStream): Promise<void>;
    addPlugin(plugin: AliRtcPlugin): void;
    removePlugin(plugin: AliRtcPlugin): boolean;
}

declare enum AliRtcPluginType {
    PRE_PROCESSOR = 0,
    POST_PROCESSOR = 1
}
declare enum AliRtcPluginTrackType {
    AUDIO = 0,
    VIDEO = 1,
    BOTH = 2
}
interface AliRtcPluginListener {
    enabled: () => void;
    disabled: () => void;
    updated: () => void;
    ready: () => void;
    overload: (info: any) => void;
    error: (error: any) => void;
    unsupported: () => void;
}
declare abstract class AliRtcPlugin extends EventEmitter$1<AliRtcPluginListener> {
    name: string;
    options: any;
    type: AliRtcPluginType;
    streamType: AliRtcRawDataStreamType;
    trackType: AliRtcPluginTrackType;
    zIndex: number;
    private _isEnable;
    protected shouldCache: boolean;
    lastInputAudioTrack?: MediaStreamTrack;
    lastOutputAudioTrack?: MediaStreamTrack;
    lastInputVideoTrack?: MediaStreamTrack;
    lastOutputVideoTrack?: MediaStreamTrack;
    private _hasCleared;
    constructor(name: string, streamType?: AliRtcRawDataStreamType, trackType?: AliRtcPluginTrackType);
    get initOptions(): {};
    getOptions(): any;
    abstract setOptions(options: any): void;
    abstract isSupported(version: string): boolean;
    init(): Promise<void>;
    enable(): void;
    disable(): void;
    get isEnable(): boolean;
    protected audioUpdated(streamInfo: AliRtcLocalStreamInfo): boolean;
    protected videoUpdated(streamInfo: AliRtcLocalStreamInfo): boolean;
    execute(streamInfo: AliRtcLocalStreamInfo, streamInfos: AliRtcLocalStreamInfo[]): Promise<void>;
    abstract shouldUpdate(streamInfo: AliRtcLocalStreamInfo, streamInfos: AliRtcLocalStreamInfo[]): boolean;
    abstract process(streamInfo: AliRtcLocalStreamInfo, streamInfos: AliRtcLocalStreamInfo[]): Promise<void>;
    clear(_streamInfo?: AliRtcLocalStreamInfo): void;
}

type AudioPluginOptions = {
    dumpAudioData?: boolean;
    aiaecOn?: boolean;
    farMediaStream?: MediaStream;
    slsReporter?: any;
    enableSoft3ACheck: boolean;
    useHardOnly: boolean;
};
declare class AliRtcAudioProcessPlugin extends AliRtcPlugin {
    private audioProcessor?;
    private slsReporter?;
    private enableSoft3ACheck;
    private useHardOnly;
    private lastDiffOutputLog;
    private audioContext;
    private farNode;
    constructor(options?: AudioPluginOptions);
    private activeAudioContext;
    audioUpdated(streamInfo: AliRtcLocalStreamInfo): boolean;
    videoUpdated(streamInfo: AliRtcLocalStreamInfo): boolean;
    setOptions(options: AudioPluginOptions): void;
    isSupported(): boolean;
    shouldUpdate(streamInfo: AliRtcLocalStreamInfo): boolean;
    private createNode;
    process(streamInfo: AliRtcLocalStreamInfo): Promise<void>;
    /**
     * 从日志文本中提取diff的值
     * @param logText 日志
     * @returns 提取到的diff数值（number类型）或null（未找到时）
     */
    private extractDiffValue;
    /**
     * 从日志文本中提取leak的值
     * @param logText 日志
     * @returns 提取到的leak数值（number类型）或null（未找到时）
     */
    private extractLeakValue;
    clear(streamInfo: AliRtcLocalStreamInfo): void;
    dump(): void;
}

export { type AudioPluginOptions, AliRtcAudioProcessPlugin as default };