import os
import re
import subprocess
from time import sleep

import cairocffi
import notify2
from libqtile import widget, bar
from libqtile.window import Internal
from libqtile.bar import Bar
from libqtile.utils import catch_exception_and_warn, UnixCommandNotFound
from libqtile.widget import base
from libqtile.widget.battery import default_icon_path
from libqtile.widget.check_updates import CheckUpdates
from libqtile.widget.image import Image
from libqtile.widget.sensors import ThermalSensor
from libqtile.widget.volume import Volume
from libqtile.widget.battery import BatteryIcon
from libqtile.widget.wlan import get_status
from libqtile.log_utils import logger
from notify2 import Notification, URGENCY_NORMAL

notify2.init("QTileWM")

BUTTON_LEFT = 1
BUTTON_MIDDLE = 2
BUTTON_RIGHT = 3
BUTTON_SCROLL_UP = 4
BUTTON_SCROLL_DOWN = 5


def is_running(process):
    s = subprocess.Popen(["ps", "axuw"], stdout=subprocess.PIPE)
    for x in s.stdout:
        if re.search(process, x.decode('utf-8')):
            return True
    return False


def execute(process):
    return subprocess.Popen(process.split())


def execute_once(process):
    if not is_running(process):
        return subprocess.Popen(process.split())


def get_screen_count():
    try:
        output = subprocess.check_output("xrandr -q".split()).decode('utf-8')
        output = [x for x in output.split("\n") if " connected" in x]
    except subprocess.CalledProcessError:
        return 1

    if output:
        return len(output)
    else:
        return 1


def bar_separator(config):
    return widget.Sep(foreground=config.get('colour_spacer_background', '#777777'),
                      linewidth=config.get('width_spacer', 1),
                      padding=config.get('padding_spacer', 4),
                      )


def notify(title, content, urgency=URGENCY_NORMAL, timeout=5000, image=None):
    if image is not None:
        notification = Notification(
            summary=title, message=content,
            icon=image
        )
    else:
        notification = Notification(
            summary=title, message=content
        )
    notification.set_timeout(timeout)
    notification.set_urgency(urgency)

    return notification.show()


def spawn_popup(qtile, x, y, text):
    """
    :param qtile: The main qtile instance
    :type qtile: Qtile
    :param x: x-coordinate
    :type x: int
    :param y: y-coordinate
    :type y: int
    :param text: String to display
    :type text: str
    :return: The popup instance
    :rtype: Internal
    """
    popup = Internal.create(
        qtile, x, y, 100, 100, opacity=1
    )

    # Create textwidget for in window
    popup.bordercolor = "#000000"
    popup.borderwidth = 1

    popup.focus(False)

    #popup.

    return popup


def despawn_popup(popup):
    """
    :type popup: Internal
    :param popup: The popup to despawn
    """
    popup.kill()


def test_popups(qtile):
    popup = spawn_popup(qtile, 10, 10, "Hello World!")
    sleep(3)
    despawn_popup(popup)


def display_wm_class(qtile):
    window = qtile.currentWindow if qtile else None

    if window:
        wm_class = window.window.get_wm_class() or None
        name = window.name

        if wm_class:
            notify(title="WM_Class of {}".format(name),
                   content="{}".format(wm_class),
                   urgency=notify2.URGENCY_CRITICAL)


def bluetooth_audio_sink():
    try:
        output = subprocess.check_output("pamixer --list-sinks".split()).decode("utf-8")
        output = [x for x in output.split('\n') if "blue" in x.lower()]
    except subprocess.CalledProcessError:
        return -1

    sink = -1
    try:
        sink = int(output[0].split()[0])
    except IndexError:
        pass
    except AttributeError:
        pass
    except ValueError:
        pass

    return sink


def bluetooth_audio_connected():
    return bluetooth_audio_sink() != -1


