/**
 * This class is used for local stream manipulation.
 * @remarks
 * This class does not really store any local stream for the reason
 * that the local stream tracks are stored in the peer connection.
 *
 * This simply provides necessary methods for stream manipulation.
 *
 * Currently it does not use any of its base functionality. Nevertheless
 * there might be a need that we may want to do some stream operations
 * such as closing of tracks, in future. For that purpose, it is written
 * this way.
 *
 */

import type { Session } from 'sip.js';
import type { MediaStreamFactory, SessionDescriptionHandler } from 'sip.js/lib/platform/web';
import { defaultMediaStreamFactory } from 'sip.js/lib/platform/web';

import Stream from './Stream';

export default class LocalStream extends Stream {
	static async requestNewStream(constraints: MediaStreamConstraints, session: Session): Promise<MediaStream | undefined> {
		const factory: MediaStreamFactory = defaultMediaStreamFactory();
		if (session?.sessionDescriptionHandler) {
			return factory(constraints, session.sessionDescriptionHandler as SessionDescriptionHandler);
		}
	}

	static async replaceTrack(peerConnection: RTCPeerConnection, newStream: MediaStream, mediaType?: 'audio' | 'video'): Promise<boolean> {
		const senders = peerConnection.getSenders();
		if (!senders) {
			return false;
		}
		/**
		 * This will be called when media device change happens.
		 * This needs to be called externally when the device change occurs.
		 * This function first acquires the new stream based on device selection
		 * and then replaces the track in the sender of existing stream by track acquired
		 * by caputuring new stream.
		 *
		 * Notes:
		 * Each sender represents a track in the RTCPeerConnection.
		 * Peer connection will contain single track for
		 * each, audio, video and data.
		 * Furthermore, We are assuming that
		 * newly captured stream will have a single track for each media type. i.e
		 * audio video and data. But this assumption may not be true atleast in theory. One may see multiple
		 * audio track in the captured stream or multiple senders for same kind in the peer connection
		 * If/When such situation arrives in future, we may need to revisit the track replacement logic.
		 * */

		switch (mediaType) {
			case 'audio': {
				let replaced = false;
				const newTracks = newStream.getAudioTracks();
				if (!newTracks) {
					console.warn('replaceTrack() : No audio tracks in the stream. Returning');
					return false;
				}
				for (let i = 0; i < senders?.length; i++) {
					if (senders[i].track?.kind === 'audio') {
						senders[i].replaceTrack(newTracks[0]);
						replaced = true;
						break;
					}
				}
				return replaced;
			}
			case 'video': {
				let replaced = false;
				const newTracks = newStream.getVideoTracks();
				if (!newTracks) {
					console.warn('replaceTrack() : No video tracks in the stream. Returning');
					return false;
				}
				for (let i = 0; i < senders?.length; i++) {
					if (senders[i].track?.kind === 'video') {
						senders[i].replaceTrack(newTracks[0]);
						replaced = true;
						break;
					}
				}
				return replaced;
			}
			default: {
				let replaced = false;
				const newTracks = newStream.getVideoTracks();
				if (!newTracks) {
					console.warn('replaceTrack() : No tracks in the stream. Returning');
					return false;
				}
				for (let i = 0; i < senders?.length; i++) {
					for (let j = 0; j < newTracks.length; j++) {
						if (senders[i].track?.kind === newTracks[j].kind) {
							senders[i].replaceTrack(newTracks[j]);
							replaced = true;
							break;
						}
					}
				}
				return replaced;
			}
		}
	}
}