# -*- coding: utf-8 -*-
# vim:et sts=4 sw=4
#
# ibus-table - The Tables engine for IBus
#
# Copyright (c) 2022 Mike FABIAN <mfabian@redhat.com>
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>
'''Module to track the name of the program in the currently focused window

On Wayland desktops:
    Tries AT-SPI first and falls back to xprop
On X11 desktops:
    Uses only xprop

AT-SPI:

https://en.wikipedia.org/wiki/Assistive_Technology_Service_Provider_Interface

- AT-SPI seems to work reasonably well in Gnome Wayland, KDE (Plasma)
  Wayland, and in some other cases. It even works in most X11 desktops, even
  in i3 (But as getting the active window via AT-SPI can sometimes fail,
  it is better to use xprop for that on X11 desktops, xprop is very reliable
  on X11 desktops).

- Even in a Gnome Wayland or KDE (Plasma) Wayland session AT-SPI
  doesn‘t work for some old X11 programs like xterm, urxvt, ...
  But the fallback to xprop works in these cases.

- To make AT-SPI work with Firefox and google-chrome,
  GNOME_ACCESSIBILITY=1 needs to be set in the environment.

- To make AT-SPI work with Qt5, QT_LINUX_ACCESSIBILITY_ALWAYS_ON=1
  needs to be set in the environment

- To make AT-SPI work with Qt4, QT_ACCESSIBILITY=1 needs to be set
  in the environment

In some cases, the name returned by AT-SPI may slightly differ
from from the name acquired by ibus with or by xprop.
For example in case of google-chrome:

- AT-SPI: 'Google Chrome'
- ibus focus id: 'google-chrome'
- xprop: 'google-chrome'

To test this module execute

    sleep 5 && python3 it_active_window.py

in a terminal, and focus a different window and see whether
the information from that active window is fetched correctly

Then focus different windows and see whether the log output
seen in the terminal shows correctly which window is currently active
(This works only with AT-SPI).

'''

from typing import Any
from typing import Tuple
import sys
import os
import subprocess
import shutil
import threading
import logging
IMPORT_PYATSPI_SUCCESSFUL = False
try:
    import pyatspi # type: ignore
    IMPORT_PYATSPI_SUCCESSFUL = True
except (ImportError,):
    IMPORT_PYATSPI_SUCCESSFUL = False

LOGGER = logging.getLogger('ibus-table')

class AtspiMonitor:
    '''
    Class to monitor the program name in the currently focused window
    '''
    def __init__(self) -> None:
        '''Initialization'''
        self._active_program_name = ''
        self._active_window_title = ''
        self._events_registered = False
        if not IMPORT_PYATSPI_SUCCESSFUL:
            LOGGER.info('“import pyatspi” failed.')
            return
        try:
            pyatspi.Registry.registerEventListener(
                self._on_window_activate, 'window:activate')
            pyatspi.Registry.registerEventListener(
                self._on_window_deactivate, 'window:deactivate')
            self._events_registered = True
            LOGGER.info('AtspiMonitor events registered.')
        except Exception as error:
            LOGGER.exception('%s: %s ', error.__class__.__name__, error)


    def start(self) -> None:
        '''Starts the monitoring'''
        if self._events_registered:
            LOGGER.info('Starting AtspiMonitor.')
            pyatspi.Registry.start() # pylint: disable=no-value-for-parameter

    def get_active_window(self) -> Tuple[str, str]:
        '''
        Gets information about the currently active window.

        :return: A tuple (program_name, window_title) giving
                 information about the currently focused window.
        '''
        return (self._active_program_name, self._active_window_title)

    def _on_window_activate(self, event: Any) -> None:
        '''Called when a window gets activated.'''
        LOGGER.debug('%s', str(event))
        try:
            self._active_program_name = event.host_application.name
            self._active_window_title = event.source_name
        except Exception as error:
            LOGGER.exception('%s: %s', error.__class__.__name__, error)
        LOGGER.info('window activated: %s currently active: %s title: %s',
                    self._active_program_name,
                    self._active_program_name,
                    self._active_window_title)

    def _on_window_deactivate(self, event: Any) -> None:
        '''Called when a window gets deactivated.'''
        LOGGER.debug('%s', str(event))
        program_name = ''
        try:
            program_name = event.host_application.name
        except Exception as error:
            LOGGER.exception('%s: %s', error.__class__.__name__, error)
        # There are some windows where the 'window:activate',
        # 'window:deactivate' signals do not work, for example windows
        # containing old X11 programs like xterm behave like that.
        #
        # If the focus moves from a window where the signals work to a
        # window where they do not, only the 'window:deactivate'
        # occurs.
        #
        # Therefore, we may want to set self._active_program_name = ''
        # when a window is deactivated because we may not be able to
        # get the true name of the program in the window which is
        # activated next and it is better to have an empty string than
        # a wrong program name left over from the previously active
        # program.
        #
        # *But*, sometimes the 'window:deactivate' signal for the old
        # window occurs *after* the 'window:activate' signal of the
        # new window! Weird!  Therefore, set self._active_program_name
        # = '' only if the program name is still unchanged!
        #
        # Theoretically if there are two windows for the same program,
        # for example two 'soffice' windows (Libreoffice), moving from
        # one to the other could then reset the program name from
        # 'soffice' to '' if the 'window:deactivate' signal comes
        # last.
        #
        # Luckily, when testing this I never saw that the
        # 'window:deactivate' signal came last when moving the focus
        # between two windows for the same program, i.e. when moving
        # from 'soffice' to 'soffice' or from 'firefox' to 'firefox',
        # this never happened.  But when moving from 'soffice' to
        # 'gnome-terminal' or from 'firefox' to 'gnome-terminal', it
        # *always* happened. This might be just an accident, but I
        # don’t have a better idea for a workaround at the moment.
        if self._active_program_name == program_name:
            self._active_program_name = ''
            self._active_window_title = ''
        LOGGER.info('window deactivated: %s currently active: %s title: %s',
                    program_name,
                    self._active_program_name,
                    self._active_window_title)

