# -*- 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)

"""
QwtScaleEngine
--------------

.. autoclass:: QwtScaleEngine
   :members:

QwtLinearScaleEngine
--------------------

.. autoclass:: QwtLinearScaleEngine
   :members:

QwtLogScaleEngine
-----------------

.. autoclass:: QwtLogScaleEngine
   :members:
"""

import math
import sys

import numpy as np
from qtpy.QtCore import qFuzzyCompare

from qwt._math import qwtFuzzyCompare
from qwt.interval import QwtInterval
from qwt.scale_div import QwtScaleDiv
from qwt.transform import QwtLogTransform, QwtTransform

DBL_MAX = sys.float_info.max
LOG_MIN = 1.0e-150
LOG_MAX = 1.0e150


def qwtLogInterval(base, interval):
    return QwtInterval(
        math.log(interval.minValue(), base), math.log(interval.maxValue(), base)
    )


def qwtPowInterval(base, interval):
    return QwtInterval(
        math.pow(base, interval.minValue()), math.pow(base, interval.maxValue())
    )


def qwtStepSize(intervalSize, maxSteps, base):
    """this version often doesn't find the best ticks: f.e for 15: 5, 10"""
    minStep = divideInterval(intervalSize, maxSteps, base)
    if minStep != 0.0:
        #  # ticks per interval
        numTicks = math.ceil(abs(intervalSize / minStep)) - 1
        #  Do the minor steps fit into the interval?
        if (
            qwtFuzzyCompare(
                (numTicks + 1) * abs(minStep), abs(intervalSize), intervalSize
            )
            > 0
        ):
            #  The minor steps doesn't fit into the interval
            return 0.5 * intervalSize
    return minStep


EPS = 1.0e-6


def ceilEps(value, intervalSize):
    """
    Ceil a value, relative to an interval

    :param float value: Value to be ceiled
    :param float intervalSize: Interval size
    :return: Rounded value

    .. seealso::

        :py:func:`qwt.scale_engine.floorEps()`
    """
    eps = EPS * intervalSize
    value = (value - eps) / intervalSize
    return math.ceil(value) * intervalSize


def floorEps(value, intervalSize):
    """
    Floor a value, relative to an interval

    :param float value: Value to be floored
    :param float intervalSize: Interval size
    :return: Rounded value

    .. seealso::

        :py:func:`qwt.scale_engine.ceilEps()`
    """
    eps = EPS * intervalSize
    value = (value + eps) / intervalSize
    return math.floor(value) * intervalSize


def divideEps(intervalSize, numSteps):
    """
    Divide an interval into steps

    `stepSize = (intervalSize - intervalSize * 10**-6) / numSteps`

    :param float intervalSize: Interval size
    :param float numSteps: Number of steps
    :return: Step size
    """
    if numSteps == 0.0 or intervalSize == 0.0:
        return 0.0
    return (intervalSize - (EPS * intervalSize)) / numSteps


def divideInterval(intervalSize, numSteps, base):
    """
    Calculate a step size for a given interval

    :param float intervalSize: Interval size
    :param float numSteps: Number of steps
    :param int base: Base for the division (usually 10)
    :return: Calculated step size
    """
    if numSteps <= 0:
        return 0.0
    v = divideEps(intervalSize, numSteps)
    if v == 0.0:
        return 0.0

    lx = math.log(abs(v), base)
    p = math.floor(lx)
    fraction = math.pow(base, lx - p)
    n = base
    while n > 1 and fraction <= n // 2:
        n //= 2

    stepSize = n * math.pow(base, p)
    if v < 0:
        stepSize = -stepSize

    return stepSize


class QwtScaleEngine_PrivateData(object):
    def __init__(self):
        self.attributes = QwtScaleEngine.NoAttribute
        self.lowerMargin = 0.0
        self.upperMargin = 0.0
        self.referenceValue = 0.0
        self.base = 10
        self.transform = None  # QwtTransform


