# -*- coding: utf-8 -*-
#
# Licensed under the terms of the Qwt License
# Copyright (c) 2002 Uwe Rathmann, for the original C++ code
# Copyright (c) 2015 Pierre Raybaut, for the Python translation/optimization
# (see LICENSE file for more details)

"""
QwtPlotGrid
-----------

.. autoclass:: QwtPlotGrid
   :members:
"""

from qtpy.QtCore import QLineF, QObject, Qt
from qtpy.QtGui import QPen

from qwt._math import qwtFuzzyGreaterOrEqual, qwtFuzzyLessOrEqual
from qwt.plot import QwtPlotItem
from qwt.qthelpers import qcolor_from_str
from qwt.scale_div import QwtScaleDiv


class QwtPlotGrid_PrivateData(QObject):
    def __init__(self):
        QObject.__init__(self)

        self.xEnabled = True
        self.yEnabled = True
        self.xMinEnabled = False
        self.yMinEnabled = False
        self.xScaleDiv = QwtScaleDiv()
        self.yScaleDiv = QwtScaleDiv()
        self.majorPen = QPen()
        self.minorPen = QPen()


class QwtPlotGrid(QwtPlotItem):
    """
    A class which draws a coordinate grid

    The `QwtPlotGrid` class can be used to draw a coordinate grid.
    A coordinate grid consists of major and minor vertical
    and horizontal grid lines. The locations of the grid lines
    are determined by the X and Y scale divisions which can
    be assigned with `setXDiv()` and `setYDiv()`.
    The `draw()` member draws the grid within a bounding
    rectangle.
    """

    def __init__(self, title="Grid"):
        QwtPlotItem.__init__(self, title)
        self.__data = QwtPlotGrid_PrivateData()
        self.setItemInterest(QwtPlotItem.ScaleInterest, True)
        self.setZ(10.0)

    @classmethod
    def make(
        cls,
        plot=None,
        z=None,
        enablemajor=None,
        enableminor=None,
        color=None,
        width=None,
        style=None,
        mincolor=None,
        minwidth=None,
        minstyle=None,
    ):
        """
        Create and setup a new `QwtPlotGrid` object (convenience function).

        :param plot: Plot to attach the curve to
        :type plot: qwt.plot.QwtPlot or None
        :param z: Z-value
        :type z: float or None
        :param enablemajor: Tuple of two boolean values (x, y) for enabling major grid lines
        :type enablemajor: bool or None
        :param enableminor: Tuple of two boolean values (x, y) for enabling minor grid lines
        :type enableminor: bool or None
        :param color: Pen color for both major and minor grid lines (default: Qt.gray)
        :type color: QColor or str or None
        :param width: Pen width for both major and minor grid lines (default: 1.0)
        :type width: float or None
        :param style: Pen style for both major and minor grid lines (default: Qt.DotLine)
        :type style: Qt.PenStyle or None
        :param mincolor: Pen color for minor grid lines only (default: Qt.gray)
        :type mincolor: QColor or str or None
        :param minwidth: Pen width for minor grid lines only (default: 1.0)
        :type minwidth: float or None
        :param minstyle: Pen style for minor grid lines only (default: Qt.DotLine)
        :type minstyle: Qt.PenStyle or None

        .. seealso::

            :py:meth:`setMinorPen()`, :py:meth:`setMajorPen()`
        """
        item = cls()
        if z is not None:
            item.setZ(z)
        color = qcolor_from_str(color, Qt.gray)
        width = 1.0 if width is None else float(width)
        style = Qt.DotLine if style is None else style
        item.setPen(QPen(color, width, style))
        if mincolor is not None or minwidth is not None or minstyle is not None:
            mincolor = qcolor_from_str(mincolor, Qt.gray)
            minwidth = 1.0 if width is None else minwidth
            minstyle = Qt.DotLine if style is None else minstyle
            item.setMinorPen(QPen(mincolor, minwidth, minstyle))
        if enablemajor is not None:
            if isinstance(enablemajor, tuple) and len(enablemajor) == 2:
                item.enableX(enablemajor[0])
                item.enableY(enablemajor[1])
            else:
                raise TypeError(
                    "Invalid enablemajor %r (expecting tuple of two booleans)"
                    % enablemajor
                )
        if enableminor is not None:
            if isinstance(enableminor, tuple) and len(enableminor) == 2:
                item.enableXMin(enableminor[0])
                item.enableYMin(enableminor[1])
            else:
                raise TypeError(
                    "Invalid enableminor %r (expecting tuple of two booleans)"
                    % enableminor
                )
        if plot is not None:
            item.attach(plot)
        return item

    def rtti(self):
        """
        :return: Return `QwtPlotItem.Rtti_PlotGrid`
        """
        return QwtPlotItem.Rtti_PlotGrid

    def enableX(self, on):
        """
        Enable or disable vertical grid lines

        :param bool on: Enable (true) or disable

        .. seealso::

            :py:meth:`enableXMin()`
        """
        if self.__data.xEnabled != on:
            self.__data.xEnabled = on
            self.legendChanged()
            self.itemChanged()

    def enableY(self, on):
        """
        Enable or disable horizontal grid lines

        :param bool on: Enable (true) or disable

        .. seealso::

            :py:meth:`enableYMin()`
        """
        if self.__data.yEnabled != on:
            self.__data.yEnabled = on
            self.legendChanged()
            self.itemChanged()

    def enableXMin(self, on):
        """
        Enable or disable  minor vertical grid lines.

        :param bool on: Enable (true) or disable

        .. seealso::

            :py:meth:`enableX()`
        """
        if self.__data.xMinEnabled != on:
            self.__data.xMinEnabled = on
            self.legendChanged()
            self.itemChanged()

    def enableYMin(self, on):
        """
        Enable or disable  minor horizontal grid lines.

        :param bool on: Enable (true) or disable

        .. seealso::

            :py:meth:`enableY()`
        """
        if self.__data.yMinEnabled != on:
            self.__data.yMinEnabled = on
            self.legendChanged()
            self.itemChanged()

    def setXDiv(self, scaleDiv):
        """
        Assign an x axis scale division

        :param qwt.scale_div.QwtScaleDiv scaleDiv: Scale division
        """
        if self.__data.xScaleDiv != scaleDiv:
            self.__data.xScaleDiv = scaleDiv
            self.itemChanged()

    def setYDiv(self, scaleDiv):
        """
        Assign an y axis scale division

        :param qwt.scale_div.QwtScaleDiv scaleDiv: Scale division
        """
        if self.__data.yScaleDiv != scaleDiv:
            self.__data.yScaleDiv = scaleDiv
            self.itemChanged()

    def setPen(self, *args):
        """
        Build and/or assign a pen for both major and minor grid lines

        .. py:method:: setPen(color, width, style)
            :noindex:

            Build and assign a pen for both major and minor grid lines

            In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
            non cosmetic (see `QPen.isCosmetic()`). This method signature has
            been introduced to hide this incompatibility.

            :param QColor color: Pen color
            :param float width: Pen width
            :param Qt.PenStyle style: Pen style

        .. py:method:: setPen(pen)
            :noindex:

            Assign a pen for both major and minor grid lines

            :param QPen pen: New pen

        .. seealso::

            :py:meth:`pen()`, :py:meth:`brush()`
        """
        if len(args) == 3:
            color, width, style = args
            self.setPen(QPen(color, width, style))
        elif len(args) == 1:
            (pen,) = args
            if self.__data.majorPen != pen or self.__data.minorPen != pen:
                self.__data.majorPen = pen
                self.__data.minorPen = pen
                self.legendChanged()
                self.itemChanged()
        else:
            raise TypeError(
                "%s().setPen() takes 1 or 3 argument(s) (%s given)"
                % (self.__class__.__name__, len(args))
            )

    def setMajorPen(self, *args):
        """
        Build and/or assign a pen for both major grid lines

        .. py:method:: setMajorPen(color, width, style)
            :noindex:

            Build and assign a pen for both major grid lines

            In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
            non cosmetic (see `QPen.isCosmetic()`). This method signature has
            been introduced to hide this incompatibility.

            :param QColor color: Pen color
            :param float width: Pen width
            :param Qt.PenStyle style: Pen style

        .. py:method:: setMajorPen(pen)
            :noindex:

            Assign a pen for the major grid lines

            :param QPen pen: New pen

        .. seealso::

            :py:meth:`majorPen()`, :py:meth:`setMinorPen()`,
            :py:meth:`setPen()`, :py:meth:`pen()`, :py:meth:`brush()`
        """
        if len(args) == 3:
            color, width, style = args
            self.setMajorPen(QPen(color, width, style))
        elif len(args) == 1:
            (pen,) = args
            if self.__data.majorPen != pen:
                self.__data.majorPen = pen
                self.legendChanged()
                self.itemChanged()
        else:
            raise TypeError(
                "%s().setMajorPen() takes 1 or 3 argument(s) (%s "
                "given)" % (self.__class__.__name__, len(args))
            )

    def setMinorPen(self, *args):
        """
        Build and/or assign a pen for both minor grid lines

        .. py:method:: setMinorPen(color, width, style)
            :noindex:

            Build and assign a pen for both minor grid lines

            In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
            non cosmetic (see `QPen.isCosmetic()`). This method signature has
            been introduced to hide this incompatibility.

            :param QColor color: Pen color
            :param float width: Pen width
            :param Qt.PenStyle style: Pen style

        .. py:method:: setMinorPen(pen)
            :noindex:

            Assign a pen for the minor grid lines

            :param QPen pen: New pen

        .. seealso::

            :py:meth:`minorPen()`, :py:meth:`setMajorPen()`,
            :py:meth:`setPen()`, :py:meth:`pen()`, :py:meth:`brush()`
        """
        if len(args) == 3:
            color, width, style = args
            self.setMinorPen(QPen(color, width, style))
        elif len(args) == 1:
            (pen,) = args
            if self.__data.minorPen != pen:
                self.__data.minorPen = pen
                self.legendChanged()
                self.itemChanged()
        else:
            raise TypeError(
                "%s().setMinorPen() takes 1 or 3 argument(s) (%s "
                "given)" % (self.__class__.__name__, len(args))
            )

    def draw(self, painter, xMap, yMap, canvasRect):
        """
        Draw the grid

        The grid is drawn into the bounding rectangle such that
        grid lines begin and end at the rectangle's borders. The X and Y
        maps are used to map the scale divisions into the drawing region
        screen.

        :param QPainter painter: Painter
        :param qwt.scale_map.QwtScaleMap xMap: X axis map
        :param qwt.scale_map.QwtScaleMap yMap: Y axis
        :param QRectF canvasRect: Contents rectangle of the plot canvas
        """
        minorPen = QPen(self.__data.minorPen)
        minorPen.setCapStyle(Qt.FlatCap)
        painter.setPen(minorPen)
        if self.__data.xEnabled and self.__data.xMinEnabled:
            self.drawLines(
                painter,
                canvasRect,
                Qt.Vertical,
                xMap,
                self.__data.xScaleDiv.ticks(QwtScaleDiv.MinorTick),
            )
            self.drawLines(
                painter,
                canvasRect,
                Qt.Vertical,
                xMap,
                self.__data.xScaleDiv.ticks(QwtScaleDiv.MediumTick),
            )
        if self.__data.yEnabled and self.__data.yMinEnabled:
            self.drawLines(
                painter,
                canvasRect,
                Qt.Horizontal,
                yMap,
                self.__data.yScaleDiv.ticks(QwtScaleDiv.MinorTick),
            )
            self.drawLines(
                painter,
                canvasRect,
                Qt.Horizontal,
                yMap,
                self.__data.yScaleDiv.ticks(QwtScaleDiv.MediumTick),
            )
        majorPen = QPen(self.__data.majorPen)
        majorPen.setCapStyle(Qt.FlatCap)
        painter.setPen(majorPen)
        if self.__data.xEnabled:
            self.drawLines(
                painter,
                canvasRect,
                Qt.Vertical,
                xMap,
                self.__data.xScaleDiv.ticks(QwtScaleDiv.MajorTick),
            )
        if self.__data.yEnabled:
            self.drawLines(
                painter,
                canvasRect,
                Qt.Horizontal,
                yMap,
                self.__data.yScaleDiv.ticks(QwtScaleDiv.MajorTick),
            )

    def drawLines(self, painter, canvasRect, orientation, scaleMap, values):
        x1 = canvasRect.left()
        x2 = canvasRect.right() - 1.0
        y1 = canvasRect.top()
        y2 = canvasRect.bottom() - 1.0
        for val in values:
            value = scaleMap.transform(val)
            if orientation == Qt.Horizontal:
                if qwtFuzzyGreaterOrEqual(value, y1) and qwtFuzzyLessOrEqual(value, y2):
                    painter.drawLine(QLineF(x1, value, x2, value))
            else:
                if qwtFuzzyGreaterOrEqual(value, x1) and qwtFuzzyLessOrEqual(value, x2):
                    painter.drawLine(QLineF(value, y1, value, y2))

    def majorPen(self):
        """
        :return: the pen for the major grid lines

        .. seealso::

            :py:meth:`setMajorPen()`, :py:meth:`setMinorPen()`,
            :py:meth:`setPen()`
        """
        return self.__data.majorPen

    def minorPen(self):
        """
        :return: the pen for the minor grid lines

        .. seealso::

            :py:meth:`setMinorPen()`, :py:meth:`setMajorPen()`,
            :py:meth:`setPen()`
        """
        return self.__data.minorPen

    def xEnabled(self):
        """
        :return: True if vertical grid lines are enabled

        .. seealso::

            :py:meth:`enableX()`
        """
        return self.__data.xEnabled

    def yEnabled(self):
        """
        :return: True if horizontal grid lines are enabled

        .. seealso::

            :py:meth:`enableY()`
        """
        return self.__data.yEnabled

    def xMinEnabled(self):
        """
        :return: True if minor vertical grid lines are enabled

        .. seealso::

            :py:meth:`enableXMin()`
        """
        return self.__data.xMinEnabled

    def yMinEnabled(self):
        """
        :return: True if minor horizontal grid lines are enabled

        .. seealso::

            :py:meth:`enableYMin()`
        """
        return self.__data.yMinEnabled

    def xScaleDiv(self):
        """
        :return: the scale division of the x axis
        """
        return self.__data.xScaleDiv

    def yScaleDiv(self):
        """
        :return: the scale division of the y axis
        """
        return self.__data.yScaleDiv

    def updateScaleDiv(self, xScaleDiv, yScaleDiv):
        """
        Update the grid to changes of the axes scale division

        :param qwt.scale_map.QwtScaleMap xMap: Scale division of the x-axis
        :param qwt.scale_map.QwtScaleMap yMap: Scale division of the y-axis

        .. seealso::

            :py:meth:`updateAxes()`
        """
        self.setXDiv(xScaleDiv)
        self.setYDiv(yScaleDiv)