package com.discord.stores;

import android.content.Context;
import androidx.annotation.VisibleForTesting;
import c.d.b.a.a;
import com.airbnb.lottie.parser.AnimatableValueParser;
import com.discord.api.channel.Channel;
import com.discord.api.voice.state.VoiceState;
import com.discord.app.AudioManagerFeatureFlag;
import com.discord.rtcconnection.RtcConnection;
import com.discord.stores.updates.ObservationDeck;
import com.discord.stores.updates.ObservationDeckProvider;
import com.discord.utilities.media.AudioOutputMonitor;
import com.discord.utilities.media.AudioOutputState;
import com.discord.utilities.rx.ObservableExtensionsKt;
import d0.t.h0;
import d0.t.n0;
import d0.z.d.m;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
/* compiled from: StoreAudioDevices.kt */
public final class StoreAudioDevices extends StoreV2 {
    public static final Companion Companion = new Companion(null);
    private static final AudioDevicesState DEFAULT_AUDIO_DEVICES_STATE;
    private static final OutputDevice.Speaker DEFAULT_OUTPUT_DEVICE;
    private static final AudioOutputState DEFAULT_OUTPUT_STATE;
    private AudioDevicesState audioDevicesState;
    private AudioDevicesState audioDevicesStateSnapshot;
    private final AudioManagerFeatureFlag audioManagerFeatureFlag;
    private final AudioOutputMonitor audioOutputMonitor;
    private AudioOutputState audioOutputState;
    private final StoreChannels channelsStore;
    private final Dispatcher dispatcher;
    private final boolean enabled;
    private final ObservationDeck observationDeck;
    private final StoreVoiceChannelSelected selectedVoiceChannelStore;
    private final VideoUseDetector videoUseDetector;
    private boolean wasMeUsingVideoInChannel;

    /* compiled from: StoreAudioDevices.kt */
    public static final class AudioDevicesState {
        private final AudioOutputState audioOutputState;
        private final Set<OutputDevice> availableOutputDevices;
        private final OutputDevice selectedOutputDevice;

        /* JADX DEBUG: Multi-variable search result rejected for r4v0, resolved type: java.util.Set<? extends com.discord.stores.StoreAudioDevices$OutputDevice> */
        /* JADX WARN: Multi-variable type inference failed */
        public AudioDevicesState(AudioOutputState audioOutputState, OutputDevice outputDevice, Set<? extends OutputDevice> set) {
            m.checkNotNullParameter(audioOutputState, "audioOutputState");
            m.checkNotNullParameter(outputDevice, "selectedOutputDevice");
            m.checkNotNullParameter(set, "availableOutputDevices");
            this.audioOutputState = audioOutputState;
            this.selectedOutputDevice = outputDevice;
            this.availableOutputDevices = set;
        }

        /* JADX DEBUG: Multi-variable search result rejected for r0v0, resolved type: com.discord.stores.StoreAudioDevices$AudioDevicesState */
        /* JADX WARN: Multi-variable type inference failed */
        public static /* synthetic */ AudioDevicesState copy$default(AudioDevicesState audioDevicesState, AudioOutputState audioOutputState, OutputDevice outputDevice, Set set, int i, Object obj) {
            if ((i & 1) != 0) {
                audioOutputState = audioDevicesState.audioOutputState;
            }
            if ((i & 2) != 0) {
                outputDevice = audioDevicesState.selectedOutputDevice;
            }
            if ((i & 4) != 0) {
                set = audioDevicesState.availableOutputDevices;
            }
            return audioDevicesState.copy(audioOutputState, outputDevice, set);
        }

        public final AudioOutputState component1() {
            return this.audioOutputState;
        }

        public final OutputDevice component2() {
            return this.selectedOutputDevice;
        }

        public final Set<OutputDevice> component3() {
            return this.availableOutputDevices;
        }

