use typed_builder::TypedBuilder;

#[derive(Debug, Clone, Copy)]
pub enum Microphone {
    Unmuted,
    ServerMuted,
    Muted,
}

#[derive(Debug, Clone, Copy)]
pub enum Headphone {
    Undeafened,
    ServerDeafened,
    Deafened,
}

#[derive(Debug, Clone, Copy)]
pub enum Camera {
    Showing,
    Off,
}

impl From<bool> for Camera {
    fn from(camming: bool) -> Self {
        if camming {
            Camera::Showing
        } else {
            Camera::Off
        }
    }
}

#[derive(Debug, Clone, Copy)]
pub enum Stream {
    Sharing,
    None,
}

impl From<bool> for Stream {
    fn from(streaming: bool) -> Self {
        if streaming {
            Stream::Sharing
        } else {
            Stream::None
        }
    }
}

#[derive(Debug, Clone)]
pub struct UserInVCData {
    pub microphone: Microphone,
    pub headphone: Headphone,
    pub camera: Camera,
    pub stream: Stream,
}

#[derive(Debug, Clone, TypedBuilder)]
pub struct VoiceStatus {
    server_deafened: bool,
    self_deafened: bool,

    server_muted: bool,
    self_muted: bool,

    camming: bool,

    streaming: bool,
}

impl From<VoiceStatus> for UserInVCData {
    fn from(
        VoiceStatus {
            server_deafened,
            self_deafened,
            server_muted,
            self_muted,
            camming,
            streaming,
        }: VoiceStatus,
    ) -> Self {
        let microphone = match (server_muted, self_muted) {
            (true, _) => Microphone::ServerMuted,
            (false, true) => Microphone::Muted,
            (false, false) => Microphone::Unmuted,
        };

        let headphone = match (server_deafened, self_deafened) {
            (true, _) => Headphone::ServerDeafened,
            (false, true) => Headphone::Deafened,
            (false, false) => Headphone::Undeafened,
        };

        let camera = camming.into();

        let stream = streaming.into();

        UserInVCData {
            microphone,
            headphone,
            camera,
            stream,
        }
    }
}