# -*- coding: utf-8 -*-
# vim: autoindent shiftwidth=4 expandtab textwidth=120 tabstop=4 softtabstop=4

###############################################################################
# OpenLP - Open Source Lyrics Projection                                      #
# --------------------------------------------------------------------------- #
# Copyright (c) 2008-2018 OpenLP Developers                                   #
# --------------------------------------------------------------------------- #
# This program is free software; you can redistribute it and/or modify it     #
# under the terms of the GNU General Public License as published by the Free  #
# Software Foundation; version 2 of the License.                              #
#                                                                             #
# This program 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 General Public License for    #
# more details.                                                               #
#                                                                             #
# You should have received a copy of the GNU General Public License along     #
# with this program; if not, write to the Free Software Foundation, Inc., 59  #
# Temple Place, Suite 330, Boston, MA 02111-1307 USA                          #
###############################################################################
"""
The :mod:`screen` module provides management functionality for a machines'
displays.
"""
import logging

from PyQt5 import QtCore

from openlp.core.common.i18n import translate
from openlp.core.common.registry import Registry
from openlp.core.common.settings import Settings

log = logging.getLogger(__name__)


class Screen(object):
    """
    A Python representation of a screen
    """
    def __init__(self, number=None, geometry=None, is_primary=False, is_display=False):
        """
        Set up the screen object

        :param int number: The Qt number of this screen
        :param QRect geometry: The geometry of this screen as a QRect object
        :param bool is_primary: Whether or not this screen is the primary screen
        :param bool is_display: Whether or not this screen should be used to display lyrics
        """
        self.number = number
        self.geometry = geometry
        self.display_geometry = geometry
        self.is_primary = is_primary
        self.is_display = is_display

    def __str__(self):
        """
        Return a string for displaying this screen

        :return str: A nicely formatted string
        """
        name = '{screen} {number:d}'.format(screen=translate('OpenLP.ScreenList', 'Screen'), number=self.number + 1)
        if self.is_primary:
            name = '{name} ({primary})'.format(name=name, primary=translate('OpenLP.ScreenList', 'primary'))
        return name

    @classmethod
    def from_dict(cls, screen_dict):
        """
        Create a screen object from a dictionary

        :param dict screen_dict: The dictionary from which to make the Screen object
        :return: A Screen object with the values from screen_dict
        :rtype: openlp.core.display.screens.Screen
        """
        screen_dict['geometry'] = QtCore.QRect(**screen_dict['geometry'])
        if 'display_geometry' in screen_dict:
            screen_dict['display_geometry'] = QtCore.QRect(**screen_dict['display_geometry'])
        return cls(**screen_dict)

    def to_dict(self):
        """
        Convert a screen object to a dictionary

        :return: A dictionary of this screen
        :rtype: dict
        """
        screen_dict = {
            'number': self.number,
            'geometry': {
                'x': self.geometry.x(),
                'y': self.geometry.y(),
                'width': self.geometry.width(),
                'height': self.geometry.height()
            },
            'is_primary': self.is_primary,
            'is_display': self.is_display
        }
        if self.display_geometry != self.geometry:
            screen_dict['display_geometry'] = {
                'x': self.display_geometry.x(),
                'y': self.display_geometry.y(),
                'width': self.display_geometry.width(),
                'height': self.display_geometry.height()
            }
        return screen_dict

    def update(self, screen_dict):
        """
        Update this instance from a dictionary

        :param dict screen_dict: The dictionary which we want to apply to the screen
        """
        self.number = screen_dict['number']
        self.is_display = screen_dict['is_display']
        self.is_primary = screen_dict['is_primary']
        self.geometry = QtCore.QRect(**screen_dict['geometry'])


