import dbus, dbus.service, dbus.exceptions

from event.sync import EventDispatcher

OP_DPM_EMU = 'dpm-emulation'

OP_TR_EMU = 'tr-emulation'

OP_BS_EMU = 'bad-sector-emulation'

OP_DEV_ID = 'device-id'

class CDEmuDaemonProxy(EventDispatcher):

    _name = 'net.sf.cdemu.CDEmuDaemon'

    _object_path = '/Daemon'

    def __init__(self, use_system=False):

        """

        Low-level abstraction for communitating with cdemu daemon

        :param autostart_daemon: Attempt to start daemon if it is not running

        :param use_system: Not recommended. Consider this option deprecated. Left as a compatibility option

        """

        super().__init__(

            'daemon_started',

            'daemon_stopped',

            'device_status_changed',

            'device_option_changed',

            'device_mapping_ready',

            'device_added',

            'device_removed'

        )

        self._is_running = False

        self.use_system = use_system

        if self.use_system:

            self.bus = dbus.SystemBus()

        else:

            self.bus = dbus.SessionBus()

        self.bus.add_signal_receiver(self.from_daemon, dbus_interface='net.sf.cdemu.CDEmuDaemon',

                                     member_keyword='signal', message_keyword='params')

        self.bus.add_signal_receiver(self.from_dbus, dbus_interface='org.freedesktop.DBus',

                                     member_keyword='signal', message_keyword='params')

        self.obj = None

        self.interface = None

        self.connect()

    @property

    def is_running(self):

        return self._is_running

    def connect(self, retry=True):

        self.obj = self.bus.get_object(self._name, self._object_path)

        self.interface = dbus.Interface(self.obj, dbus_interface='net.sf.cdemu.CDEmuDaemon')

        self.ping_daemon(retry)

    def ping_daemon(self, retry=True):

        try:

            self.obj.Ping(dbus_interface='org.freedesktop.DBus.Peer')

            self._is_running = True

            self.dispatch('daemon_started')

        except dbus.exceptions.DBusException as e:

            if e.get_dbus_name() == 'org.freedesktop.DBus.Error.ServiceUnknown' and retry:

                self.connect(False)

    def from_dbus(self, *args, signal, params):

        print('from_dbus', '|'.join([str(a) for a in args]), signal, params)

        if signal == 'NameOwnerChanged':

            if args[0] == self._name:

                if args[2]:

                    self._is_running = True

                    self.dispatch('daemon_started')

                else:

                    self._is_running = False

                    self.dispatch('daemon_stopped')

    def from_daemon(self, *args, signal, params):

        print('from_daemon', '|'.join([str(a) for a in args]), signal, params)

        if signal == "DeviceStatusChanged":

            self.dispatch('device_status_changed', *args)

        elif signal == "DeviceOptionChanged":

            self.dispatch('device_option_changed', *args)

        elif signal == "DeviceMappingReady":

            self.dispatch('device_mapping_ready', *args)

        elif signal == "DeviceAdded":

            self.dispatch('device_added', *args)

        elif signal == "DeviceRemoved":

            self.dispatch('device_removed', *args)

    def get_daemon_version(self):

        return self.interface.GetDaemonVersion()

    def get_library_version(self):

        return self.interface.GetLibraryVersion()

    def get_daemon_interface_version2(self):

        return self.interface.GetDaemonInterfaceVersion2()

    def enum_daemon_debug_masks(self):

        return self.interface.EnumDaemonDebugMasks()

    def enum_library_debug_masks(self):

        return self.interface.EnumLibraryDebugMasks()

    def enum_supported_parsers(self):

        return self.interface.EnumSupportedParsers()

    def enum_supported_writers(self):

        return self.interface.EnumSupportedWriters()

    def enum_supported_filter_streams(self):

        return self.interface.EnumSupportedFilterStreams()

    def enum_writer_parameters(self, writer_id):

        return self.interface.EnumWriterParameters('(s)', writer_id)

    def get_number_of_devices(self):

        return self.interface.GetNumberOfDevices()

    def device_get_mapping(self, device_number):

        return self.interface.DeviceGetMapping(device_number)

    def device_get_status(self, device_number):

        return self.interface.DeviceGetStatus(device_number)

    def device_load(self, device_number, filenames, parameters={}):

        return self.interface.DeviceLoad(device_number, filenames, parameters)

    def device_create_blank(self, device_number, filename, parameters):

        return self.interface.DeviceCreateBlank(device_number, filename, parameters)

    def device_unload(self, device_number):

        return self.interface.DeviceUnload(device_number)

    def device_get_option(self, device_number, option_name):

        return self.interface.DeviceGetOption(device_number, option_name)

    def device_set_option(self, device_number, option_name, option_value):

        return self.interface.DeviceSetOption(device_number, option_name, option_value)

    def add_device(self):

        return self.interface.AddDevice()

    def remove_device(self):

        return self.interface.RemoveDevice()