#! /usr/bin/env python
"""
Position/place windows in WindowMaker.
Script calculates size of the target windows depending on current screen size.

Required python 2.7

Dependencies:
    - pygtk
    - docopt
    - wmctrl
    - xdotool
    - xwininfo

Calculate possible moves of the window against to the current size and
position. Assuming we have screen layout (two physical monitors in twin view
nvidia mode which makes one big screen available)

    +---------------------+-----------------------------+--+
    |                     |                             |  |
    | +--------+          |                             +--+
    | |window  |          |                             |  |
    | |        |          |                             +--+
    | +--------+          |                             |  |
    |                     |                             +--+
    |                     |                             |  |
    |   screen 0          |   screen 1                  +--+
    |                     |                                |
    +--+                  +--+--+                          |
    |  |                  |  |  |                          |
    +--+------------------+--+--+--------------------------+

possible moves of the depicted window would be:
    1. without resizing:
        - move to the left edge of the screen 0
        - move to the right edge of the screen 0
        - move to the left edge of the screen 1
        - move to the right edge of the screen 1
        - move to the screen 1 (don't cross boundary of the
          screen)
        - move to the left edge of the screen 1
        - move to the right edge of the screen 1
    2. with resizing:
        - move to the screen 1 (maximized)
        - maximize on current screen
        - move to screen 0 to the left half
        - move to screen 0 to the right half
        - move to screen 1 to the left half
        - move to screen 1 to the right half

TODO: Make it more flexible with different screen configurations

Author: Roman 'gryf' Dobosz <gryf73@gmail.com>
Date: 2013-01-06
Date: 2014-03-31 (used pygtk instead of xrandr, which is faster)
Date: 2014-06-25 added docopt, corrections and simplify the process
Version: 1.3
"""
import sys
import os
import re
from subprocess import Popen, PIPE, call
from docopt import docopt

from gtk import gdk


# TODO: Make it configurable (lots of options starting from ini file)
COVER_MINIWINDOWS = True
COVER_DOCK = False
DECOTATORS_HEIGHT = 29  # TODO: get it somehow from real window


def get_monitors():
    """Get monitors information:
        name
        index
        dimensions (as a tuple position x, y and dimension x and y)"""

    monitors = {}
    gdk_screen = gdk.screen_get_default()

    for out_num in range(gdk_screen.get_n_monitors()):
        monitor = {"index": out_num}
        (monitor["sx"], monitor["sy"],
         monitor["x"], monitor["y"]) = gdk_screen.get_monitor_geometry(out_num)
        monitors[gdk_screen.get_monitor_plug_name(out_num)] = monitor

    return monitors


def set_cover():
    """read actual wmaker config and set apropriate globals"""
    global COVER_MINIWINDOWS, COVER_DOCK

    with open(os.path.expanduser("~/GNUstep/Defaults/WindowMaker")) as fobj:
        for line in fobj:
            if "NoWindowOverIcons" in line and "YES" in line:
                COVER_MINIWINDOWS = False
                continue

            if "NoWindowOverDock" in line and "NO" in line:
                COVER_DOCK = True
                continue


class Screens(object):
    """
    Holds entire screen information and also Screen objects as a list
    """
    def __init__(self):
        """Class container for a Screen objects and whole area coordinates"""
        self.screens = []
        self.coords = ()
        self.dimension = None

    def append(self, screen):
        """Add screen"""
        self.screens.append(screen)

    def guess_dimensions(self, window):
        """
        Check wheter current window is in one of three states: maximized,
        left-half maximized, right-half maximized. If so, return appropriate
        information, None otherwise
        """
        for scr in self.screens:
            if window == scr.left_half:
                return "left"
            if window == scr.right_half:
                return "right"

            # check for maximized window (approximated)
            if window['pos_x'] == window['pos_y'] == 0:
                if window['size_x'] in range(scr.x - 32, scr.x + 32) and \
                        window['size_x'] in range(scr.x - 32, scr.x + 32):
                    return "maximized"

        return None


