"""This is the pyusb implementation of the seabreeze library

Author: Andreas Poehlmann

most of this code is based on implementations from
    http://github.com/ap--/python-oceanoptics

"""
import logging

import usb.core
import usb.util

from seabreeze.pyseabreeze.devices import SeaBreezeDevice, _model_class_registry
from seabreeze.pyseabreeze.transport import USBTransport


__all__ = ['SeaBreezeAPI']


class SeaBreezeAPI(object):
    """SeaBreeze API interface"""

    _log = logging.getLogger(__name__)

    def __init__(self, initialize=True):
        if initialize:
            self.initialize()

    @staticmethod
    def initialize():
        """initialize the api backend

        normally this function does not have to be called directly by the user.
        it resets all usb devices on load
        """
        # create the handles and associate protocols
        for device in USBTransport.list_devices():
            try:
                device.reset()
                usb.util.dispose_resources(device)
            except Exception as err:
                SeaBreezeAPI._log.debug("initialize failed: {}('{}')".format(
                    err.__class__.__name__, err.message
                ))

    @staticmethod
    def shutdown():
        """shutdown the api backend

        normally this function does not have to be called directly by the user
        """
        # dispose usb resources
        for device in USBTransport.list_devices():
            try:
                usb.util.dispose_resources(device)
            except Exception as err:
                SeaBreezeAPI._log.debug("shutdown failed: {}('{}')".format(
                    err.__class__.__name__, err.message
                ))

    @staticmethod
    def add_rs232_device_location(device_type, bus_path, baudrate):
        """add RS232 device location"""
        # RS232Transport.register_device(device_type, bus_path, baudrate)
        raise NotImplementedError("rs232 communication not implemented for pyseabreeze")

    @staticmethod
    def add_ipv4_device_location(device_type, ip_address, port):
        """add ipv4 device location"""
        # IPV4Transport.register_device(device_type, ip_address, port)
        raise NotImplementedError("ipv4 communication not implemented for pyseabreeze")

    @staticmethod
    def list_devices():
        """returns available SeaBreezeDevices

        list all connected Ocean Optics devices supported
        by libseabreeze.

        Returns
        -------
        devices: list of SeaBreezeDevice
            connected Spectrometer instances
        """
        # get all matching devices
        devices = []
        for pyusb_dev in USBTransport.list_devices():
            # get the correct communication interface
            dev = SeaBreezeDevice(pyusb_dev)
            if dev.is_open:
                was_open_before = True
            else:
                was_open_before = False
                try:
                    dev.open()
                except usb.core.USBError as usb_error:
                    if usb_error.errno == 16:
                        # device used by another thread?
                        continue
                    else:
                        raise
            if not was_open_before:
                dev.close()
            devices.append(dev)
        return devices

    @staticmethod
    def supported_models():
        """returns SeaBreezeDevices supported by the backend

        models supported by the backend

        Returns
        -------
        devices: list of str
            list of model names that are supported by this backend
        """
        return [x for x in sorted(_model_class_registry.keys())]