_ACTIVE_WINDOW: Tuple[str, str] = ('', '')

def _get_active_window_atspi() -> None:
    '''
    Internal function to get information about the currently active window.

    :return: A tuple (program_name, window_title) giving
             information about the currently focused window.
    '''
    global _ACTIVE_WINDOW
    try:
        desktop = pyatspi.Registry.getDesktop(0) # pylint: disable=no-value-for-parameter
        for application in desktop:
            if application.getState().contains(pyatspi.STATE_DEFUNCT):
                continue
            for window in application:
                if window.get_state_set().contains(pyatspi.STATE_ACTIVE):
                    _ACTIVE_WINDOW = (application.name, window.name)
                    return
    except Exception as error:
        LOGGER.exception('%s: %s', error.__class__.__name__, error)
    _ACTIVE_WINDOW = ('', '')

def get_active_window_atspi() -> Tuple[str, str]:
    '''
    Get information about the currently active window.

    :return: A tuple (program_name, window_title) giving
             information about the currently focused window.
    '''
    global _ACTIVE_WINDOW
    _ACTIVE_WINDOW = ('', '')
    if not IMPORT_PYATSPI_SUCCESSFUL:
        return ('', '')
    active_window_thread = threading.Thread(
        daemon=True, target=_get_active_window_atspi)
    active_window_thread.start()
    active_window_thread.join(timeout=0.5)
    if active_window_thread.is_alive():
        LOGGER.error('timeout getting active window.')
        return ('', '')
    return _ACTIVE_WINDOW

def get_active_window_xprop() -> Tuple[str, str]:
    '''
    Gets information about the currently active window.

    :return: A tuple (program_name, window_title) giving
             information about the currently focused window.

    Works only in X11 sessions (and for some X11 programs like xterm,
    urxvt, ...  in Wayland sessions)
    '''
    program_name = ''
    window_title = ''
    if 'DISPLAY' not in os.environ or not os.environ['DISPLAY']:
        return (program_name, window_title)
    xprop_binary = shutil.which('xprop')
    if not xprop_binary:
        return (program_name, window_title)
    try:
        result = subprocess.run(
            [xprop_binary, '-root', '-f',
             '_NET_ACTIVE_WINDOW', '0x', ' $0', '_NET_ACTIVE_WINDOW'],
            check=True, encoding='utf-8', capture_output=True)
    except subprocess.CalledProcessError as error:
        LOGGER.exception(
            'Exception when calling xprop: %s: %s stderr: %s',
             error.__class__.__name__, error, error.stderr)
        return (program_name, window_title)
    # result now looks like in this example:
    #
    # b'_NET_ACTIVE_WINDOW(WINDOW) 0x1e02d79'
    window_id = result.stdout.split()[-1:][0]
    if window_id == '0x0':
        return (program_name, window_title)
    try:
        result = subprocess.run(
            [xprop_binary,
             '-id', window_id, '-f', 'WM_CLASS', '0s', 'WM_CLASS'],
            check=True, encoding='utf-8', capture_output=True)
    except subprocess.CalledProcessError as error:
        LOGGER.exception(
            'Exception when calling xprop: %s: %s stderr: %s',
             error.__class__.__name__, error,  error.stderr)
        return (program_name, window_title)
    # result now looks like in this example
    #
    # b'WM_CLASS(STRING) = "xfce4-terminal", "Xfce4-terminal"\n'
    program_name = result.stdout.split(
        '=', maxsplit=1)[1].split(',')[1].strip()[1:-1].lower()
    try:
        result = subprocess.run(
            [xprop_binary,
             '-id', window_id, '-f', '_NET_WM_NAME', '0t', '_NET_WM_NAME'],
            check=True, encoding='utf-8', capture_output=True)
    except subprocess.CalledProcessError as error:
        LOGGER.exception(
            'Exception when calling xprop: %s: %s stderr: %s',
             error.__class__.__name__, error, error.stderr)
        return (program_name, window_title)
    # result now looks like in this example
    #
    # b'_NET_WM_NAME(UTF8_STRING) = "☺foo = "bar"\n'
    window_title = result.stdout.split('=', maxsplit=1)[1].strip()[1:-1]
    return (program_name, window_title)


def get_active_window() -> Tuple[str, str]:
    '''
    Gets information about the currently active window.

    :return: A tuple (program_name, window_title) giving
             information about the currently focused window.

    Tries AT-SPI first, if that doesn’t work falls back to xprop.

    '''
    (program_name, window_title) = ('', '')
    if ('XDG_SESSION_TYPE' in os.environ
        and os.environ['XDG_SESSION_TYPE'].lower() == 'wayland'):
        (program_name, window_title) = get_active_window_atspi()
    if program_name:
        LOGGER.debug(
            'Got active window from AT-SPI: %s', (program_name, window_title))
        return (program_name, window_title)
    (program_name, window_title) = get_active_window_xprop()
    if program_name:
        LOGGER.debug(
            'Got active window from xprop: %s', (program_name, window_title))
    return (program_name, window_title)

if __name__ == "__main__":
    LOG_HANDLER = logging.StreamHandler(stream=sys.stderr)
    LOGGER.setLevel(logging.DEBUG)
    LOGGER.addHandler(LOG_HANDLER)
    LOGGER.info('%s', get_active_window())
    atspi_monitor = AtspiMonitor()
    atspi_monitor.start()
