# Source code for fontTools.cu2qu.ufo

    # Copyright 2015 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.

    """Converts cubic bezier curves to quadratic splines.

    Conversion is performed such that the quadratic splines keep the same end-curve
    tangents as the original cubics. The approach is iterative, increasing the
    number of segments for a spline until the error gets below a bound.

    Respective curves from multiple fonts will be converted at once to ensure that
    the resulting splines are interpolation-compatible.
    """

    import logging
    from fontTools.pens.basePen import AbstractPen
    from fontTools.pens.pointPen import PointToSegmentPen
    from fontTools.pens.reverseContourPen import ReverseContourPen

    from . import curves_to_quadratic
    from .errors import (
        UnequalZipLengthsError,
        IncompatibleSegmentNumberError,
        IncompatibleSegmentTypesError,
        IncompatibleGlyphsError,
        IncompatibleFontsError,
    )

    __all__ = ["fonts_to_quadratic", "font_to_quadratic"]

    # The default approximation error below is a relative value (1/1000 of the EM square).
    # Later on, we convert it to absolute font units by multiplying it by a font's UPEM
    # (see fonts_to_quadratic).
    DEFAULT_MAX_ERR = 0.001
    CURVE_TYPE_LIB_KEY = "com.github.googlei18n.cu2qu.curve_type"

    logger = logging.getLogger(__name__)

    _zip = zip

    def zip(*args):
        """Ensure each argument to zip has the same length. Also make sure a list is
        returned for python 2/3 compatibility.
        """

        if len(set(len(a) for a in args)) != 1:
            raise UnequalZipLengthsError(*args)
        return list(_zip(*args))

    class GetSegmentsPen(AbstractPen):
        """Pen to collect segments into lists of points for conversion.

        Curves always include their initial on-curve point, so some points are
        duplicated between segments.
        """

        def __init__(self):
            self._last_pt = None
            self.segments = []

        def _add_segment(self, tag, *args):
            if tag in ["move", "line", "qcurve", "curve"]:
                self._last_pt = args[-1]
            self.segments.append((tag, args))

        def moveTo(self, pt):
            self._add_segment("move", pt)

        def lineTo(self, pt):
            self._add_segment("line", pt)

        def qCurveTo(self, *points):
            self._add_segment("qcurve", self._last_pt, *points)

        def curveTo(self, *points):
            self._add_segment("curve", self._last_pt, *points)

        def closePath(self):
            self._add_segment("close")

        def endPath(self):
            self._add_segment("end")

        def addComponent(self, glyphName, transformation):
            pass

    def _get_segments(glyph):
        """Get a glyph's segments as extracted by GetSegmentsPen."""

        pen = GetSegmentsPen()
        # glyph.draw(pen)
        # We can't simply draw the glyph with the pen, but we must initialize the
        # PointToSegmentPen explicitly with outputImpliedClosingLine=True.
        # By default PointToSegmentPen does not outputImpliedClosingLine -- unless
        # last and first point on closed contour are duplicated. Because we are
        # converting multiple glyphs at the same time, we want to make sure
        # this function returns the same number of segments, whether or not
        # the last and first point overlap.
        # https://github.com/googlefonts/fontmake/issues/572
        # https://github.com/fonttools/fonttools/pull/1720
        pointPen = PointToSegmentPen(pen, outputImpliedClosingLine=True)
        glyph.drawPoints(pointPen)
        return pen.segments

    def _set_segments(glyph, segments, reverse_direction):
        """Draw segments as extracted by GetSegmentsPen back to a glyph."""

        glyph.clearContours()
        pen = glyph.getPen()
        if reverse_direction:
            pen = ReverseContourPen(pen)
        for tag, args in segments:
            if tag == "move":
                pen.moveTo(*args)
            elif tag == "line":
                pen.lineTo(*args)
            elif tag == "curve":
                pen.curveTo(*args[1:])
            elif tag == "qcurve":
                pen.qCurveTo(*args[1:])
            elif tag == "close":
                pen.closePath()
            elif tag == "end":
                pen.endPath()
            else:
                raise AssertionError('Unhandled segment type "%s"' % tag)

    def _segments_to_quadratic(segments, max_err, stats, all_quadratic=True):
        """Return quadratic approximations of cubic segments."""

        assert all(s[0] == "curve" for s in segments), "Non-cubic given to convert"

        new_points = curves_to_quadratic([s[1] for s in segments], max_err, all_quadratic)
        n = len(new_points[0])
        assert all(len(s) == n for s in new_points[1:]), "Converted incompatibly"

        spline_length = str(n - 2)
        stats[spline_length] = stats.get(spline_length, 0) + 1

        if all_quadratic or n == 3:
            return [("qcurve", p) for p in new_points]
        else:
            return [("curve", p) for p in new_points]

    def _glyphs_to_quadratic(glyphs, max_err, reverse_direction, stats, all_quadratic=True):
        """Do the actual conversion of a set of compatible glyphs, after arguments
        have been set up.

        Return True if the glyphs were modified, else return False.
        """

        try:
            segments_by_location = zip(*[_get_segments(g) for g in glyphs])
        except UnequalZipLengthsError:
            raise IncompatibleSegmentNumberError(glyphs)
        if not any(segments_by_location):
            return False

        # always modify input glyphs if reverse_direction is True
        glyphs_modified = reverse_direction

        new_segments_by_location = []
        incompatible = {}
        for i, segments in enumerate(segments_by_location):
            tag = segments[0][0]
            if not all(s[0] == tag for s in segments[1:]):
                incompatible[i] = [s[0] for s in segments]
            elif tag == "curve":
                new_segments = _segments_to_quadratic(
                    segments, max_err, stats, all_quadratic
                )
                if all_quadratic or new_segments != segments:
                    glyphs_modified = True
                segments = new_segments
            new_segments_by_location.append(segments)

        if glyphs_modified:
            new_segments_by_glyph = zip(*new_segments_by_location)
            for glyph, new_segments in zip(glyphs, new_segments_by_glyph):
                _set_segments(glyph, new_segments, reverse_direction)

        if incompatible:
            raise IncompatibleSegmentTypesError(glyphs, segments=incompatible)
        return glyphs_modified

    def glyphs_to_quadratic(
        glyphs, max_err=None, reverse_direction=False, stats=None, all_quadratic=True
    ):
        """Convert the curves of a set of compatible of glyphs to quadratic.

        All curves will be converted to quadratic at once, ensuring interpolation
        compatibility. If this is not required, calling glyphs_to_quadratic with one
        glyph at a time may yield slightly more optimized results.

        Return True if glyphs were modified, else return False.

        Raises IncompatibleGlyphsError if glyphs have non-interpolatable outlines.
        """
        if stats is None:
            stats = {}

        if not max_err:
            # assume 1000 is the default UPEM
            max_err = DEFAULT_MAX_ERR * 1000

        if isinstance(max_err, (list, tuple)):
            max_errors = max_err
        else:
            max_errors = [max_err] * len(glyphs)
        assert len(max_errors) == len(glyphs)

        return _glyphs_to_quadratic(
            glyphs, max_errors, reverse_direction, stats, all_quadratic
        )

    def fonts_to_quadratic(
        fonts,
        max_err_em=None,
        max_err=None,
        reverse_direction=False,
        stats=None,
        dump_stats=False,
        remember_curve_type=True,
        all_quadratic=True,
    ):
        """Convert the curves of a collection of fonts to quadratic.

        All curves will be converted to quadratic at once, ensuring interpolation
        compatibility. If this is not required, calling fonts_to_quadratic with one
        font at a time may yield slightly more optimized results.

        Return the set of modified glyph names if any, else return an empty set.

        By default, cu2qu stores the curve type in the fonts' lib, under a private
        key "com.github.googlei18n.cu2qu.curve_type", and will not try to convert
        them again if the curve type is already set to "quadratic".
        Setting 'remember_curve_type' to False disables this optimization.

        Raises IncompatibleFontsError if same-named glyphs from different fonts
        have non-interpolatable outlines.
        """

        if remember_curve_type:
            curve_types = {f.lib.get(CURVE_TYPE_LIB_KEY, "cubic") for f in fonts}
            if len(curve_types) == 1:
                curve_type = next(iter(curve_types))
                if curve_type in ("quadratic", "mixed"):
                    logger.info("Curves already converted to quadratic")
                    return False
                elif curve_type == "cubic":
                    pass  # keep converting
                else:
                    raise NotImplementedError(curve_type)
            elif len(curve_types) > 1:
                # going to crash later if they do differ
                logger.warning("fonts may contain different curve types")

        if stats is None:
            stats = {}

        if max_err_em and max_err:
            raise TypeError("Only one of max_err and max_err_em can be specified.")
        if not (max_err_em or max_err):
            max_err_em = DEFAULT_MAX_ERR

        if isinstance(max_err, (list, tuple)):
            assert len(max_err) == len(fonts)
            max_errors = max_err
        elif max_err:
            max_errors = [max_err] * len(fonts)

        if isinstance(max_err_em, (list, tuple)):
            assert len(fonts) == len(max_err_em)
            max_errors = [f.info.unitsPerEm * e for f, e in zip(fonts, max_err_em)]
        elif max_err_em:
            max_errors = [f.info.unitsPerEm * max_err_em for f in fonts]

        modified = set()
        glyph_errors = {}
        for name in set().union(*(f.keys() for f in fonts)):
            glyphs = []
            cur_max_errors = []
            for font, error in zip(fonts, max_errors):
                if name in font:
                    glyphs.append(font[name])
                    cur_max_errors.append(error)
            try:
                if _glyphs_to_quadratic(
                    glyphs, cur_max_errors, reverse_direction, stats, all_quadratic
                ):
                    modified.add(name)
            except IncompatibleGlyphsError as exc:
                logger.error(exc)
                glyph_errors[name] = exc

        if glyph_errors:
            raise IncompatibleFontsError(glyph_errors)

        if modified and dump_stats:
            spline_lengths = sorted(stats.keys())
            logger.info(
                "New spline lengths: %s"
                % (", ".join("%s: %d" % (l, stats[l]) for l in spline_lengths))
            )

        if remember_curve_type:
            for font in fonts:
                curve_type = font.lib.get(CURVE_TYPE_LIB_KEY, "cubic")
                new_curve_type = "quadratic" if all_quadratic else "mixed"
                if curve_type != new_curve_type:
                    font.lib[CURVE_TYPE_LIB_KEY] = new_curve_type
        return modified

    def glyph_to_quadratic(glyph, **kwargs):
        """Convenience wrapper around glyphs_to_quadratic, for just one glyph.
        Return True if the glyph was modified, else return False.
        """

        return glyphs_to_quadratic([glyph], **kwargs)

    def font_to_quadratic(font, **kwargs):
        """Convenience wrapper around fonts_to_quadratic, for just one font.
        Return the set of modified glyph names if any, else return empty set.
        """

        return fonts_to_quadratic([font], **kwargs)