class QwtScaleEngine(object):
    """
    Base class for scale engines.

    A scale engine tries to find "reasonable" ranges and step sizes
    for scales.

    The layout of the scale can be varied with `setAttribute()`.

    `PythonQwt` offers implementations for logarithmic and linear scales.

    Layout attributes:

      * `QwtScaleEngine.NoAttribute`: No attributes
      * `QwtScaleEngine.IncludeReference`: Build a scale which includes the
        `reference()` value
      * `QwtScaleEngine.Symmetric`: Build a scale which is symmetric to the
        `reference()` value
      * `QwtScaleEngine.Floating`: The endpoints of the scale are supposed to
        be equal the outmost included values plus the specified margins (see
        `setMargins()`). If this attribute is *not* set, the endpoints of the
        scale will be integer multiples of the step size.
      * `QwtScaleEngine.Inverted`: Turn the scale upside down
    """

    # enum Attribute
    NoAttribute = 0x00
    IncludeReference = 0x01
    Symmetric = 0x02
    Floating = 0x04
    Inverted = 0x08

    def __init__(self, base=10):
        self.__data = QwtScaleEngine_PrivateData()
        self.setBase(base)

    def autoScale(self, maxNumSteps, x1, x2, stepSize, relativeMargin=0.0):
        """
        Align and divide an interval

        :param int maxNumSteps: Max. number of steps
        :param float x1: First limit of the interval (In/Out)
        :param float x2: Second limit of the interval (In/Out)
        :param float stepSize: Step size
        :param float relativeMargin: Margin as a fraction of the interval width
        :return: tuple (x1, x2, stepSize)
        """
        pass

    def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.0):
        """
        Calculate a scale division

        :param float x1: First interval limit
        :param float x2: Second interval limit
        :param int maxMajorSteps: Maximum for the number of major steps
        :param int maxMinorSteps: Maximum number of minor steps
        :param float stepSize: Step size. If stepSize == 0.0, the scaleEngine calculates one
        :return: Calculated scale division
        """
        pass

    def setTransformation(self, transform):
        """
        Assign a transformation

        :param qwt.transform.QwtTransform transform: Transformation

        The transformation object is used as factory for clones
        that are returned by `transformation()`

        The scale engine takes ownership of the transformation.

        .. seealso::

            :py:meth:`QwtTransform.copy()`, :py:meth:`transformation()`
        """
        assert transform is None or isinstance(transform, QwtTransform)
        if transform != self.__data.transform:
            self.__data.transform = transform

    def transformation(self):
        """
        Create and return a clone of the transformation
        of the engine. When the engine has no special transformation
        None is returned, indicating no transformation.

        :return: A clone of the transfomation

        .. seealso::

            :py:meth:`setTransformation()`
        """
        if self.__data.transform:
            return self.__data.transform.copy()

    def lowerMargin(self):
        """
        :return: the margin at the lower end of the scale

        The default margin is 0.

        .. seealso::

            :py:meth:`setMargins()`
        """
        return self.__data.lowerMargin

    def upperMargin(self):
        """
        :return: the margin at the upper end of the scale

        The default margin is 0.

        .. seealso::

            :py:meth:`setMargins()`
        """
        return self.__data.upperMargin

    def setMargins(self, lower, upper):
        """
        Specify margins at the scale's endpoints

        :param float lower: minimum distance between the scale's lower boundary and the smallest enclosed value
        :param float upper: minimum distance between the scale's upper boundary and the greatest enclosed value
        :return: A clone of the transfomation

        Margins can be used to leave a minimum amount of space between
        the enclosed intervals and the boundaries of the scale.

        .. warning::

            `QwtLogScaleEngine` measures the margins in decades.

        .. seealso::

            :py:meth:`upperMargin()`, :py:meth:`lowerMargin()`
        """
        self.__data.lowerMargin = max([lower, 0.0])
        self.__data.upperMargin = max([upper, 0.0])

    def divideInterval(self, intervalSize, numSteps):
        """
        Calculate a step size for a given interval

        :param float intervalSize: Interval size
        :param float numSteps: Number of steps
        :return: Step size
        """
        return divideInterval(intervalSize, numSteps, self.__data.base)

    def contains(self, interval, value):
        """
        Check if an interval "contains" a value

        :param float intervalSize: Interval size
        :param float value: Value
        :return: True, when the value is inside the interval
        """
        if not interval.isValid():
            return False
        eps = abs(1.0e-6 * interval.width())
        if interval.minValue() - value > eps or value - interval.maxValue() > eps:
            return False
        else:
            return True

    def strip(self, ticks, interval):
        """
        Remove ticks from a list, that are not inside an interval

        :param list ticks: Tick list
        :param qwt.interval.QwtInterval interval: Interval
        :return: Stripped tick list
        """
        if not interval.isValid() or not ticks:
            return []
        if self.contains(interval, ticks[0]) and self.contains(interval, ticks[-1]):
            return ticks
        return [tick for tick in ticks if self.contains(interval, tick)]

    def buildInterval(self, value):
        """
        Build an interval around a value

        In case of v == 0.0 the interval is [-0.5, 0.5],
        otherwide it is [0.5 * v, 1.5 * v]

        :param float value: Initial value
        :return: Calculated interval
        """
        if value == 0.0:
            delta = 0.5
        else:
            delta = abs(0.5 * value)
        if DBL_MAX - delta < value:
            return QwtInterval(DBL_MAX - delta, DBL_MAX)
        if -DBL_MAX + delta > value:
            return QwtInterval(-DBL_MAX, -DBL_MAX + delta)
        return QwtInterval(value - delta, value + delta)

    def setAttribute(self, attribute, on=True):
        """
        Change a scale attribute

        :param int attribute: Attribute to change
        :param bool on: On/Off
        :return: Calculated interval

        .. seealso::

            :py:meth:`testAttribute()`
        """
        if on:
            self.__data.attributes |= attribute
        else:
            self.__data.attributes &= ~attribute

    def testAttribute(self, attribute):
        """
        :param int attribute: Attribute to be tested
        :return: True, if attribute is enabled

        .. seealso::

            :py:meth:`setAttribute()`
        """
        return self.__data.attributes & attribute

    def setAttributes(self, attributes):
        """
        Change the scale attribute

        :param attributes: Set scale attributes

        .. seealso::

            :py:meth:`attributes()`
        """
        self.__data.attributes = attributes

    def attributes(self):
        """
        :return: Scale attributes

        .. seealso::

            :py:meth:`setAttributes()`, :py:meth:`testAttribute()`
        """
        return self.__data.attributes

    def setReference(self, r):
        """
        Specify a reference point

        :param float r: new reference value

        The reference point is needed if options `IncludeReference` or
        `Symmetric` are active. Its default value is 0.0.
        """
        self.__data.referenceValue = r

    def reference(self):
        """
        :return: the reference value

        .. seealso::

            :py:meth:`setReference()`, :py:meth:`setAttribute()`
        """
        return self.__data.referenceValue

    def setBase(self, base):
        """
        Set the base of the scale engine

        While a base of 10 is what 99.9% of all applications need
        certain scales might need a different base: f.e 2

        The default setting is 10

        :param int base: Base of the engine

        .. seealso::

            :py:meth:`base()`
        """
        self.__data.base = max([base, 2])

    def base(self):
        """
        :return: Base of the scale engine

        .. seealso::

            :py:meth:`setBase()`
        """
        return self.__data.base


