# Source code for fontTools.pens.cu2quPen

    # Copyright 2016 Google Inc. All Rights Reserved.
    #
    # Licensed under the Apache License, Version 2.0 (the "License");
    # you may not use this file except in compliance with the License.
    # You may obtain a copy of the License at
    #
    #     http://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing, software
    # distributed under the License is distributed on an "AS IS" BASIS,
    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    # See the License for the specific language governing permissions and
    # limitations under the License.

    import operator
    from fontTools.cu2qu import curve_to_quadratic, curves_to_quadratic
    from fontTools.pens.basePen import decomposeSuperBezierSegment
    from fontTools.pens.filterPen import FilterPen
    from fontTools.pens.reverseContourPen import ReverseContourPen
    from fontTools.pens.pointPen import BasePointToSegmentPen
    from fontTools.pens.pointPen import ReverseContourPointPen

    class Cu2QuPen(FilterPen):
        """A filter pen to convert cubic bezier curves to quadratic b-splines
        using the FontTools SegmentPen protocol.

        Args:

            other_pen: another SegmentPen used to draw the transformed outline.
            max_err: maximum approximation error in font units. For optimal results,
                if you know the UPEM of the font, we recommend setting this to a
                value equal, or close to UPEM / 1000.
            reverse_direction: flip the contours' direction but keep starting point.
            stats: a dictionary counting the point numbers of quadratic segments.
            all_quadratic: if True (default), only quadratic b-splines are generated.
                if False, quadratic curves or cubic curves are generated depending
                on which one is more economical.
        """

        def __init__(
            self,
            other_pen,
            max_err,
            reverse_direction=False,
            stats=None,
            all_quadratic=True,
        ):
            if reverse_direction:
                other_pen = ReverseContourPen(other_pen)
            super().__init__(other_pen)
            self.max_err = max_err
            self.stats = stats
            self.all_quadratic = all_quadratic

        def _convert_curve(self, pt1, pt2, pt3):
            curve = (self.current_pt, pt1, pt2, pt3)
            result = curve_to_quadratic(curve, self.max_err, self.all_quadratic)
            if self.stats is not None:
                n = str(len(result) - 2)
                self.stats[n] = self.stats.get(n, 0) + 1
            if self.all_quadratic:
                self.qCurveTo(*result[1:])
            else:
                if len(result) == 3:
                    self.qCurveTo(*result[1:])
                else:
                    assert len(result) == 4
                    super().curveTo(*result[1:])

        def curveTo(self, *points):
            n = len(points)
            if n == 3:
                # this is the most common case, so we special-case it
                self._convert_curve(*points)
            elif n > 3:
                for segment in decomposeSuperBezierSegment(points):
                    self._convert_curve(*segment)
            else:
                self.qCurveTo(*points)

    class Cu2QuPointPen(BasePointToSegmentPen):
        """A filter pen to convert cubic bezier curves to quadratic b-splines
        using the FontTools PointPen protocol.

        Args:
            other_point_pen: another PointPen used to draw the transformed outline.
            max_err: maximum approximation error in font units. For optimal results,
                if you know the UPEM of the font, we recommend setting this to a
                value equal, or close to UPEM / 1000.
            reverse_direction: reverse the winding direction of all contours.
            stats: a dictionary counting the point numbers of quadratic segments.
            all_quadratic: if True (default), only quadratic b-splines are generated.
                if False, quadratic curves or cubic curves are generated depending
                on which one is more economical.
        """

        __points_required = {
            "move": (1, operator.eq),
            "line": (1, operator.eq),
            "qcurve": (2, operator.ge),
            "curve": (3, operator.eq),
        }

        def __init__(
            self,
            other_point_pen,
            max_err,
            reverse_direction=False,
            stats=None,
            all_quadratic=True,
        ):
            BasePointToSegmentPen.__init__(self)
            if reverse_direction:
                self.pen = ReverseContourPointPen(other_point_pen)
            else:
                self.pen = other_point_pen
            self.max_err = max_err
            self.stats = stats
            self.all_quadratic = all_quadratic

        def _flushContour(self, segments):
            assert len(segments) >= 1
            closed = segments[0][0] != "move"
            new_segments = []
            prev_points = segments[-1][1]
            prev_on_curve = prev_points[-1][0]
            for segment_type, points in segments:
                if segment_type == "curve":
                    for sub_points in self._split_super_bezier_segments(points):
                        on_curve, smooth, name, kwargs = sub_points[-1]
                        bcp1, bcp2 = sub_points[0][0], sub_points[1][0]
                        cubic = [prev_on_curve, bcp1, bcp2, on_curve]
                        quad = curve_to_quadratic(cubic, self.max_err, self.all_quadratic)
                        if self.stats is not None:
                            n = str(len(quad) - 2)
                            self.stats[n] = self.stats.get(n, 0) + 1
                        new_points = [(pt, False, None, {}) for pt in quad[1:-1]]
                        new_points.append((on_curve, smooth, name, kwargs))
                        if self.all_quadratic or len(new_points) == 2:
                            new_segments.append(["qcurve", new_points])
                        else:
                            new_segments.append(["curve", new_points])
                        prev_on_curve = sub_points[-1][0]
                else:
                    new_segments.append([segment_type, points])
                    prev_on_curve = points[-1][0]
            if closed:
                # the BasePointToSegmentPen.endPath method that calls _flushContour
                # rotates the point list of closed contours so that they end with
                # the first on-curve point. We restore the original starting point.
                new_segments = new_segments[-1:] + new_segments[:-1]
            self._drawPoints(new_segments)

        def _split_super_bezier_segments(self, points):
            sub_segments = []
            # n is the number of control points
            n = len(points) - 1
            if n == 2:
                # a simple bezier curve segment
                sub_segments.append(points)
            elif n > 2:
                # a "super" bezier; decompose it
                on_curve, smooth, name, kwargs = points[-1]
                num_sub_segments = n - 1
                for i, sub_points in enumerate(
                    decomposeSuperBezierSegment([pt for pt, _, _, _ in points])
                ):
                    new_segment = []
                    for point in sub_points[:-1]:
                        new_segment.append((point, False, None, {}))
                    if i == (num_sub_segments - 1):
                        # the last on-curve keeps its original attributes
                        new_segment.append((on_curve, smooth, name, kwargs))
                    else:
                        # on-curves of sub-segments are always "smooth"
                        new_segment.append((sub_points[-1], True, None, {}))
                    sub_segments.append(new_segment)
            else:
                raise AssertionError("expected 2 control points, found: %d" % n)
            return sub_segments

        def _drawPoints(self, segments):
            pen = self.pen
            pen.beginPath()
            last_offcurves = []
            points_required = self.__points_required
            for i, (segment_type, points) in enumerate(segments):
                if segment_type in points_required:
                    n, op = points_required[segment_type]
                    assert op(len(points), n), (
                        f"illegal {segment_type!r} segment point count: "
                        f"expected {n}, got {len(points)}"
                    )
                    offcurves = points[:-1]
                    if i == 0:
                        # any off-curve points preceding the first on-curve
                        # will be appended at the end of the contour
                        last_offcurves = offcurves
                    else:
                        for pt, smooth, name, kwargs in offcurves:
                            pen.addPoint(pt, None, smooth, name, **kwargs)
                    pt, smooth, name, kwargs = points[-1]
                    if pt is None:
                        assert segment_type == "qcurve"
                        # special quadratic contour with no on-curve points:
                        # we need to skip the "None" point. See also the Pen
                        # protocol's qCurveTo() method and fontTools.pens.basePen
                        pass
                    else:
                        pen.addPoint(pt, segment_type, smooth, name, **kwargs)
                else:
                    raise AssertionError("unexpected segment type: %r" % segment_type)
            for pt, smooth, name, kwargs in last_offcurves:
                pen.addPoint(pt, None, smooth, name, **kwargs)
            pen.endPath()

        def addComponent(self, baseGlyphName, transformation):
            assert self.currentPath is None
            self.pen.addComponent(baseGlyphName, transformation)

    class Cu2QuMultiPen:
        """A filter multi-pen to convert cubic bezier curves to quadratic b-splines
        in a interpolation-compatible manner, using the FontTools SegmentPen protocol.

        Args:

            other_pens: list of SegmentPens used to draw the transformed outlines.
            max_err: maximum approximation error in font units. For optimal results,
                if you know the UPEM of the font, we recommend setting this to a
                value equal, or close to UPEM / 1000.
            reverse_direction: flip the contours' direction but keep starting point.

        This pen does not follow the normal SegmentPen protocol. Instead, its
        moveTo/lineTo/qCurveTo/curveTo methods take a list of tuples that are
        arguments that would normally be passed to a SegmentPen, one item for
        each of the pens in other_pens.
        """

        # TODO Simplify like 3e8ebcdce592fe8a59ca4c3a294cc9724351e1ce
        # Remove start_pts and _add_moveTO

        def __init__(self, other_pens, max_err, reverse_direction=False):
            if reverse_direction:
                other_pens = [
                    ReverseContourPen(pen, outputImpliedClosingLine=True)
                    for pen in other_pens
                ]
            self.pens = other_pens
            self.max_err = max_err
            self.start_pts = None
            self.current_pts = None

        def _check_contour_is_open(self):
            if self.current_pts is None:
                raise AssertionError("moveTo is required")

        def _check_contour_is_closed(self):
            if self.current_pts is not None:
                raise AssertionError("closePath or endPath is required")

        def _add_moveTo(self):
            if self.start_pts is not None:
                for pt, pen in zip(self.start_pts, self.pens):
                    pen.moveTo(*pt)
                self.start_pts = None

        def moveTo(self, pts):
            self._check_contour_is_closed()
            self.start_pts = self.current_pts = pts
            self._add_moveTo()

        def lineTo(self, pts):
            self._check_contour_is_open()
            self._add_moveTo()
            for pt, pen in zip(pts, self.pens):
                pen.lineTo(*pt)
            self.current_pts = pts

        def qCurveTo(self, pointsList):
            self._check_contour_is_open()
            if len(pointsList[0]) == 1:
                self.lineTo([(points[0],) for points in pointsList])
                return
            self._add_moveTo()
            current_pts = []
            for points, pen in zip(pointsList, self.pens):
                pen.qCurveTo(*points)
                current_pts.append((points[-1],))
            self.current_pts = current_pts

        def _curves_to_quadratic(self, pointsList):
            curves = []
            for current_pt, points in zip(self.current_pts, pointsList):
                curves.append(current_pt + points)
            quadratics = curves_to_quadratic(curves, [self.max_err] * len(curves))
            pointsList = []
            for quadratic in quadratics:
                pointsList.append(quadratic[1:])
            self.qCurveTo(pointsList)

        def curveTo(self, pointsList):
            self._check_contour_is_open()
            self._curves_to_quadratic(pointsList)

        def closePath(self):
            self._check_contour_is_open()
            if self.start_pts is None:
                for pen in self.pens:
                    pen.closePath()
            self.current_pts = self.start_pts = None

        def endPath(self):
            self._check_contour_is_open()
            if self.start_pts is None:
                for pen in self.pens:
                    pen.endPath()
            self.current_pts = self.start_pts = None

        def addComponent(self, glyphName, transformations):
            self._check_contour_is_closed()
            for trans, pen in zip(transformations, self.pens):
                pen.addComponent(glyphName, trans)