class KuroTopBar(Bar):
    def __init__(self, theme, widgets, size, **config):
        self.theme = theme
        super(KuroTopBar, self).__init__(widgets, size, **config)

    def _configure(self, qtile, screen):
        super(KuroTopBar, self)._configure(qtile, screen)
        self.window.handle_EnterNotify = self.handle_enter_notify
        self.window.handle_LeaveNotify = self.handle_leave_notify

    def handle_enter_notify(self, e):
        # self.theme.log_debug("Bar HandleEnterNotify")
        #
        # self.window.opacity = Config.get('bar_hover_opacity', 1.0)
        # print("Bar Hover Enter")
        #
        # try:
        #     hovered_widget = [x for x in self.widgets if (x.offsetx + x.width) >= e.event_x][0]
        # except IndexError:
        #     hovered_widget = None
        #
        # self.theme.log_debug("Hovered over {}".format(hovered_widget))
        #
        # if hasattr(hovered_widget, "handle_hover_enter"):
        #     hovered_widget.handle_hover_enter(e)

        self.draw()

    def handle_leave_notify(self, e):
        # self.theme.log_debug("Bar HandleLeaveNotify")
        #
        # self.window.opacity = Config.get('bar_opacity', 1.0)
        # print("Bar Hover Leave")
        #
        # try:
        #     hovered_widget = [x for x in self.widgets if (x.offsetx + x.width) >= e.event_x][0]
        # except IndexError:
        #     hovered_widget = None
        #
        # self.theme.log_debug("Hovered over {}".format(hovered_widget))
        #
        # if hasattr(hovered_widget, "handle_hover_leave"):
        #     hovered_widget.handle_hover_leave(e)

        self.draw()


class AppLauncherIcon(Image):
    def button_press(self, x, y, button):
        if button == BUTTON_LEFT:
            execute("dmenu_run -i -p '»' -nb '#000000' -fn 'Noto Sans-11' -nf '#777777' -sb '#1793d0' -sf '#ffffff'")

    def handle_hover(self, event):
        spawn_popup(self.qtile, self.offsetx, self.offsety, "Hovered over AppLauncherIcon!")


class CheckUpdatesYaourt(CheckUpdates):
    def __init__(self, **config):
        super(CheckUpdatesYaourt, self).__init__(**config)
        # Override command and output with yaourt command
        self.cmd = "yaourt -Qua".split()
        self.status_cmd = "yaourt -Qua".split()
        self.update_cmd = "sudo yaourt -Sya".split()
        self.subtr = 0

    def _check_updates(self):
        #subprocess.check_output(self.update_cmd)
        res = super(CheckUpdatesYaourt, self)._check_updates()
        return res

    def button_press(self, x, y, button):
        if button == BUTTON_LEFT:
            output = subprocess.check_output(self.status_cmd).decode('utf-8').split('\n')

            num_updates = len(output)-1
            msg = "{} updates available.".format(num_updates)

            if num_updates > 0:
                msg += "\n\n"
                for x in range(min(num_updates, 9)):
                    msg += output[x] + "\n"
                if num_updates > 9:
                    msg += "and {} more...".format(num_updates-9)

            notify(
                "System updates",
                msg
            )

        elif button == BUTTON_MIDDLE and self.execute is not None:
            subprocess.Popen(self.execute, shell=True)

class KuroBatteryIcon(BatteryIcon):
    status_cmd = "acpi"

    def button_press(self, x, y, button):
        if button == BUTTON_LEFT:
            output = subprocess.check_output(self.status_cmd).decode('utf-8')

            notify(
                "Battery Status",
                output
            )