class QwtLinearScaleEngine(QwtScaleEngine):
    r"""
    A scale engine for linear scales

    The step size will fit into the pattern
    \f$\left\{ 1,2,5\right\} \cdot 10^{n}\f$, where n is an integer.
    """

    def __init__(self, base=10):
        super(QwtLinearScaleEngine, self).__init__(base)

    def autoScale(self, maxNumSteps, x1, x2, stepSize, relativeMargin=0.0):
        """
        Align and divide an interval

        :param int maxNumSteps: Max. number of steps
        :param float x1: First limit of the interval (In/Out)
        :param float x2: Second limit of the interval (In/Out)
        :param float stepSize: Step size
        :param float relativeMargin: Margin as a fraction of the interval width
        :return: tuple (x1, x2, stepSize)

        .. seealso::

            :py:meth:`setAttribute()`
        """
        # Apply the relative margin (fraction of the interval width) in linear space:
        if relativeMargin > 0.0:
            margin = (x2 - x1) * relativeMargin
            x1 -= margin
            x2 += margin

        interval = QwtInterval(x1, x2)
        interval = interval.normalized()
        interval.setMinValue(interval.minValue() - self.lowerMargin())
        interval.setMaxValue(interval.maxValue() + self.upperMargin())
        if self.testAttribute(QwtScaleEngine.Symmetric):
            interval = interval.symmetrize(self.reference())
        if self.testAttribute(QwtScaleEngine.IncludeReference):
            interval = interval.extend(self.reference())
        if interval.width() == 0.0:
            interval = self.buildInterval(interval.minValue())
        stepSize = divideInterval(interval.width(), max([maxNumSteps, 1]), self.base())
        if not self.testAttribute(QwtScaleEngine.Floating):
            interval = self.align(interval, stepSize)
        x1 = interval.minValue()
        x2 = interval.maxValue()
        if self.testAttribute(QwtScaleEngine.Inverted):
            x1, x2 = x2, x1
            stepSize = -stepSize
        return x1, x2, stepSize

    def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.0):
        """
        Calculate a scale division for an interval

        :param float x1: First interval limit
        :param float x2: Second interval limit
        :param int maxMajorSteps: Maximum for the number of major steps
        :param int maxMinorSteps: Maximum number of minor steps
        :param float stepSize: Step size. If stepSize == 0.0, the scaleEngine calculates one
        :return: Calculated scale division
        """
        interval = QwtInterval(x1, x2).normalized()
        if interval.width() <= 0:
            return QwtScaleDiv()
        stepSize = abs(stepSize)
        if stepSize == 0.0:
            if maxMajorSteps < 1:
                maxMajorSteps = 1
            stepSize = divideInterval(interval.width(), maxMajorSteps, self.base())
        scaleDiv = QwtScaleDiv()
        if stepSize != 0.0:
            ticks = self.buildTicks(interval, stepSize, maxMinorSteps)
            scaleDiv = QwtScaleDiv(interval, ticks)
        if x1 > x2:
            scaleDiv.invert()
        return scaleDiv

    def buildTicks(self, interval, stepSize, maxMinorSteps):
        """
        Calculate ticks for an interval

        :param qwt.interval.QwtInterval interval: Interval
        :param float stepSize: Step size
        :param int maxMinorSteps: Maximum number of minor steps
        :return: Calculated ticks
        """
        ticks = [[] for _i in range(QwtScaleDiv.NTickTypes)]
        boundingInterval = self.align(interval, stepSize)
        ticks[QwtScaleDiv.MajorTick] = self.buildMajorTicks(boundingInterval, stepSize)
        if maxMinorSteps > 0:
            self.buildMinorTicks(ticks, maxMinorSteps, stepSize)
        for i in range(QwtScaleDiv.NTickTypes):
            ticks[i] = self.strip(ticks[i], interval)
            for j in range(len(ticks[i])):
                if qwtFuzzyCompare(ticks[i][j], 0.0, stepSize) == 0:
                    ticks[i][j] = 0.0
        return ticks

    def buildMajorTicks(self, interval, stepSize):
        """
        Calculate major ticks for an interval

        :param qwt.interval.QwtInterval interval: Interval
        :param float stepSize: Step size
        :return: Calculated ticks
        """
        numTicks = min([round(interval.width() / stepSize) + 1, 10000])
        if np.isnan(numTicks):
            numTicks = 0
        ticks = [interval.minValue()]
        for i in range(1, int(numTicks - 1)):
            ticks += [interval.minValue() + i * stepSize]
        ticks += [interval.maxValue()]
        return ticks

    def buildMinorTicks(self, ticks, maxMinorSteps, stepSize):
        """
        Calculate minor ticks for an interval

        :param list ticks: Major ticks (returned)
        :param int maxMinorSteps: Maximum number of minor steps
        :param float stepSize: Step size
        """
        minStep = qwtStepSize(stepSize, maxMinorSteps, self.base())
        if minStep == 0.0:
            return
        numTicks = int(math.ceil(abs(stepSize / minStep)) - 1)
        medIndex = -1
        if numTicks % 2:
            medIndex = numTicks / 2
        for val in ticks[QwtScaleDiv.MajorTick]:
            for k in range(numTicks):
                val += minStep
                alignedValue = val
                if qwtFuzzyCompare(val, 0.0, stepSize) == 0:
                    alignedValue = 0.0
                if k == medIndex:
                    ticks[QwtScaleDiv.MediumTick] += [alignedValue]
                else:
                    ticks[QwtScaleDiv.MinorTick] += [alignedValue]

    def align(self, interval, stepSize):
        """
        Align an interval to a step size

        The limits of an interval are aligned that both are integer
        multiples of the step size.

        :param qwt.interval.QwtInterval interval: Interval
        :param float stepSize: Step size
        :return: Aligned interval
        """
        x1 = interval.minValue()
        x2 = interval.maxValue()
        eps = 0.000000000001
        if -DBL_MAX + stepSize <= x1:
            x = floorEps(x1, stepSize)
            if abs(x) <= eps or not qFuzzyCompare(x1, x):
                x1 = x
        if DBL_MAX - stepSize >= x2:
            x = ceilEps(x2, stepSize)
            if abs(x) <= eps or not qFuzzyCompare(x2, x):
                x2 = x
        return QwtInterval(x1, x2)


