#!/usr/bin/env python3
"""
Syncthing-GTK - Windows related stuff.
"""


import codecs
import logging
import msvcrt
import os
import winreg

import win32api
import win32pipe
import win32process
from gi.repository import Gdk, GLib, Gtk
from win32com.shell import shell, shellcon


log = logging.getLogger("windows.py")

SM_SHUTTINGDOWN = 0x2000


def fix_localized_system_error_messages():
    """
    Python has trouble decoding messages like
    'S?bor, ktor? u? existuje, sa ned? vytvori:'
    as they are encoded in some crazy, Windows-specific, locale-specific,
    day-in-week-specific encoding.

    This simply eats exceptions caused by 'ascii' codec and replaces
    non-decodable characters by question mark.
    """

    def handle_error(error):
        return ('?', error.end)

    codecs.register_error("strict", handle_error)


def enable_localization():
    """
    Updates environment variables with windows locale.
    """
    loc = "en"
    try:
        import locale
        loc = locale.getdefaultlocale()[0]
    except Exception:
        pass
    if 'LANGUAGE' not in os.environ:
        os.environ['LANGUAGE'] = loc


def is_shutting_down():
    """ Returns True if Windows initiated shutdown process """
    return (win32api.GetSystemMetrics(SM_SHUTTINGDOWN) != 0)


def nice_to_priority_class(nice):
    """ Converts nice value to windows priority class """
    if nice <= -20:  # PRIORITY_HIGHEST
        return win32process.HIGH_PRIORITY_CLASS,
    if nice <= -10:  # PRIORITY_HIGH
        return win32process.ABOVE_NORMAL_PRIORITY_CLASS
    if nice >= 10:  # PRIORITY_LOW
        return win32process.BELOW_NORMAL_PRIORITY_CLASS
    if nice >= 19:  # PRIORITY_LOWEST
        return win32process.IDLE_PRIORITY_CLASS
    # PRIORITY_NORMAL
    return win32process.NORMAL_PRIORITY_CLASS


def override_menu_borders():
    """ Loads custom CSS to create borders around popup menus """
    style_provider = Gtk.CssProvider()
    style_provider.load_from_data("""
        .menu {
            border-image: linear-gradient(to top,
                                          alpha(@borders, 0.80),
                                          alpha(@borders, 0.60) 33%,
                                          alpha(@borders, 0.50) 66%,
                                          alpha(@borders, 0.15)) 2 2 2 2/ 2px 2px 2px 2px;
        }

        .menubar .menu {
            border-image: linear-gradient(to top,
                                          alpha(@borders, 0.80),
                                          alpha(@borders, 0.60) 33%,
                                          alpha(@borders, 0.50) 66%,
                                          transparent 99%) 2 2 2 2/ 2px 2px 2px 2px;
        }
        """)
    Gtk.StyleContext.add_provider_for_screen(
        Gdk.Screen.get_default(),
        style_provider,
        Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
    )


def get_unicode_home():
    return shell.SHGetFolderPath(0, shellcon.CSIDL_LOCAL_APPDATA, None, 0)


class WinPopenReader:
    """
    Reads from PIPE using GLib timers or idle_add. Emulates part of
    UnixInputStream, but its in no way even close to complete
    emulation.

    This is only way that I found so far to have pipe and hidden
    console window on Windows.
    """

    def __init__(self, pipe):
        # Prepare stuff
        self._pipe = pipe
        self._waits_for_read = None
        self._buffer = ""
        self._buffer_size = 32
        self._closed = False
        self._osfhandle = msvcrt.get_osfhandle(self._pipe.fileno())
        # Start reading
        GLib.idle_add(self._peek)

    def _peek(self):
        if self._closed:
            return False
        # Check if there is anything to read and read if available
        (read, nAvail, nMessage) = win32pipe.PeekNamedPipe(self._osfhandle, 0)
        if nAvail >= self._buffer_size:
            data = self._pipe.read(self._buffer_size)
            self._buffer += data
        # If there is read_async callback and buffer has some data,
        # send them right away
        if self._waits_for_read is not None and len(self._buffer) > 0:
            r = WinPopenReader.Results(self._buffer)
            self._buffer = ""
            callback, data = self._waits_for_read
            self._waits_for_read = None
            callback(self, r, *data)
            GLib.idle_add(self._peek)
            return False
        GLib.timeout_add_seconds(1, self._peek)
        return False

    def read_bytes_async(self, size, trash, cancel, callback, data=()):
        if self._waits_for_read is not None:
            raise Exception("Already reading")
        self._buffer_size = size
        self._waits_for_read = (callback, data)

    def read_bytes_finish(self, results):
        return results

    def close(self):
        self._closed = True

    class Results:
        """ Also serves as response object """

        def __init__(self, data):
            self._data = data

        def get_data(self):
            return self._data


def WinConfiguration():
    from syncthing_gtk.configuration import _Configuration, serializer

    class _WinConfiguration(_Configuration):
        """
        Configuration implementation for Windows - stores values
        in registry
        """

        # @ Overrides
        def load(self):
            self.values = {}
            r = winreg.OpenKey(winreg.HKEY_CURRENT_USER,
                               "Software\\SyncthingGTK")
            for key in _Configuration.REQUIRED_KEYS:
                tp, trash = _Configuration.REQUIRED_KEYS[key]
                try:
                    self.values[key] = self._read(r, key, tp)
                except WindowsError:
                    # Not found
                    pass
            winreg.CloseKey(r)

        # @ Overrides
        def save(self):
            r = winreg.CreateKey(winreg.HKEY_CURRENT_USER,
                                 "Software\\SyncthingGTK")
            for key in _Configuration.REQUIRED_KEYS:
                tp, trash = _Configuration.REQUIRED_KEYS[key]
                value = self.values[key]
                self._store(r, key, tp, value)
            winreg.CloseKey(r)

        def _store(self, r, name, tp, value):
            """ Stores value in registry, handling special types """
            if tp == str:
                winreg.SetValueEx(r, name, 0, winreg.REG_SZ, str(value))
            elif tp in (int, bool):
                value = int(value)
                if value > 0xFFFF:
                    raise ValueError("Overflow")
                if value < 0:
                    # This basically prevents storing anything >0xFFFF to registry.
                    # Luckily, that shouldn't be needed, largest thing stored as int is 20
                    value = 0xFFFF + (-value)
                winreg.SetValueEx(r, name, 0, winreg.REG_DWORD, int(value))
            elif tp in (list, tuple):
                if value is not None:  # None is default value for window_position
                    winreg.SetValueEx(r, "%s_size" %
                                      (name,), 0, winreg.REG_DWORD, len(value))
                    for i in range(0, len(value)):
                        self._store(r, "%s_%s" % (name, i),
                                    type(value[i]), value[i])
            else:
                winreg.SetValueEx(r, name, 0, winreg.REG_SZ, serializer(value))

        def _read(self, r, name, tp):
            """ Reads value from registry, handling special types """
            if tp in (list, tuple):
                size, trash = winreg.QueryValueEx(r, "%s_size" % (name,))
                value = []
                for i in range(0, size):
                    value.append(self._read(r, "%s_%s" % (name, i), None))
                return value
            else:
                value, keytype = winreg.QueryValueEx(r, name)
                if type(value) == int and value > 0xFFFF:
                    value = - (value - 0xFFFF)
                return value

    return _WinConfiguration()