use super::*;

#[derive(Clone, Debug)]
pub enum Participant {
    Local(LocalParticipant),
    Remote(RemoteParticipant),
}

#[derive(Clone, Debug)]
pub struct LocalParticipant {
    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
    pub(super) identity: ParticipantIdentity,
    pub(super) room: Room,
}

#[derive(Clone, Debug)]
pub struct RemoteParticipant {
    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
    pub(super) identity: ParticipantIdentity,
    pub(super) room: WeakRoom,
}

#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
impl Participant {
    pub fn identity(&self) -> ParticipantIdentity {
        match self {
            Participant::Local(participant) => participant.identity.clone(),
            Participant::Remote(participant) => participant.identity.clone(),
        }
    }
}

#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
impl LocalParticipant {
    pub async fn unpublish_track(&self, track: &TrackSid) -> Result<()> {
        self.room
            .test_server()
            .unpublish_track(self.room.token(), track)
            .await
    }

    pub async fn publish_track(
        &self,
        track: LocalTrack,
        _options: TrackPublishOptions,
    ) -> Result<LocalTrackPublication> {
        let this = self.clone();
        let track = track.clone();
        let server = this.room.test_server();
        let sid = match track {
            LocalTrack::Video(track) => {
                server.publish_video_track(this.room.token(), track).await?
            }
            LocalTrack::Audio(track) => {
                server
                    .publish_audio_track(this.room.token(), &track)
                    .await?
            }
        };
        Ok(LocalTrackPublication {
            room: self.room.downgrade(),
            sid,
        })
    }
}

#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
impl RemoteParticipant {
    pub fn track_publications(&self) -> HashMap<TrackSid, RemoteTrackPublication> {
        if let Some(room) = self.room.upgrade() {
            let server = room.test_server();
            let audio = server
                .audio_tracks(room.token())
                .unwrap()
                .into_iter()
                .filter(|track| track.publisher_id() == self.identity)
                .map(|track| {
                    (
                        track.sid(),
                        RemoteTrackPublication {
                            sid: track.sid(),
                            room: self.room.clone(),
                            track: RemoteTrack::Audio(track),
                        },
                    )
                });
            let video = server
                .video_tracks(room.token())
                .unwrap()
                .into_iter()
                .filter(|track| track.publisher_id() == self.identity)
                .map(|track| {
                    (
                        track.sid(),
                        RemoteTrackPublication {
                            sid: track.sid(),
                            room: self.room.clone(),
                            track: RemoteTrack::Video(track),
                        },
                    )
                });
            audio.chain(video).collect()
        } else {
            HashMap::default()
        }
    }

    pub fn identity(&self) -> ParticipantIdentity {
        self.identity.clone()
    }
}