class QwtLogScaleEngine(QwtScaleEngine):
    """
    A scale engine for logarithmic scales

    The step size is measured in *decades* and the major step size will be
    adjusted to fit the pattern {1,2,3,5}.10**n, where n is a natural number
    including zero.

    .. warning::

        The step size as well as the margins are measured in *decades*.
    """

    def __init__(self, base=10):
        super(QwtLogScaleEngine, self).__init__(base)
        self.setTransformation(QwtLogTransform())

    def autoScale(self, maxNumSteps, x1, x2, stepSize, relativeMargin=0.0):
        """
        Align and divide an interval

        :param int maxNumSteps: Max. number of steps
        :param float x1: First limit of the interval (In/Out)
        :param float x2: Second limit of the interval (In/Out)
        :param float stepSize: Step size
        :param float relativeMargin: Margin as a fraction of the interval width
        :return: tuple (x1, x2, stepSize)

        .. seealso::

            :py:meth:`setAttribute()`
        """
        if x1 > x2:
            x1, x2 = x2, x1
        logBase = self.base()

        # Apply the relative margin (fraction of the interval width) in logarithmic
        # space, and convert back to linear space.
        if relativeMargin is not None:
            x1 = min(max([x1, LOG_MIN]), LOG_MAX)
            x2 = min(max([x2, LOG_MIN]), LOG_MAX)
            log_margin = math.log(x2 / x1, logBase) * relativeMargin
            x1 /= math.pow(logBase, log_margin)
            x2 *= math.pow(logBase, log_margin)

        interval = QwtInterval(
            x1 / math.pow(logBase, self.lowerMargin()),
            x2 * math.pow(logBase, self.upperMargin()),
        )
        if interval.maxValue() / interval.minValue() < logBase:
            linearScaler = QwtLinearScaleEngine()
            linearScaler.setAttributes(self.attributes())
            linearScaler.setReference(self.reference())
            linearScaler.setMargins(self.lowerMargin(), self.upperMargin())

            x1, x2, stepSize = linearScaler.autoScale(maxNumSteps, x1, x2, stepSize)

            linearInterval = QwtInterval(x1, x2).normalized()
            linearInterval = linearInterval.limited(LOG_MIN, LOG_MAX)

            if linearInterval.maxValue() / linearInterval.minValue() < logBase:
                # The min / max interval is too short to be represented as a log scale.
                # Set the step to 0, so that a new step is calculated and a linear scale is used.
                stepSize = 0.0
                return x1, x2, stepSize

        logRef = 1.0
        if self.reference() > LOG_MIN / 2:
            logRef = min([self.reference(), LOG_MAX / 2])

        if self.testAttribute(QwtScaleEngine.Symmetric):
            delta = max([interval.maxValue() / logRef, logRef / interval.minValue()])
            interval.setInterval(logRef / delta, logRef * delta)

        if self.testAttribute(QwtScaleEngine.IncludeReference):
            interval = interval.extend(logRef)

        interval = interval.limited(LOG_MIN, LOG_MAX)

        if interval.width() == 0.0:
            interval = self.buildInterval(interval.minValue())

        stepSize = self.divideInterval(
            qwtLogInterval(logBase, interval).width(), max([maxNumSteps, 1])
        )
        if stepSize < 1.0:
            stepSize = 1.0

        if not self.testAttribute(QwtScaleEngine.Floating):
            interval = self.align(interval, stepSize)

        x1 = interval.minValue()
        x2 = interval.maxValue()

        if self.testAttribute(QwtScaleEngine.Inverted):
            x1, x2 = x2, x1
            stepSize = -stepSize

        return x1, x2, stepSize

    def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.0):
        """
        Calculate a scale division for an interval

        :param float x1: First interval limit
        :param float x2: Second interval limit
        :param int maxMajorSteps: Maximum for the number of major steps
        :param int maxMinorSteps: Maximum number of minor steps
        :param float stepSize: Step size. If stepSize == 0.0, the scaleEngine calculates one
        :return: Calculated scale division
        """
        interval = QwtInterval(x1, x2).normalized()
        interval = interval.limited(LOG_MIN, LOG_MAX)

        if interval.width() <= 0:
            return QwtScaleDiv()

        logBase = self.base()

        if interval.maxValue() / interval.minValue() < logBase:
            linearScaler = QwtLinearScaleEngine()
            linearScaler.setAttributes(self.attributes())
            linearScaler.setReference(self.reference())
            linearScaler.setMargins(self.lowerMargin(), self.upperMargin())
            return linearScaler.divideScale(
                x1, x2, maxMajorSteps, maxMinorSteps, stepSize
            )

        stepSize = abs(stepSize)
        if stepSize == 0.0:
            if maxMajorSteps < 1:
                maxMajorSteps = 1
            stepSize = self.divideInterval(
                qwtLogInterval(logBase, interval).width(), maxMajorSteps
            )
            if stepSize < 1.0:
                stepSize = 1.0

        scaleDiv = QwtScaleDiv()
        if stepSize != 0.0:
            ticks = self.buildTicks(interval, stepSize, maxMinorSteps)
            scaleDiv = QwtScaleDiv(interval, ticks)

        if x1 > x2:
            scaleDiv.invert()

        return scaleDiv

    def buildTicks(self, interval, stepSize, maxMinorSteps):
        """
        Calculate ticks for an interval

        :param qwt.interval.QwtInterval interval: Interval
        :param float stepSize: Step size
        :param int maxMinorSteps: Maximum number of minor steps
        :return: Calculated ticks
        """
        ticks = [[] for _i in range(QwtScaleDiv.NTickTypes)]
        boundingInterval = self.align(interval, stepSize)
        ticks[QwtScaleDiv.MajorTick] = self.buildMajorTicks(boundingInterval, stepSize)
        if maxMinorSteps > 0:
            self.buildMinorTicks(ticks, maxMinorSteps, stepSize)
        for i in range(QwtScaleDiv.NTickTypes):
            ticks[i] = self.strip(ticks[i], interval)
        return ticks

    def buildMajorTicks(self, interval, stepSize):
        """
        Calculate major ticks for an interval

        :param qwt.interval.QwtInterval interval: Interval
        :param float stepSize: Step size
        :return: Calculated ticks
        """
        width = qwtLogInterval(self.base(), interval).width()
        numTicks = min([int(round(width / stepSize)) + 1, 10000])

        lxmin = math.log(interval.minValue())
        lxmax = math.log(interval.maxValue())
        lstep = (lxmax - lxmin) / float(numTicks - 1)

        ticks = [interval.minValue()]
        for i in range(1, numTicks - 1):
            ticks += [math.exp(lxmin + float(i) * lstep)]
        ticks += [interval.maxValue()]
        return ticks

    def buildMinorTicks(self, ticks, maxMinorSteps, stepSize):
        """
        Calculate minor ticks for an interval

        :param list ticks: Major ticks (returned)
        :param int maxMinorSteps: Maximum number of minor steps
        :param float stepSize: Step size
        """
        logBase = self.base()

        if stepSize < 1.1:
            minStep = self.divideInterval(stepSize, maxMinorSteps + 1)
            if minStep == 0.0:
                return

            numSteps = int(round(stepSize / minStep))

            mediumTickIndex = -1
            if numSteps > 2 and numSteps % 2 == 0:
                mediumTickIndex = numSteps / 2

            for v in ticks[QwtScaleDiv.MajorTick]:
                s = logBase / numSteps
                if s >= 1.0:
                    if not qFuzzyCompare(s, 1.0):
                        ticks[QwtScaleDiv.MinorTick] += [v * s]
                    for j in range(2, numSteps):
                        ticks[QwtScaleDiv.MinorTick] += [v * j * s]
                else:
                    for j in range(1, numSteps):
                        tick = v + j * v * (logBase - 1) / numSteps
                        if j == mediumTickIndex:
                            ticks[QwtScaleDiv.MediumTick] += [tick]
                        else:
                            ticks[QwtScaleDiv.MinorTick] += [tick]

        else:
            minStep = self.divideInterval(stepSize, maxMinorSteps)
            if minStep == 0.0:
                return

            if minStep < 1.0:
                minStep = 1.0

            numTicks = int(round(stepSize / minStep)) - 1

            if qwtFuzzyCompare((numTicks + 1) * minStep, stepSize, stepSize) > 0:
                numTicks = 0

            if numTicks < 1:
                return

            mediumTickIndex = -1
            if numTicks > 2 and numTicks % 2:
                mediumTickIndex = numTicks / 2

            minFactor = max([math.pow(logBase, minStep), float(logBase)])

            for tick in ticks[QwtScaleDiv.MajorTick]:
                for j in range(numTicks):
                    tick *= minFactor
                    if j == mediumTickIndex:
                        ticks[QwtScaleDiv.MediumTick] += [tick]
                    else:
                        ticks[QwtScaleDiv.MinorTick] += [tick]

    def align(self, interval, stepSize):
        """
        Align an interval to a step size

        The limits of an interval are aligned that both are integer
        multiples of the step size.

        :param qwt.interval.QwtInterval interval: Interval
        :param float stepSize: Step size
        :return: Aligned interval
        """
        intv = qwtLogInterval(self.base(), interval)

        x1 = floorEps(intv.minValue(), stepSize)
        if qwtFuzzyCompare(interval.minValue(), x1, stepSize) == 0:
            x1 = interval.minValue()

        x2 = ceilEps(intv.maxValue(), stepSize)
        if qwtFuzzyCompare(interval.maxValue(), x2, stepSize) == 0:
            x2 = interval.maxValue()

        return qwtPowInterval(self.base(), QwtInterval(x1, x2))