        public final AudioDevicesState copy(AudioOutputState audioOutputState, OutputDevice outputDevice, Set<? extends OutputDevice> set) {
            m.checkNotNullParameter(audioOutputState, "audioOutputState");
            m.checkNotNullParameter(outputDevice, "selectedOutputDevice");
            m.checkNotNullParameter(set, "availableOutputDevices");
            return new AudioDevicesState(audioOutputState, outputDevice, set);
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof AudioDevicesState)) {
                return false;
            }
            AudioDevicesState audioDevicesState = (AudioDevicesState) obj;
            return m.areEqual(this.audioOutputState, audioDevicesState.audioOutputState) && m.areEqual(this.selectedOutputDevice, audioDevicesState.selectedOutputDevice) && m.areEqual(this.availableOutputDevices, audioDevicesState.availableOutputDevices);
        }

        public final AudioOutputState getAudioOutputState() {
            return this.audioOutputState;
        }

        public final Set<OutputDevice> getAvailableOutputDevices() {
            return this.availableOutputDevices;
        }

        public final OutputDevice getSelectedOutputDevice() {
            return this.selectedOutputDevice;
        }

        public int hashCode() {
            AudioOutputState audioOutputState = this.audioOutputState;
            int i = 0;
            int hashCode = (audioOutputState != null ? audioOutputState.hashCode() : 0) * 31;
            OutputDevice outputDevice = this.selectedOutputDevice;
            int hashCode2 = (hashCode + (outputDevice != null ? outputDevice.hashCode() : 0)) * 31;
            Set<OutputDevice> set = this.availableOutputDevices;
            if (set != null) {
                i = set.hashCode();
            }
            return hashCode2 + i;
        }

        public String toString() {
            StringBuilder L = a.L("AudioDevicesState(audioOutputState=");
            L.append(this.audioOutputState);
            L.append(", selectedOutputDevice=");
            L.append(this.selectedOutputDevice);
            L.append(", availableOutputDevices=");
            L.append(this.availableOutputDevices);
            L.append(")");
            return L.toString();
        }
    }

    /* compiled from: StoreAudioDevices.kt */
    public static final class Companion {
        private Companion() {
        }

        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
            this();
        }

        @VisibleForTesting
        public static /* synthetic */ void getDEFAULT_AUDIO_DEVICES_STATE$app_productionBetaRelease$annotations() {
        }

        @VisibleForTesting
        public static /* synthetic */ void getDEFAULT_OUTPUT_STATE$app_productionBetaRelease$annotations() {
        }

        public final AudioDevicesState getDEFAULT_AUDIO_DEVICES_STATE$app_productionBetaRelease() {
            return StoreAudioDevices.access$getDEFAULT_AUDIO_DEVICES_STATE$cp();
        }

        public final OutputDevice.Speaker getDEFAULT_OUTPUT_DEVICE$app_productionBetaRelease() {
            return StoreAudioDevices.access$getDEFAULT_OUTPUT_DEVICE$cp();
        }

        public final AudioOutputState getDEFAULT_OUTPUT_STATE$app_productionBetaRelease() {
            return StoreAudioDevices.access$getDEFAULT_OUTPUT_STATE$cp();
        }
    }

    /* compiled from: StoreAudioDevices.kt */
    public static abstract class OutputDevice {

        /* compiled from: StoreAudioDevices.kt */
        public static final class BluetoothAudio extends OutputDevice {
            private final String name;

            public BluetoothAudio() {
                this(null, 1, null);
            }

            public BluetoothAudio(String str) {
                super(null);
                this.name = str;
            }

            /* JADX INFO: this call moved to the top of the method (can break code semantics) */
            public /* synthetic */ BluetoothAudio(String str, int i, DefaultConstructorMarker defaultConstructorMarker) {
                this((i & 1) != 0 ? null : str);
            }

            public static /* synthetic */ BluetoothAudio copy$default(BluetoothAudio bluetoothAudio, String str, int i, Object obj) {
                if ((i & 1) != 0) {
                    str = bluetoothAudio.name;
                }
                return bluetoothAudio.copy(str);
            }

            public final String component1() {
                return this.name;
            }

            public final BluetoothAudio copy(String str) {
                return new BluetoothAudio(str);
            }

            public boolean equals(Object obj) {
                if (this != obj) {
                    return (obj instanceof BluetoothAudio) && m.areEqual(this.name, ((BluetoothAudio) obj).name);
                }
                return true;
            }

            public final String getName() {
                return this.name;
            }

            public int hashCode() {
                String str = this.name;
                if (str != null) {
                    return str.hashCode();
                }
                return 0;
            }

            public String toString() {
                return a.D(a.L("BluetoothAudio(name="), this.name, ")");
            }
        }

        /* compiled from: StoreAudioDevices.kt */
        public static final class Earpiece extends OutputDevice {
            public static final Earpiece INSTANCE = new Earpiece();

            private Earpiece() {
                super(null);
            }
        }

        /* compiled from: StoreAudioDevices.kt */
        public static final class Speaker extends OutputDevice {
            public static final Speaker INSTANCE = new Speaker();

            private Speaker() {
                super(null);
            }
        }

        /* compiled from: StoreAudioDevices.kt */
        public static final class WiredAudio extends OutputDevice {
            public static final WiredAudio INSTANCE = new WiredAudio();

            private WiredAudio() {
                super(null);
            }
        }

        private OutputDevice() {
        }

        public /* synthetic */ OutputDevice(DefaultConstructorMarker defaultConstructorMarker) {
            this();
        }
    }

    /* compiled from: StoreAudioDevices.kt */
    public static final class VideoUseDetector {
        private final StoreChannels channelsStore;
        private final StoreUser usersStore;
        private final StoreVoiceStates voiceStatesStore;

        public VideoUseDetector(StoreChannels storeChannels, StoreVoiceStates storeVoiceStates, StoreUser storeUser) {
            m.checkNotNullParameter(storeChannels, "channelsStore");
            m.checkNotNullParameter(storeVoiceStates, "voiceStatesStore");
            m.checkNotNullParameter(storeUser, "usersStore");
            this.channelsStore = storeChannels;
            this.voiceStatesStore = storeVoiceStates;
            this.usersStore = storeUser;
        }

        @StoreThread
        private final Map<Long, VoiceState> getVoiceStatesForChannel(long j) {
            Channel findChannelByIdInternal$app_productionBetaRelease = this.channelsStore.findChannelByIdInternal$app_productionBetaRelease(j);
            Map<Long, VoiceState> map = this.voiceStatesStore.getInternal$app_productionBetaRelease().get(findChannelByIdInternal$app_productionBetaRelease != null ? Long.valueOf(findChannelByIdInternal$app_productionBetaRelease.f()) : null);
            if (map == null) {
                return h0.emptyMap();
            }
            LinkedHashMap linkedHashMap = new LinkedHashMap();
            for (Map.Entry<Long, VoiceState> entry : map.entrySet()) {
                Long a = entry.getValue().a();
                if (a != null && a.longValue() == j) {
                    linkedHashMap.put(entry.getKey(), entry.getValue());
                }
            }
            return linkedHashMap;
        }

        @StoreThread
        public final boolean isAnyoneUsingVideoInChannel(long j) {
            Collection<VoiceState> values = getVoiceStatesForChannel(j).values();
            if ((values instanceof Collection) && values.isEmpty()) {
                return false;
            }
            for (VoiceState voiceState : values) {
                if (AnimatableValueParser.U0(voiceState)) {
                    return true;
                }
            }
            return false;
        }

        @StoreThread
        public final boolean isMeUsingVideoInChannel(long j) {
            VoiceState voiceState = getVoiceStatesForChannel(j).get(Long.valueOf(this.usersStore.getMeInternal$app_productionBetaRelease().getId()));
            if (voiceState != null) {
                return AnimatableValueParser.U0(voiceState);
            }
            return false;
        }
    }

    static {
        OutputDevice.Speaker speaker = OutputDevice.Speaker.INSTANCE;
        DEFAULT_OUTPUT_DEVICE = speaker;
        AudioOutputState audioOutputState = new AudioOutputState(true, true, true, true, null);
        DEFAULT_OUTPUT_STATE = audioOutputState;
        DEFAULT_AUDIO_DEVICES_STATE = new AudioDevicesState(audioOutputState, speaker, n0.setOf((Object[]) new OutputDevice[]{speaker, OutputDevice.Earpiece.INSTANCE}));
    }

    public StoreAudioDevices(Dispatcher dispatcher, AudioOutputMonitor audioOutputMonitor, VideoUseDetector videoUseDetector, StoreVoiceChannelSelected storeVoiceChannelSelected, StoreChannels storeChannels, ObservationDeck observationDeck, AudioManagerFeatureFlag audioManagerFeatureFlag) {
        m.checkNotNullParameter(dispatcher, "dispatcher");
        m.checkNotNullParameter(audioOutputMonitor, "audioOutputMonitor");
        m.checkNotNullParameter(videoUseDetector, "videoUseDetector");
        m.checkNotNullParameter(storeVoiceChannelSelected, "selectedVoiceChannelStore");
        m.checkNotNullParameter(storeChannels, "channelsStore");
        m.checkNotNullParameter(observationDeck, "observationDeck");
        m.checkNotNullParameter(audioManagerFeatureFlag, "audioManagerFeatureFlag");
        this.dispatcher = dispatcher;
        this.audioOutputMonitor = audioOutputMonitor;
        this.videoUseDetector = videoUseDetector;
        this.selectedVoiceChannelStore = storeVoiceChannelSelected;
        this.channelsStore = storeChannels;
        this.observationDeck = observationDeck;
        this.audioManagerFeatureFlag = audioManagerFeatureFlag;
        this.enabled = !audioManagerFeatureFlag.b();
        AudioDevicesState audioDevicesState = DEFAULT_AUDIO_DEVICES_STATE;
        this.audioDevicesState = audioDevicesState;
        this.audioDevicesStateSnapshot = audioDevicesState;
    }

    /* JADX WARNING: Illegal instructions before constructor call */
    public /* synthetic */ StoreAudioDevices(Dispatcher dispatcher, AudioOutputMonitor audioOutputMonitor, VideoUseDetector videoUseDetector, StoreVoiceChannelSelected storeVoiceChannelSelected, StoreChannels storeChannels, ObservationDeck observationDeck, AudioManagerFeatureFlag audioManagerFeatureFlag, int i, DefaultConstructorMarker defaultConstructorMarker) {
        this(dispatcher, audioOutputMonitor, videoUseDetector, storeVoiceChannelSelected, storeChannels, r7, r8);
        AudioManagerFeatureFlag audioManagerFeatureFlag2;
        ObservationDeck observationDeck2 = (i & 32) != 0 ? ObservationDeckProvider.get() : observationDeck;
        if ((i & 64) != 0) {
            AudioManagerFeatureFlag audioManagerFeatureFlag3 = AudioManagerFeatureFlag.b;
            audioManagerFeatureFlag2 = AudioManagerFeatureFlag.a();
        } else {
            audioManagerFeatureFlag2 = audioManagerFeatureFlag;
        }
    }

    public static final /* synthetic */ void access$autoSelectNonSpeakerOutput(StoreAudioDevices storeAudioDevices) {
        storeAudioDevices.autoSelectNonSpeakerOutput();
    }

    public static final /* synthetic */ AudioDevicesState access$getAudioDevicesState(StoreAudioDevices storeAudioDevices) {
        return storeAudioDevices.getAudioDevicesState();
    }

    public static final /* synthetic */ AudioDevicesState access$getDEFAULT_AUDIO_DEVICES_STATE$cp() {
        return DEFAULT_AUDIO_DEVICES_STATE;
    }

    public static final /* synthetic */ OutputDevice.Speaker access$getDEFAULT_OUTPUT_DEVICE$cp() {
        return DEFAULT_OUTPUT_DEVICE;
    }

    public static final /* synthetic */ AudioOutputState access$getDEFAULT_OUTPUT_STATE$cp() {
        return DEFAULT_OUTPUT_STATE;
    }

    public static final /* synthetic */ Dispatcher access$getDispatcher$p(StoreAudioDevices storeAudioDevices) {
        return storeAudioDevices.dispatcher;
    }

    public static final /* synthetic */ void access$updateAudioOutputState(StoreAudioDevices storeAudioDevices, AudioOutputState audioOutputState) {
        storeAudioDevices.updateAudioOutputState(audioOutputState);
    }

    public static final /* synthetic */ void access$updateSelectedOutputDevice(StoreAudioDevices storeAudioDevices, OutputDevice outputDevice) {
        storeAudioDevices.updateSelectedOutputDevice(outputDevice);
    }

    @StoreThread
    private final void autoSelectAudioOutput() {
        OutputDevice outputDevice;
        long selectedVoiceChannelId = this.selectedVoiceChannelStore.getSelectedVoiceChannelId();
        if (this.audioDevicesState.getAudioOutputState().isExternalAudioOutputConnected()) {
            autoSelectNonSpeakerOutput();
            return;
        }
        if (this.videoUseDetector.isAnyoneUsingVideoInChannel(selectedVoiceChannelId)) {
            outputDevice = OutputDevice.Speaker.INSTANCE;
        } else {
            Channel channel = this.channelsStore.getChannel(selectedVoiceChannelId);
            outputDevice = (channel == null || !AnimatableValueParser.v1(channel)) ? OutputDevice.Earpiece.INSTANCE : OutputDevice.Speaker.INSTANCE;
        }
        updateSelectedOutputDevice(outputDevice);
    }

    @StoreThread
    private final void autoSelectNonSpeakerOutput() {
        Object obj;
        AudioOutputState audioOutputState = this.audioDevicesState.getAudioOutputState();
        Iterator<T> it = this.audioDevicesState.getAvailableOutputDevices().iterator();
        while (true) {
            if (!it.hasNext()) {
                obj = null;
                break;
            }
            obj = it.next();
            if (((OutputDevice) obj) instanceof OutputDevice.BluetoothAudio) {
                break;
            }
        }
        OutputDevice outputDevice = (OutputDevice) obj;
        if (!audioOutputState.isBluetoothOutputConnected() || outputDevice == null) {
            outputDevice = !audioOutputState.isHeadsetUnplugged() ? OutputDevice.WiredAudio.INSTANCE : OutputDevice.Earpiece.INSTANCE;
        }
        updateSelectedOutputDevice(outputDevice);
    }

    private final AudioDevicesState getAudioDevicesState() {
        return this.audioDevicesStateSnapshot;
    }

    @StoreThread
    private final void refreshAudioOutputState() {
        AudioOutputState audioOutputState = this.audioOutputState;
        if (audioOutputState != null) {
            updateAudioOutputState(audioOutputState);
        }
    }

    @StoreThread
    private final void updateAudioOutputState(AudioOutputState audioOutputState) {
        this.audioOutputState = audioOutputState;
        boolean isBluetoothOutputConnected = this.audioDevicesState.getAudioOutputState().isBluetoothOutputConnected();
        boolean z2 = !this.audioDevicesState.getAudioOutputState().isHeadsetUnplugged();
        this.audioDevicesState = AudioDevicesState.copy$default(this.audioDevicesState, audioOutputState, null, null, 6, null);
        Set<? extends OutputDevice> mutableSetOf = n0.mutableSetOf(OutputDevice.Speaker.INSTANCE);
        if (!audioOutputState.isHeadsetUnplugged()) {
            mutableSetOf.add(OutputDevice.WiredAudio.INSTANCE);
        } else {
            if (!this.videoUseDetector.isMeUsingVideoInChannel(this.selectedVoiceChannelStore.getSelectedVoiceChannelId())) {
                mutableSetOf.add(OutputDevice.Earpiece.INSTANCE);
            }
            if (audioOutputState.isBluetoothOutputConnected()) {
                mutableSetOf.add(new OutputDevice.BluetoothAudio(audioOutputState.getBluetoothDeviceName()));
            }
        }
        updateAvailableOutputDevices(mutableSetOf);
        AudioOutputState audioOutputState2 = this.audioDevicesState.getAudioOutputState();
        if ((!isBluetoothOutputConnected && audioOutputState2.isBluetoothOutputConnected()) || ((isBluetoothOutputConnected && !audioOutputState2.isBluetoothOutputConnected()) || ((!z2 && !audioOutputState2.isHeadsetUnplugged()) || (z2 && audioOutputState2.isHeadsetUnplugged())))) {
            autoSelectAudioOutput();
        }
        markChanged();
    }

    @StoreThread
    private final void updateAvailableOutputDevices(Set<? extends OutputDevice> set) {
        this.audioDevicesState = AudioDevicesState.copy$default(this.audioDevicesState, null, null, set, 3, null);
        markChanged();
    }

    @StoreThread
    private final void updateSelectedOutputDevice(OutputDevice outputDevice) {
        if (!m.areEqual(this.audioDevicesState.getSelectedOutputDevice(), outputDevice)) {
            this.audioDevicesState = AudioDevicesState.copy$default(this.audioDevicesState, null, outputDevice, null, 5, null);
            markChanged();
        }
    }

    public final AudioDevicesState getAudioDevicesState$app_productionBetaRelease() {
        return this.audioDevicesState;
    }

    public final boolean getEnabled() {
        return this.enabled;
    }

    @StoreThread
    public final void handleStreamRtcConnectionStateChange(RtcConnection.State state) {
        m.checkNotNullParameter(state, "state");
        if (this.enabled) {
            if (m.areEqual(state, RtcConnection.State.f.a) && !this.audioDevicesState.getAudioOutputState().isExternalAudioOutputConnected()) {
                updateSelectedOutputDevice(OutputDevice.Speaker.INSTANCE);
            }
        }
    }

    @StoreThread
    public final void handleVoiceChannelSelected() {
        if (this.enabled) {
            autoSelectAudioOutput();
        }
    }

    @StoreThread
    public final void handleVoiceStatesUpdated() {
        if (this.enabled) {
            boolean isMeUsingVideoInChannel = this.videoUseDetector.isMeUsingVideoInChannel(this.selectedVoiceChannelStore.getSelectedVoiceChannelId());
            if (this.wasMeUsingVideoInChannel != isMeUsingVideoInChannel) {
                refreshAudioOutputState();
            }
            if (!this.wasMeUsingVideoInChannel && isMeUsingVideoInChannel) {
                autoSelectAudioOutput();
            }
            this.wasMeUsingVideoInChannel = isMeUsingVideoInChannel;
        }
    }

    public final void init() {
        if (this.enabled) {
            ObservableExtensionsKt.appSubscribe$default(this.audioOutputMonitor.getOutputState(), StoreAudioDevices.class, (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, new StoreAudioDevices$init$1(this), 62, (Object) null);
        }
    }

    public final Observable<AudioDevicesState> observeAudioDevicesState() {
        Observable<AudioDevicesState> r = ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreAudioDevices$observeAudioDevicesState$1(this), 14, null).r();
        m.checkNotNullExpressionValue(r, "observationDeck.connectR… }.distinctUntilChanged()");
        return r;
    }

    public final void selectAudioOutput(OutputDevice outputDevice) {
        m.checkNotNullParameter(outputDevice, "outputDevice");
        this.dispatcher.schedule(new StoreAudioDevices$selectAudioOutput$1(this, outputDevice));
    }

    public final void setAudioDevicesState$app_productionBetaRelease(AudioDevicesState audioDevicesState) {
        m.checkNotNullParameter(audioDevicesState, "<set-?>");
        this.audioDevicesState = audioDevicesState;
    }

    @Override // com.discord.stores.StoreV2
    public void snapshotData() {
        super.snapshotData();
        this.audioDevicesStateSnapshot = AudioDevicesState.copy$default(this.audioDevicesState, null, null, new HashSet(this.audioDevicesState.getAvailableOutputDevices()), 3, null);
    }

    public final void toggleSpeakerOutput() {
        this.dispatcher.schedule(new StoreAudioDevices$toggleSpeakerOutput$1(this));
    }
}