class ScreenList(object):
    """
    Wrapper to handle the parameters of the display screen.

    To get access to the screen list call ``ScreenList()``.
    """
    log.info('Screen loaded')
    __instance__ = None
    screens = []

    def __new__(cls):
        """
        Re-implement __new__ to create a true singleton.
        """
        if not cls.__instance__:
            cls.__instance__ = object.__new__(cls)
        return cls.__instance__

    def __iter__(self):
        """
        Convert this object into an iterable, so that we can iterate over it instead of the inner list
        """
        for screen in self.screens:
            yield screen

    def __getitem__(self, key):
        """
        Make sure this object is indexable, e.g. screen_list[1] => Screen(number=1)
        """
        for screen in self:
            if screen.number == key:
                return screen
        else:
            raise IndexError('No screen with number {number} in list'.format(number=key))

    def __len__(self):
        """
        Make sure we can call "len" on this object
        """
        return len(self.screens)

    @property
    def current(self):
        """
        Return the first "current" desktop

        NOTE: This is a HACK to ease the upgrade process
        """
        # Get the first display screen
        for screen in self.screens:
            if screen.is_display:
                return screen
        # If there's no display screen, get the first primary screen
        for screen in self.screens:
            if screen.is_primary:
                return screen
        # Otherwise just return the first screen
        if len(self.screens) > 0:
            return self.screens[0]
        else:
            return None

    @classmethod
    def create(cls, desktop):
        """
        Initialise the screen list.

        :param desktop:  A QDesktopWidget object.
        """
        screen_list = cls()
        screen_list.desktop = desktop
        screen_list.desktop.resized.connect(screen_list.on_screen_resolution_changed)
        screen_list.desktop.screenCountChanged.connect(screen_list.on_screen_count_changed)
        screen_list.desktop.primaryScreenChanged.connect(screen_list.on_primary_screen_changed)
        screen_list.update_screens()
        screen_list.load_screen_settings()
        return screen_list

    def load_screen_settings(self):
        """
        Loads the screen size and the monitor number from the settings.
        """
        # Add the screen settings to the settings dict. This has to be done here due to cyclic dependency.
        # Do not do this anywhere else.
        screen_settings = {
            'core/monitors': '{}'
        }
        Settings.extend_default_settings(screen_settings)
        monitors = Settings().value('core/monitors')
        # for number, monitor in monitors.items():
        #     if self.has_screen(number):
        #         self[number].update(monitor)
        #     else:
        #         self.screens.append(Screen.from_dict(monitor))

    def save_screen_settings(self):
        """
        Saves the screen size and monitor settings
        """
        Settings().setValue('core/monitors', {screen.number: screen.to_dict() for screen in self.screens})

    def get_display_screen_list(self):
        """
        Returns a list with the screens. This should only be used to display available screens to the user::

            ['Screen 1 (primary)', 'Screen 2']
        """
        screen_list = []
        for screen in self.screens:
            screen_name = '{name} {number:d}'.format(name=translate('OpenLP.ScreenList', 'Screen'),
                                                     number=screen.number + 1)
            if screen.is_primary:
                screen_name = '{name} ({primary})'.format(name=screen_name,
                                                          primary=translate('OpenLP.ScreenList', 'primary'))
            screen_list.append(screen_name)
        return screen_list

    def get_number_for_window(self, window):
        """
        Return the screen number that the centre of the passed window is in.

        :param window: A QWidget we are finding the location of.
        """
        for screen in self.screens:
            if screen.geometry == window.geometry() or screen.display_geometry == window.geometry():
                return screen
        return None

    def set_display_screen(self, number, can_save=False):
        """
        Set screen number ``number`` to be the display screen.

        At the moment, this is forced to be only a single screen, but later when we support multiple monitors it
        will need to be updated.

        :param int number: The number of the screen
        :param bool can_save: If the screen settings should be saved, defaults to False.
        """
        for screen in self.screens:
            if screen.number == number:
                screen.is_display = True
            else:
                screen.is_display = False
        if can_save:
            self.save_screen_settings()

    def has_screen(self, number):
        """
        Confirms a screen is known.

        :param number: The screen number (int).
        """
        for screen in self.screens:
            if screen.number == number:
                return True
        return False

    def update_screens(self):
        """
        Update the list of screens
        """
        self.screens = []
        for number in range(self.desktop.screenCount()):
            self.screens.append(
                Screen(number, self.desktop.screenGeometry(number), self.desktop.primaryScreen() == number))

    def on_screen_resolution_changed(self, number):
        """
        Called when the resolution of a screen has changed.

        ``number``
            The number of the screen, which size has changed.
        """
        log.info('screen_resolution_changed {number:d}'.format(number=number))
        for screen in self.screens:
            if number == screen.number:
                screen.geometry = self.desktop.screenGeometry(number)
                screen.is_primary = self.desktop.primaryScreen() == number
                Registry().execute('config_screen_changed')
                break

    def on_screen_count_changed(self, changed_screen=None):
        """
        Called when a screen has been added or removed.

        ``changed_screen``
            The screen's number which has been (un)plugged.
        """
        screen_count = self.desktop.screenCount()
        log.info('screen_count_changed {count:d}'.format(count=screen_count))
        # Update the list of screens
        self.update_screens()
        # Reload setting tabs to apply possible changes.
        Registry().execute('config_screen_changed')

    def on_primary_screen_changed(self):
        """
        The primary screen has changed, let's sort it out and then notify everyone
        """
        for screen in self.screens:
            screen.is_primary = self.desktop.primaryScreen() == screen.number
        Registry().execute('config_screen_changed')