class QwtDateTimeScaleEngine(QwtLinearScaleEngine):
    """
    A scale engine for datetime scales that creates intelligent time-based tick intervals.

    This engine calculates tick intervals that correspond to meaningful time units
    (seconds, minutes, hours, days, weeks, months, years) rather than arbitrary
    numerical spacing.
    """

    # Time intervals in seconds
    TIME_INTERVALS = [
        1,  # 1 second
        5,  # 5 seconds
        10,  # 10 seconds
        15,  # 15 seconds
        30,  # 30 seconds
        60,  # 1 minute
        2 * 60,  # 2 minutes
        5 * 60,  # 5 minutes
        10 * 60,  # 10 minutes
        15 * 60,  # 15 minutes
        30 * 60,  # 30 minutes
        60 * 60,  # 1 hour
        2 * 60 * 60,  # 2 hours
        3 * 60 * 60,  # 3 hours
        6 * 60 * 60,  # 6 hours
        12 * 60 * 60,  # 12 hours
        24 * 60 * 60,  # 1 day
        2 * 24 * 60 * 60,  # 2 days
        7 * 24 * 60 * 60,  # 1 week
        2 * 7 * 24 * 60 * 60,  # 2 weeks
        30 * 24 * 60 * 60,  # 1 month (approx)
        3 * 30 * 24 * 60 * 60,  # 3 months (approx)
        6 * 30 * 24 * 60 * 60,  # 6 months (approx)
        365 * 24 * 60 * 60,  # 1 year (approx)
    ]

    def __init__(self, base=10):
        super(QwtDateTimeScaleEngine, self).__init__(base)

    def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.0):
        """
        Calculate a scale division for a datetime interval

        :param float x1: First interval limit (Unix timestamp)
        :param float x2: Second interval limit (Unix timestamp)
        :param int maxMajorSteps: Maximum for the number of major steps
        :param int maxMinorSteps: Maximum number of minor steps
        :param float stepSize: Step size. If stepSize == 0.0, calculates intelligent datetime step
        :return: Calculated scale division
        """
        interval = QwtInterval(x1, x2).normalized()
        if interval.width() <= 0:
            return QwtScaleDiv()

        # If stepSize is provided and > 0, use parent implementation
        if stepSize > 0.0:
            return super(QwtDateTimeScaleEngine, self).divideScale(
                x1, x2, maxMajorSteps, maxMinorSteps, stepSize
            )

        # Calculate intelligent datetime step size
        duration = interval.width()  # Duration in seconds

        # Find the best time interval for the given duration and max steps
        best_step = self._find_best_time_step(duration, maxMajorSteps)

        # Use the calculated datetime step
        scaleDiv = QwtScaleDiv()
        if best_step > 0.0:
            ticks = self.buildTicks(interval, best_step, maxMinorSteps)
            scaleDiv = QwtScaleDiv(interval, ticks)

        if x1 > x2:
            scaleDiv.invert()

        return scaleDiv

    def _find_best_time_step(self, duration, max_steps):
        """
        Find the best time interval step for the given duration and maximum steps.

        :param float duration: Total duration in seconds
        :param int max_steps: Maximum number of major ticks
        :return: Best step size in seconds
        """
        if max_steps < 1:
            max_steps = 1

        # Calculate the target step size
        target_step = duration / max_steps

        # Find the time interval that is closest to our target
        best_step = self.TIME_INTERVALS[0]
        min_error = abs(target_step - best_step)

        for interval in self.TIME_INTERVALS:
            error = abs(target_step - interval)
            if error < min_error:
                min_error = error
                best_step = interval
            # If the interval is getting much larger than target, stop
            elif interval > target_step * 2:
                break

        return float(best_step)

    def buildMinorTicks(self, ticks, maxMinorSteps, stepSize):
        """
        Calculate minor ticks for datetime intervals

        :param list ticks: List of tick arrays
        :param int maxMinorSteps: Maximum number of minor steps
        :param float stepSize: Major tick step size
        """
        if maxMinorSteps < 1:
            return

        # For datetime, create intelligent minor tick intervals
        minor_step = self._get_minor_step(stepSize, maxMinorSteps)

        if minor_step <= 0:
            return

        major_ticks = ticks[QwtScaleDiv.MajorTick]
        if len(major_ticks) < 2:
            return

        minor_ticks = []

        # Generate minor ticks between each pair of major ticks
        for i in range(len(major_ticks) - 1):
            start = major_ticks[i]
            end = major_ticks[i + 1]

            # Add minor ticks between start and end
            current = start + minor_step
            while current < end:
                minor_ticks.append(current)
                current += minor_step

        ticks[QwtScaleDiv.MinorTick] = minor_ticks

    def _get_minor_step(self, major_step, max_minor_steps):
        """
        Calculate appropriate minor tick step size for datetime intervals

        :param float major_step: Major tick step size in seconds
        :param int max_minor_steps: Maximum number of minor steps
        :return: Minor tick step size in seconds
        """
        # Define sensible minor tick divisions for different time scales
        if major_step >= 365 * 24 * 60 * 60:  # 1 year or more
            return 30 * 24 * 60 * 60  # 1 month
        elif major_step >= 30 * 24 * 60 * 60:  # 1 month or more
            return 7 * 24 * 60 * 60  # 1 week
        elif major_step >= 7 * 24 * 60 * 60:  # 1 week or more
            return 24 * 60 * 60  # 1 day
        elif major_step >= 24 * 60 * 60:  # 1 day or more
            return 6 * 60 * 60  # 6 hours
        elif major_step >= 60 * 60:  # 1 hour or more
            return 15 * 60  # 15 minutes
        elif major_step >= 10 * 60:  # 10 minutes or more
            return 2 * 60  # 2 minutes
        elif major_step >= 60:  # 1 minute or more
            return 15  # 15 seconds
        elif major_step >= 10:  # 10 seconds or more
            return 2  # 2 seconds
        else:  # Less than 10 seconds
            return major_step / max(max_minor_steps, 2)