class Screen(object):
    """
    Holds separate display information. It can be separate X screen or just a
    display/monitor
    """
    def __init__(self, x=0, y=0, sx=0, sy=0):
        """Initialization"""
        self.x = int(x)
        self.y = int(y)
        self.x_shift = int(sx)
        self.y_shift = int(sy)
        self.main = False

        self.left_half = {"pos_x": 0,
                          "pos_y": 0,
                          "size_x": 0,
                          "size_y": 0}

        self.right_half = {"pos_x": 0,
                           "pos_y": 0,
                           "size_x": 0,
                           "size_y": 0}

        self.maximized = {"pos_x": 0,
                          "pos_y": 0,
                          "size_x": 0,
                          "size_y": 0}

    def calculate_columns(self):
        """
        Calculate dimension grid, which two column windows could occupy,
        make it pixel exact.
        """
        sx, sy = self.x, self.y

        if sx % 2 != 0:
            # it is rare, but hell, shit happens
            sx = sx - 1

        if self.main and not COVER_DOCK:
            # dock on the right side + 2px for border
            self.x = sx = sx - (64 + 2)
        else:
            self.x = sx = sx - 2

        # miniwindows on bottom + 2px for border
        print "calculate_columns", COVER_MINIWINDOWS
        if not COVER_MINIWINDOWS:
            self.y = sy = sy - (64 + 2)

        self.left_half['size_x'] = sx / 2 - 1
        self.maximized['pos_x'] = self.left_half['pos_x'] = self.x_shift

        self.right_half['size_x'] = sx / 2
        self.right_half['pos_x'] = sx / 2 + self.x_shift

        self.maximized['size_x'] = sx

        self.maximized['size_y'] = self.right_half['size_y'] = \
                self.left_half['size_y'] = sy - DECOTATORS_HEIGHT


class WMWindow(object):
    """
    Window object. Hold all of the information about current window and
    surrounded environment (screens and such).
    """

    position_re = re.compile("^\s+Position:\s(\d+),(\d+)\s.*$")
    geometry_re = re.compile(".*Geometry:\s(\d+)x(\d+).*")

    def __init__(self, monitors, main):
        """
        Initialization
        """
        self.screens = []
        self.x = None
        self.y = None
        self.pos_x = None
        self.pos_y = None
        self.current_screen = 0
        self.state = None
        self._main = main

        self._discover_screens(monitors)
        self._get_props()

    def _get_props(self):
        """
        Update current window dimensions and position
        """
        self.x = self.y = self.pos_x = self.pos_y = None

        out = Popen(['xdotool', 'getactivewindow', 'getwindowgeometry'],
                    stdout=PIPE).communicate()[0]
        out = out.strip().split("\n")

        if len(out) != 3:
            print "Cannot get window size and position"
            return

        pos, size = out[1:]

        match = self.position_re.match(pos)
        if match:
            self.pos_x, self.pos_y = match.groups()
            # XXX: arbitrary correction of the window position. Don't know why
            # xdotool reports such strange data - maybe it is connected with
            # inner/outer dimensions and/or window manager decorations
            self.pos_x = int(self.pos_x) - 1
            self.pos_y = int(self.pos_y) - 43

            for scr_no, scr in enumerate(self.screens.screens):
                if self.pos_x in range(scr.x_shift, scr.x + scr.x_shift):
                    self.current_screen = scr_no
                    break

        match = self.geometry_re.match(size)
        if match:
            self.x, self.y = match.groups()
            self.x = int(self.x)
            self.y = int(self.y)

        if None in (self.x, self.y, self.pos_x, self.pos_y):
            print "Not enough data for calculate window placement"
            print self.x, self.y, self.pos_x, self.pos_y
        else:
            self.guess_dimensions()

    def guess_dimensions(self):
        """Wrapper for screens guess_dimensions method"""
        return self.screens.guess_dimensions(self.get_data())

    def _discover_screens(self, monitors):
        """Create list of available screens. Assuming, that first screen
        reported is main screen."""

        self.screens = Screens()

        for name, data in monitors.items():
            screen = Screen(data["x"], data["y"], data["sx"], data["sy"])
            if self._main and len(monitors.keys()) > 1:
                if self._main == name:
                    screen.main = True
            elif not self.screens.screens:
                screen.main = True

            screen.calculate_columns()
            self.screens.append(screen)

        # sort screens depending on the position (only horizontal order is
        # supported)
        screens = {}

        for screen in self.screens.screens:
            screens[screen.x_shift] = screen

        self.screens.screens = [screens[key] for key in sorted(screens.keys())]

    def get_data(self):
        """Return current window coordinates and size"""
        return {"pos_x": self.pos_x,
                "pos_y": self.pos_y,
                "size_x": self.x,
                "size_y": self.y}

    def move_to_screen(self, screen_direction):
        """
        Set current screen to possible next or previous. Returns true if such
        operation is possible, false otherwise.
        """

        if screen_direction == "right":
            idx = self.current_screen + 1
        else:
            idx = self.current_screen - 1

        if idx < 0:
            return False

        try:
            self.screens.screens[idx]
        except IndexError:
            return False

        self.current_screen = idx
        return True

    def get_coords(self, which):
        """Return screen coordinates"""
        scr = self.screens.screens[self.current_screen]

        coord_map = {"maximized": scr.maximized,
                     "left_half": scr.left_half,
                     "right_half": scr.right_half}

        return coord_map[which]