class PulseVolumeWidget(Volume):

    defaults = [
        ("cardid", None, "Card Id"),
        ("device", "default", "Device Name"),
        ("channel", "Master", "Channel"),
        ("padding", 3, "Padding left and right. Calculated if None."),
        ("theme_path", None, "Path of the icons"),
        ("update_interval", 0.2, "Update time in seconds."),
        ("emoji", False, "Use emoji to display volume states, only if ``theme_path`` is not set."
                         "The specified font needs to contain the correct unicode characters."),
        ("mute_command", None, "Mute command"),
        ("volume_up_command", None, "Volume up command"),
        ("volume_down_command", None, "Volume down command"),
        ("get_volume_command", None, "Command to get the current volume"),
        ("is_bluetooth_icon", False, "Is this icon for a Bluetooth Audio device?"),
    ]

    _old_length = 0

    def __init__(self, **config):
        super(PulseVolumeWidget, self).__init__(**config)
        self._old_length = self._length

        # Augment commands with bluetooth sink ID if this is a bluetooth icon
        if self.is_bluetooth_icon and bluetooth_audio_connected():
            bsink = bluetooth_audio_sink()
            self.mute_command = " ".join(self._user_config['mute_command']).format(bsink=bsink).split()
            self.volume_up_command = " ".join(self._user_config['volume_up_command']).format(bsink=bsink).split()
            self.volume_down_command = " ".join(self._user_config['volume_down_command']).format(bsink=bsink).split()
            self.get_volume_command = " ".join(self._user_config['get_volume_command']).format(bsink=bsink).split()
            logger.info("Updated bluetooth commands with bluetooth sink {}".format(bsink))
            self._length = self._old_length
            self.commands_need_reset = False
        elif self.is_bluetooth_icon:
            self.commands_need_reset = True
        else:
            self.commands_need_reset = False

        self._old_length = self._length

    def reset_bluetooth_commands(self):
        if self.is_bluetooth_icon and bluetooth_audio_connected():
            bsink = 0 if bluetooth_audio_sink() == -1 else bluetooth_audio_sink()
            self.mute_command = " ".join(self._user_config['mute_command']).format(bsink=bsink).split()
            self.volume_up_command = " ".join(self._user_config['volume_up_command']).format(bsink=bsink).split()
            self.volume_down_command = " ".join(self._user_config['volume_down_command']).format(bsink=bsink).split()
            self.get_volume_command = " ".join(self._user_config['get_volume_command']).format(bsink=bsink).split()
            logger.info("Updated bluetooth commands with bluetooth sink {}".format(bsink))
            self._length = self._old_length
            self.commands_need_reset = False

    def get_volume(self):
        try:
            get_volume_cmd = "echo 0".split()

            if self.get_volume_command:
                if self.is_bluetooth_icon and bluetooth_audio_sink() == -1:
                    pass
                else:
                    get_volume_cmd = self.get_volume_command

            mixer_out = self.call_process(get_volume_cmd)
        except subprocess.CalledProcessError:
            return -1

        try:
            return int(mixer_out.strip())
        except ValueError:
            return -1

    def _update_drawer(self):
        super(PulseVolumeWidget, self)._update_drawer()
        self.text = ""
        if self.is_bluetooth_icon and not bluetooth_audio_connected():
            self._length = 0

    def draw(self):
        if self.is_bluetooth_icon and not bluetooth_audio_connected():
            if not self.commands_need_reset:
                logger.info("Bluetooth device disconnected. Hiding bluetooth audio mixer")
                self.commands_need_reset = True
            base._TextBox.draw(self)
        else:
            if self.commands_need_reset:
                self.reset_bluetooth_commands()
            if self.theme_path:
                self.drawer.draw(offsetx=self.offset, width=self.length)
            else:
                base._TextBox.draw(self)

    def button_press(self, x, y, button):
        if button == BUTTON_LEFT:
            volume = self.get_volume()

            width = 15

            if volume >= 0:
                volume_amount = round((volume/100)*width)
            else:
                volume_amount = 0

            msg = "[{}{}]".format(
                "".join(["#" for x in range(volume_amount)]),
                "".join(["-" for x in range(width-volume_amount)])
            )

            notify(
                "{}Volume : {}%".format("Bluetooth " if self.is_bluetooth_icon else "", volume),
                msg
            )
        else:
            super(PulseVolumeWidget, self).button_press(x, y, button)


