import logging
from enum import IntEnum

import vban_cmd

from . import configuration
from .layer import ILayer
from .states import AudioState

logger = logging.getLogger(__name__)


Buttons = IntEnum("Buttons", "mute_mics only_discord only_stream", start=0)


class Audio(ILayer):
    """Audio concrete class"""

    def __init__(self, duckypad, **kwargs):
        super().__init__(duckypad)
        for attr, val in kwargs.items():
            setattr(self, attr, val)

        self.reset_states()

    @property
    def identifier(self):
        return type(self).__name__

    @property
    def state(self):
        return self._state

    @state.setter
    def state(self, val):
        self._state = val

    def reset_states(self):
        self.state = AudioState()
        for button in Buttons:
            self.vm.button[button].stateonly = getattr(AudioState, button.name)

    def mute_mics(self):
        self.state.mute_mics = not self.state.mute_mics
        if self.state.mute_mics:
            self.vm.strip[0].mute = True
            self.vm.strip[1].mute = True
            self.vm.strip[4].mute = True
            self.logger.info("Mics Muted")
        else:
            self.vm.strip[0].mute = False
            self.vm.strip[1].mute = False
            self.vm.strip[4].mute = False
            self.logger.info("Mics Unmuted")
        self.vm.button[Buttons.mute_mics].stateonly = self.state.mute_mics

    def only_discord(self):
        self.state.only_discord = not self.state.only_discord
        if self.state.only_discord:
            self.mixer.dca[0].on = False
            self.vm.strip[4].mute = True
            self.logger.info("Only Discord Enabled")
        else:
            self.vm.strip[4].mute = False
            self.mixer.dca[0].on = True
            self.logger.info("Only Discord Disabled")
        self.vm.button[Buttons.only_discord].stateonly = self.state.only_discord

    def only_stream(self):
        self.state.only_stream = not self.state.only_stream
        if self.state.only_stream:
            self.vm.bus[5].mute = True
            self.vm.bus[6].mute = True
            self.vm.strip[2].gain = -3
            self.vm.strip[3].gain = -3
            self.vm.strip[6].gain = -3
            self.logger.info("Only Stream Enabled")
        else:
            self.vm.strip[2].gain = 0
            self.vm.strip[3].gain = 0
            self.vm.strip[6].gain = 0
            self.vm.bus[5].mute = False
            self.vm.bus[6].mute = False
            self.logger.info("Only Stream Disabled")
        self.vm.button[Buttons.only_stream].stateonly = self.state.only_stream

    def sound_test(self):
        def toggle_soundtest(params):
            onyx_conn = configuration.get("vban_onyx")
            iris_conn = configuration.get("vban_iris")
            assert all(
                [onyx_conn, iris_conn]
            ), "expected configurations for onyx_conn, iris_conn"

            with vban_cmd.api("potato", outbound=True, **onyx_conn) as vban:
                vban.strip[0].apply(params)
            with vban_cmd.api("potato", outbound=True, **iris_conn) as vban:
                vban.strip[0].apply(params)

        ENABLE_SOUNDTEST = {
            "A1": True,
            "A2": True,
            "B1": False,
            "B2": False,
            "mono": True,
        }
        DISABLE_SOUNDTEST = {
            "A1": False,
            "A2": False,
            "B1": True,
            "B2": True,
            "mono": False,
        }

        self.state.sound_test = not self.state.sound_test
        if self.state.sound_test:
            self.vm.strip[4].apply({"B3": False, "A1": True, "mute": False})
            self.vm.vban.outstream[0].on = True
            self.vm.vban.outstream[1].on = True
            self.vm.vban.outstream[0].route = 0
            self.vm.vban.outstream[1].route = 0
            toggle_soundtest(ENABLE_SOUNDTEST)
            self.logger.info("Sound Test Enabled")
        else:
            toggle_soundtest(DISABLE_SOUNDTEST)
            self.vm.vban.outstream[0].route = 5
            self.vm.vban.outstream[1].route = 6
            self.vm.strip[4].apply({"B3": True, "A1": False, "mute": True})
            self.logger.info("Sound Test Disabled")

    def solo_onyx(self):
        """placeholder method."""

    def solo_iris(self):
        """placeholder method."""

    def toggle_workstation_to_onyx(self):
        self.state.ws_to_onyx = not self.state.ws_to_onyx
        onyx_conn = configuration.get("vban_onyx")
        if self.state.ws_to_onyx:
            with vban_cmd.api("potato", **onyx_conn) as vban:
                vban.vban.instream[0].on = True
            self.vm.strip[5].gain = -6
            self.vm.vban.outstream[2].on = True
        else:
            with vban_cmd.api("potato", **onyx_conn) as vban:
                vban.vban.instream[0].on = False
            self.vm.strip[5].gain = 0
            self.vm.vban.outstream[2].on = False