def cycle(monitors, right=False, main=None):
    """Cycle through the window states"""
    wmwin = WMWindow(monitors, main)
    current_state = wmwin.guess_dimensions()

    direction = "right" if right else "left"

    if direction == "left":
        movement = {"left": ("right_half", "left", False),
                    "maximized": ("left_half", None, False),
                    "right": ("maximized", None, True),
                    None: ("left_half", None, False)}
    elif direction == "right":
        movement = {"left": ("maximized", None, False),
                    "maximized": ("right_half", None, True),
                    "right": ("left_half", "right", False),
                    None: ("right_half", None, False)}

    key, direction, order = movement[current_state]

    if direction:
        if not wmwin.move_to_screen(direction):
            return

    coords = wmwin.get_coords(key)
    if order:
        cmd = ['xdotool', "getactivewindow",
               "windowsize", str(coords['size_x']), str(coords['size_y']),
               "windowmove", str(coords['pos_x']), str(coords['pos_y']),
               "mousemove", str(coords['pos_x'] + coords['size_x'] / 2),
               str(coords['pos_y'] + coords['size_y'] / 2)]
    else:
        cmd = ['xdotool', "getactivewindow",
           "windowmove", str(coords['pos_x']), str(coords['pos_y']),
           "windowsize", str(coords['size_x']), str(coords['size_y']),
           "mousemove", str(coords['pos_x'] + coords['size_x'] / 2),
           str(coords['pos_y'] + coords['size_y'] / 2)]

    call(cmd)


def show_monitors(monitors):
    """Print out available monitors"""
    print "Available monitors:"
    for name, data in monitors.items():
        mon = data.copy()
        mon.update({"name": name})
        print "%(name)s at %(sx)sx%(sy)s with dimensions %(x)sx%(y)s" % mon


def move_mouse(monitors, name):
    """Move the mosue pointer to the left upper corner oft the specified by
    the name screen"""
    mon = monitors.get(name)

    if not mon:
        print "No such monitor: %s" % name
        return

    posx = mon["sx"] + 15
    posy = mon["sy"] + 50
    cmd = ['xdotool', "mousemove", str(posx), str(posy)]
    call(cmd)


def main():
    """get the arguments, run the app"""
    arguments = """Move windows around mimicking Windows7 flag+arrows behaviour

Usage:
  %(prog)s move (left|right) [-r|-l] [-m NAME]
  %(prog)s mousemove -m NAME
  %(prog)s showmonitors
  %(prog)s (-h | --help)
  %(prog)s --version

Options:
  -m NAME --monitor-name=NAME  Name of the monitor to be treade as the main one
                               (so the one containing dock)
  -r --dock-right              Dock is on the right edge of the rightmost
                               screen
  -l --dock-left               Dock is on the left edge of the leftmost screen
  -h --help                    Show this screen.
  -v --version                 Show version.

""" % {"prog": sys.argv[0]}
    opts = docopt(arguments, version=0.1)
    monitors = get_monitors()

    if opts["showmonitors"]:
        show_monitors(monitors)
        return

    if opts["mousemove"]:
        move_mouse(monitors, opts['--monitor-name'])
        return

    if opts["move"]:
        set_cover()
        cycle(monitors, bool(opts["right"]), main=opts["--monitor-name"])


if __name__ == "__main__":
    main()