class WifiIconWidget(base._TextBox):
    """WiFi connection strength indicator widget."""

    orientations = base.ORIENTATION_HORIZONTAL
    defaults = [
        ('interface', 'wlan0', 'The interface to monitor'),
        ('update_interval', 1, 'The update interval.'),
        ('theme_path', default_icon_path(), 'Path of the icons'),
        ('custom_icons', {}, 'dict containing key->filename icon map'),
    ]

    def __init__(self, **config):
        super(WifiIconWidget, self).__init__("WLAN", bar.CALCULATED, **config)
        self.add_defaults(WifiIconWidget.defaults)

        if self.theme_path:
            self.length_type = bar.STATIC
            self.length = 0
        self.surfaces = {}
        self.current_icon = 'wireless-disconnected'
        self.icons = dict([(x, '{0}.png'.format(x)) for x in (
            'wireless-disconnected',
            'wireless-none',
            'wireless-low',
            'wireless-medium',
            'wireless-high',
            'wireless-full',
        )])
        self.icons.update(self.custom_icons)

    def _get_info(self):
        try:
            essid, quality = get_status(self.interface)
            disconnected = essid is None
            if disconnected:
                return self.disconnected_message

            return {
                'error': False,
                'essid': essid,
                'quality': quality,
                'percent': (quality / 70)
            }
        except EnvironmentError:
            logger.error(
                '%s: Probably your wlan device is switched off or '
                ' otherwise not present in your system.',
                self.__class__.__name__)

        return {'error': True}

    def timer_setup(self):
        self.update()
        self.timeout_add(self.update_interval, self.timer_setup)

    def _configure(self, qtile, bar):
        super(WifiIconWidget, self)._configure(qtile, bar)
        self.setup_images()

    def _get_icon_key(self):
        key = 'wireless'
        info = self._get_info()
        if info is False or info.get('error'):
            key += '-none'
        elif info.get('essid') is None:
            key += '-disconnected'
        else:
            percent = info['percent']
            if percent < 0.2:
                key += '-low'
            elif percent < 0.4:
                key += '-medium'
            elif percent < 0.8:
                key += '-high'
            else:
                key += '-full'

        return key

    def update(self):
        icon = self._get_icon_key()
        if icon != self.current_icon:
            self.current_icon = icon
            self.draw()

    def draw(self):
        if self.theme_path:
            self.drawer.clear(self.background or self.bar.background)
            self.drawer.ctx.set_source(self.surfaces[self.current_icon])
            self.drawer.ctx.paint()
            self.drawer.draw(offsetx=self.offset, width=self.length)
        else:
            self.text = self.current_icon[8:]
            base._TextBox.draw(self)

    def setup_images(self):
        for key, name in self.icons.items():
            try:
                path = os.path.join(self.theme_path, name)
                img = cairocffi.ImageSurface.create_from_png(path)
            except cairocffi.Error:
                self.theme_path = None
                logger.warning('Wireless Icon switching to text mode')
                return
            input_width = img.get_width()
            input_height = img.get_height()

            sp = input_height / (self.bar.height - 1)

            width = input_width / sp
            if width > self.length:
                # cast to `int` only after handling all potentially-float values
                self.length = int(width + self.actual_padding * 2)

            imgpat = cairocffi.SurfacePattern(img)

            scaler = cairocffi.Matrix()

            scaler.scale(sp, sp)
            scaler.translate(self.actual_padding * -1, 0)
            imgpat.set_matrix(scaler)

            imgpat.set_filter(cairocffi.FILTER_BEST)
            self.surfaces[key] = imgpat


class ThermalSensorWidget(ThermalSensor):
    defaults = [
        ('metric', True, 'True to use metric/C, False to use imperial/F'),
        ('show_tag', False, 'Show tag sensor'),
        ('update_interval', 2, 'Update interval in seconds'),
        ('tag_sensor', None,
            'Tag of the temperature sensor. For example: "temp1" or "Core 0"'),
        ('chip', None, 'Chip argument for sensors command'),
        (
            'threshold',
            70,
            'If the current temperature value is above, '
            'then change to foreground_alert colour'
        ),
        ('foreground_alert', 'ff0000', 'Foreground colour alert'),
    ]

    @catch_exception_and_warn(warning=UnixCommandNotFound, excepts=OSError)
    def get_temp_sensors(self):
        """calls the unix `sensors` command with `-f` flag if user has specified that
        the output should be read in Fahrenheit.
        """
        command = ["sensors", ]
        if self.chip:
            command.append(self.chip)
        if not self.metric:
            command.append("-f")
        sensors_out = self.call_process(command)
        return self._format_sensors_output(sensors_out)