# Copyright 2003-2008 by Leighton Pritchard.  All rights reserved.
# Revisions copyright 2008-2017 by Peter Cock.
#
# This file is part of the Biopython distribution and governed by your
# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
# Please see the LICENSE file that should have been included as part of this
# package.
#
# Contact:       Leighton Pritchard, The James Hutton Institute,
#                Invergowrie, Dundee, Scotland, DD2 5DA, UK
#                Leighton.Pritchard@hutton.ac.uk
################################################################################

"""CircularDrawer module for GenomeDiagram."""

from math import cos
from math import pi
from math import sin

from reportlab.graphics.shapes import ArcPath
from reportlab.graphics.shapes import Circle
from reportlab.graphics.shapes import Drawing
from reportlab.graphics.shapes import Group
from reportlab.graphics.shapes import Line
from reportlab.graphics.shapes import Polygon
from reportlab.graphics.shapes import String
from reportlab.lib import colors

from ._AbstractDrawer import _stroke_and_fill_colors
from ._AbstractDrawer import AbstractDrawer
from ._AbstractDrawer import draw_polygon
from ._AbstractDrawer import intermediate_points
from ._FeatureSet import FeatureSet
from ._GraphSet import GraphSet


class CircularDrawer(AbstractDrawer):
    """Object for drawing circular diagrams.

    Attributes:
     - tracklines    Boolean for whether to draw lines dilineating tracks
     - pagesize      Tuple describing the size of the page in pixels
     - x0            Float X co-ord for leftmost point of drawable area
     - xlim          Float X co-ord for rightmost point of drawable area
     - y0            Float Y co-ord for lowest point of drawable area
     - ylim          Float Y co-ord for topmost point of drawable area
     - pagewidth     Float pixel width of drawable area
     - pageheight    Float pixel height of drawable area
     - xcenter       Float X co-ord of center of drawable area
     - ycenter       Float Y co-ord of center of drawable area
     - start         Int, base to start drawing from
     - end           Int, base to stop drawing at
     - length        Size of sequence to be drawn
     - track_size    Float (0->1) the proportion of the track height to draw in
     - drawing       Drawing canvas
     - drawn_tracks  List of ints denoting which tracks are to be drawn
     - current_track_level   Int denoting which track is currently being drawn
     - track_offsets     Dictionary of number of pixels that each track top,
       center and bottom is offset from the base of a fragment, keyed by track
     - sweep     Float (0->1) the proportion of the circle circumference to
       use for the diagram
     - cross_track_links List of tuples each with four entries (track A,
       feature A, track B, feature B) to be linked.

    """

    def __init__(
        self,
        parent=None,
        pagesize="A3",
        orientation="landscape",
        x=0.05,
        y=0.05,
        xl=None,
        xr=None,
        yt=None,
        yb=None,
        start=None,
        end=None,
        tracklines=0,
        track_size=0.75,
        circular=1,
        circle_core=0.0,
        cross_track_links=None,
    ):
        """Create CircularDrawer object.

        Arguments:
         - parent    Diagram object containing the data that the drawer
           draws
         - pagesize  String describing the ISO size of the image, or a tuple
           of pixels
         - orientation   String describing the required orientation of the
           final drawing ('landscape' or 'portrait')
         - x         Float (0->1) describing the relative size of the X
           margins to the page
         - y         Float (0->1) describing the relative size of the Y
           margins to the page
         - xl        Float (0->1) describing the relative size of the left X
           margin to the page (overrides x)
         - xl        Float (0->1) describing the relative size of the left X
           margin to the page (overrides x)
         - xr        Float (0->1) describing the relative size of the right X
           margin to the page (overrides x)
         - yt        Float (0->1) describing the relative size of the top Y
           margin to the page (overrides y)
         - yb        Float (0->1) describing the relative size of the lower Y
           margin to the page (overrides y)
         - start     Int, the position to begin drawing the diagram at
         - end       Int, the position to stop drawing the diagram at
         - tracklines    Boolean flag to show (or not) lines delineating tracks
           on the diagram
         - track_size    The proportion of the available track height that
           should be taken up in drawing
         - circular      Boolean flaw to show whether the passed sequence is
           circular or not
         - circle_core   The proportion of the available radius to leave
           empty at the center of a circular diagram (0 to 1).
         - cross_track_links List of tuples each with four entries (track A,
           feature A, track B, feature B) to be linked.

        """
        # Use the superclass' instantiation method
        AbstractDrawer.__init__(
            self,
            parent,
            pagesize,
            orientation,
            x,
            y,
            xl,
            xr,
            yt,
            yb,
            start,
            end,
            tracklines,
            cross_track_links,
        )

        # Useful measurements on the page
        self.track_size = track_size
        self.circle_core = circle_core
        # Determine proportion of circumference around which information will be drawn
        if not circular:
            self.sweep = 0.9
        else:
            self.sweep = 1.0

    def set_track_heights(self):
        """Initialize track heights.

        Since tracks may not be of identical heights, the bottom and top
        radius for each track is stored in a dictionary - self.track_radii,
        keyed by track number
        """
        bot_track = min(min(self.drawn_tracks), 1)
        top_track = max(self.drawn_tracks)  # The 'highest' track to draw

        trackunit_sum = 0  # Total number of 'units' taken up by all tracks
        trackunits = {}  # Start and & units for each track keyed by track number
        heightholder = 0  # placeholder variable
        for track in range(bot_track, top_track + 1):  # track numbers to 'draw'
            try:
                trackheight = self._parent[track].height  # Get track height
            except Exception:  # TODO: ValueError? IndexError?
                trackheight = 1
            trackunit_sum += trackheight  # increment total track unit height
            trackunits[track] = (heightholder, heightholder + trackheight)
            heightholder += trackheight  # move to next height

        max_radius = 0.5 * min(self.pagewidth, self.pageheight)
        trackunit_height = max_radius * (1 - self.circle_core) / trackunit_sum
        track_core = max_radius * self.circle_core

        # Calculate top and bottom radii for each track
        self.track_radii = {}  # The inner, outer and center radii for each track
        track_crop = (
            trackunit_height * (1 - self.track_size) / 2.0
        )  # 'step back' in pixels
        for track in trackunits:
            top = trackunits[track][1] * trackunit_height - track_crop + track_core
            btm = trackunits[track][0] * trackunit_height + track_crop + track_core
            ctr = btm + (top - btm) / 2.0
            self.track_radii[track] = (btm, ctr, top)

    def draw(self):
        """Draw a circular diagram of the stored data."""
        # Instantiate the drawing canvas
        self.drawing = Drawing(self.pagesize[0], self.pagesize[1])

        feature_elements = []  # holds feature elements
        feature_labels = []  # holds feature labels
        greytrack_bgs = []  # holds track background
        greytrack_labels = []  # holds track foreground labels
        scale_axes = []  # holds scale axes
        scale_labels = []  # holds scale axis labels

        # Get tracks to be drawn and set track sizes
        self.drawn_tracks = self._parent.get_drawn_levels()
        self.set_track_heights()

        # Go through each track in the parent (if it is to be drawn) one by
        # one and collate the data as drawing elements
        for track_level in self._parent.get_drawn_levels():
            self.current_track_level = track_level
            track = self._parent[track_level]
            gbgs, glabels = self.draw_greytrack(track)  # Greytracks
            greytrack_bgs.append(gbgs)
            greytrack_labels.append(glabels)
            features, flabels = self.draw_track(track)  # Features and graphs
            feature_elements.append(features)
            feature_labels.append(flabels)
            if track.scale:
                axes, slabels = self.draw_scale(track)  # Scale axes
                scale_axes.append(axes)
                scale_labels.append(slabels)

        feature_cross_links = []
        for cross_link_obj in self.cross_track_links:
            cross_link_elements = self.draw_cross_link(cross_link_obj)
            if cross_link_elements:
                feature_cross_links.append(cross_link_elements)

        # Groups listed in order of addition to page (from back to front)
        # Draw track backgrounds
        # Draw feature cross track links
        # Draw features and graphs
        # Draw scale axes
        # Draw scale labels
        # Draw feature labels
        # Draw track labels
        element_groups = [
            greytrack_bgs,
            feature_cross_links,
            feature_elements,
            scale_axes,
            scale_labels,
            feature_labels,
            greytrack_labels,
        ]
        for element_group in element_groups:
            for element_list in element_group:
                [self.drawing.add(element) for element in element_list]

        if self.tracklines:
            # Draw test tracks over top of diagram
            self.draw_test_tracks()

    def draw_track(self, track):
        """Return list of track elements and list of track labels."""
        track_elements = []  # Holds elements for features and graphs
        track_labels = []  # Holds labels for features and graphs

        # Distribution dictionary for dealing with different set types
        set_methods = {FeatureSet: self.draw_feature_set, GraphSet: self.draw_graph_set}

        for set in track.get_sets():  # Draw the feature or graph sets
            elements, labels = set_methods[set.__class__](set)
            track_elements += elements
            track_labels += labels
        return track_elements, track_labels

    def draw_feature_set(self, set):
        """Return list of feature elements and list of labels for them."""
        # print('draw feature set')
        feature_elements = []  # Holds diagram elements belonging to the features
        label_elements = []  # Holds diagram elements belonging to feature labels

        # Collect all the elements for the feature set
        for feature in set.get_features():
            if self.is_in_bounds(feature.start) or self.is_in_bounds(feature.end):
                features, labels = self.draw_feature(feature)
                feature_elements += features
                label_elements += labels

        return feature_elements, label_elements

    def draw_feature(self, feature):
        """Return list of feature elements and list of labels for them."""
        feature_elements = []  # Holds drawable elements for a single feature
        label_elements = []  # Holds labels for a single feature

        if feature.hide:  # Don't show feature: return early
            return feature_elements, label_elements

        start, end = self._current_track_start_end()
        # A single feature may be split into subfeatures, so loop over them
        for locstart, locend in feature.locations:
            if locend < start:
                continue
            locstart = max(locstart, start)
            if end < locstart:
                continue
            locend = min(locend, end)
            # Get sigil for the feature/ each subfeature
            feature_sigil, label = self.get_feature_sigil(feature, locstart, locend)
            feature_elements.append(feature_sigil)
            if label is not None:  # If there's a label
                label_elements.append(label)

        return feature_elements, label_elements

    def get_feature_sigil(self, feature, locstart, locend, **kwargs):
        """Return graphics for feature, and any required label for it.

        Arguments:
         - feature       Feature object
         - locstart      The start position of the feature
         - locend        The end position of the feature

        """
        # Establish the coordinates for the sigil
        btm, ctr, top = self.track_radii[self.current_track_level]

        startangle, startcos, startsin = self.canvas_angle(locstart)
        endangle, endcos, endsin = self.canvas_angle(locend)
        midangle, midcos, midsin = self.canvas_angle((locend + locstart) / 2)

        # Distribution dictionary for various ways of drawing the feature
        # Each method takes the inner and outer radii, the start and end angle
        # subtended at the diagram center, and the color as arguments
        draw_methods = {
            "BOX": self._draw_sigil_box,
            "OCTO": self._draw_sigil_cut_corner_box,
            "JAGGY": self._draw_sigil_jaggy,
            "ARROW": self._draw_sigil_arrow,
            "BIGARROW": self._draw_sigil_big_arrow,
        }

        # Get sigil for the feature, location dependent on the feature strand
        method = draw_methods[feature.sigil]
        kwargs["head_length_ratio"] = feature.arrowhead_length
        kwargs["shaft_height_ratio"] = feature.arrowshaft_height

        # Support for clickable links... needs ReportLab 2.4 or later
        # which added support for links in SVG output.
        if hasattr(feature, "url"):
            kwargs["hrefURL"] = feature.url
            kwargs["hrefTitle"] = feature.name

        sigil = method(
            btm,
            ctr,
            top,
            startangle,
            endangle,
            feature.location.strand,
            color=feature.color,
            border=feature.border,
            **kwargs,
        )

        if feature.label:  # Feature needs a label
            # The spaces are a hack to force a little space between the label
            # and the edge of the feature
            label = String(
                0,
                0,
                f" {feature.name.strip()} ",
                fontName=feature.label_font,
                fontSize=feature.label_size,
                fillColor=feature.label_color,
            )
            labelgroup = Group(label)
            if feature.label_strand:
                strand = feature.label_strand
            else:
                strand = feature.location.strand
            if feature.label_position in ("start", "5'", "left"):
                # Position the label at the feature's start
                if strand != -1:
                    label_angle = startangle + 0.5 * pi  # Make text radial
                    sinval, cosval = startsin, startcos
                else:
                    label_angle = endangle + 0.5 * pi  # Make text radial
                    sinval, cosval = endsin, endcos
            elif feature.label_position in ("middle", "center", "centre"):
                # Position the label at the feature's midpoint
                label_angle = midangle + 0.5 * pi  # Make text radial
                sinval, cosval = midsin, midcos
            elif feature.label_position in ("end", "3'", "right"):
                # Position the label at the feature's end
                if strand != -1:
                    label_angle = endangle + 0.5 * pi  # Make text radial
                    sinval, cosval = endsin, endcos
                else:
                    label_angle = startangle + 0.5 * pi  # Make text radial
                    sinval, cosval = startsin, startcos
            elif startangle < pi:
                # Default to placing the label the bottom of the feature
                # as drawn on the page, meaning feature end on left half
                label_angle = endangle + 0.5 * pi  # Make text radial
                sinval, cosval = endsin, endcos
            else:
                # Default to placing the label on the bottom of the feature,
                # which means the feature end when on right hand half
                label_angle = startangle + 0.5 * pi  # Make text radial
                sinval, cosval = startsin, startcos
            if strand != -1:
                # Feature label on top
                radius = top
                if startangle < pi:  # Turn text round
                    label_angle -= pi
                else:
                    labelgroup.contents[0].textAnchor = "end"
            else:
                # Feature label on bottom
                radius = btm
                if startangle < pi:  # Turn text round and anchor end
                    label_angle -= pi
                    labelgroup.contents[0].textAnchor = "end"
            x_pos = self.xcenter + radius * sinval
            y_pos = self.ycenter + radius * cosval
            coslabel = cos(label_angle)
            sinlabel = sin(label_angle)
            labelgroup.transform = (
                coslabel,
                -sinlabel,
                sinlabel,
                coslabel,
                x_pos,
                y_pos,
            )
        else:
            # No label required
            labelgroup = None
        # if locstart > locend:
        #    print(locstart, locend, feature.location.strand, sigil, feature.name)
        # print(locstart, locend, feature.name)
        return sigil, labelgroup

    def draw_cross_link(self, cross_link):
        """Draw a cross-link between features."""
        startA = cross_link.startA
        startB = cross_link.startB
        endA = cross_link.endA
        endB = cross_link.endB

        if not self.is_in_bounds(startA) and not self.is_in_bounds(endA):
            return None
        if not self.is_in_bounds(startB) and not self.is_in_bounds(endB):
            return None

        if startA < self.start:
            startA = self.start
        if startB < self.start:
            startB = self.start
        if self.end < endA:
            endA = self.end
        if self.end < endB:
            endB = self.end

        trackobjA = cross_link._trackA(list(self._parent.tracks.values()))
        trackobjB = cross_link._trackB(list(self._parent.tracks.values()))
        assert trackobjA is not None
        assert trackobjB is not None
        if trackobjA == trackobjB:
            raise NotImplementedError

        if trackobjA.start is not None:
            if endA < trackobjA.start:
                return
            startA = max(startA, trackobjA.start)
        if trackobjA.end is not None:
            if trackobjA.end < startA:
                return
            endA = min(endA, trackobjA.end)
        if trackobjB.start is not None:
            if endB < trackobjB.start:
                return
            startB = max(startB, trackobjB.start)
        if trackobjB.end is not None:
            if trackobjB.end < startB:
                return
            endB = min(endB, trackobjB.end)

        for track_level in self._parent.get_drawn_levels():
            track = self._parent[track_level]
            if track == trackobjA:
                trackA = track_level
            if track == trackobjB:
                trackB = track_level
        if trackA == trackB:
            raise NotImplementedError

        startangleA, startcosA, startsinA = self.canvas_angle(startA)
        startangleB, startcosB, startsinB = self.canvas_angle(startB)
        endangleA, endcosA, endsinA = self.canvas_angle(endA)
        endangleB, endcosB, endsinB = self.canvas_angle(endB)

        btmA, ctrA, topA = self.track_radii[trackA]
        btmB, ctrB, topB = self.track_radii[trackB]

        if ctrA < ctrB:
            return [
                self._draw_arc_poly(
                    topA,
                    btmB,
                    startangleA,
                    endangleA,
                    startangleB,
                    endangleB,
                    cross_link.color,
                    cross_link.border,
                    cross_link.flip,
                )
            ]
        else:
            return [
                self._draw_arc_poly(
                    btmA,
                    topB,
                    startangleA,
                    endangleA,
                    startangleB,
                    endangleB,
                    cross_link.color,
                    cross_link.border,
                    cross_link.flip,
                )
            ]

    def draw_graph_set(self, set):
        """Return list of graph elements and list of their labels.

        Arguments:
         - set       GraphSet object

        """
        # print('draw graph set')
        elements = []  # Holds graph elements

        # Distribution dictionary for how to draw the graph
        style_methods = {
            "line": self.draw_line_graph,
            "heat": self.draw_heat_graph,
            "bar": self.draw_bar_graph,
        }

        for graph in set.get_graphs():
            elements += style_methods[graph.style](graph)

        return elements, []

    def draw_line_graph(self, graph):
        """Return line graph as list of drawable elements.

        Arguments:
         - graph     GraphData object

        """
        line_elements = []  # holds drawable elements

        # Get graph data
        data_quartiles = graph.quartiles()
        minval, maxval = data_quartiles[0], data_quartiles[4]
        btm, ctr, top = self.track_radii[self.current_track_level]
        trackheight = 0.5 * (top - btm)
        datarange = maxval - minval
        if datarange == 0:
            datarange = trackheight

        start, end = self._current_track_start_end()
        data = graph[start:end]

        if not data:
            return []

        # midval is the value at which the x-axis is plotted, and is the
        # central ring in the track
        if graph.center is None:
            midval = (maxval + minval) / 2.0
        else:
            midval = graph.center
        # Whichever is the greatest difference: max-midval or min-midval, is
        # taken to specify the number of pixel units resolved along the
        # y-axis
        resolution = max((midval - minval), (maxval - midval))

        # Start from first data point
        pos, val = data[0]
        lastangle, lastcos, lastsin = self.canvas_angle(pos)
        # We calculate the track height
        posheight = trackheight * (val - midval) / resolution + ctr
        lastx = self.xcenter + posheight * lastsin  # start xy coords
        lasty = self.ycenter + posheight * lastcos
        for pos, val in data:
            posangle, poscos, possin = self.canvas_angle(pos)
            posheight = trackheight * (val - midval) / resolution + ctr
            x = self.xcenter + posheight * possin  # next xy coords
            y = self.ycenter + posheight * poscos
            line_elements.append(
                Line(
                    lastx,
                    lasty,
                    x,
                    y,
                    strokeColor=graph.poscolor,
                    strokeWidth=graph.linewidth,
                )
            )
            lastx, lasty = x, y
        return line_elements

    def draw_bar_graph(self, graph):
        """Return list of drawable elements for a bar graph.

        Arguments:
         - graph     Graph object

        """
        # At each point contained in the graph data, we draw a vertical bar
        # from the track center to the height of the datapoint value (positive
        # values go up in one color, negative go down in the alternative
        # color).
        bar_elements = []

        # Set the number of pixels per unit for the data
        data_quartiles = graph.quartiles()
        minval, maxval = data_quartiles[0], data_quartiles[4]
        btm, ctr, top = self.track_radii[self.current_track_level]
        trackheight = 0.5 * (top - btm)
        datarange = maxval - minval
        if datarange == 0:
            datarange = trackheight
        data = graph[self.start : self.end]
        # midval is the value at which the x-axis is plotted, and is the
        # central ring in the track
        if graph.center is None:
            midval = (maxval + minval) / 2.0
        else:
            midval = graph.center

        # Convert data into 'binned' blocks, covering half the distance to the
        # next data point on either side, accounting for the ends of fragments
        # and tracks
        start, end = self._current_track_start_end()
        data = intermediate_points(start, end, graph[start:end])

        if not data:
            return []

        # Whichever is the greatest difference: max-midval or min-midval, is
        # taken to specify the number of pixel units resolved along the
        # y-axis
        resolution = max((midval - minval), (maxval - midval))
        if resolution == 0:
            resolution = trackheight

        # Create elements for the bar graph based on newdata
        for pos0, pos1, val in data:
            pos0angle, pos0cos, pos0sin = self.canvas_angle(pos0)
            pos1angle, pos1cos, pos1sin = self.canvas_angle(pos1)

            barval = trackheight * (val - midval) / resolution
            if barval >= 0:
                barcolor = graph.poscolor
            else:
                barcolor = graph.negcolor

            # Draw bar
            bar_elements.append(
                self._draw_arc(ctr, ctr + barval, pos0angle, pos1angle, barcolor)
            )
        return bar_elements

    def draw_heat_graph(self, graph):
        """Return list of drawable elements for the heat graph.

        Arguments:
         - graph     Graph object

        """
        # At each point contained in the graph data, we draw a box that is the
        # full height of the track, extending from the midpoint between the
        # previous and current data points to the midpoint between the current
        # and next data points
        heat_elements = []  # holds drawable elements

        # Get graph data
        data_quartiles = graph.quartiles()
        minval, maxval = data_quartiles[0], data_quartiles[4]
        midval = (maxval + minval) / 2.0  # mid is the value at the X-axis
        btm, ctr, top = self.track_radii[self.current_track_level]
        trackheight = top - btm

        start, end = self._current_track_start_end()
        data = intermediate_points(start, end, graph[start:end])

        # Create elements on the graph, indicating a large positive value by
        # the graph's poscolor, and a large negative value by the graph's
        # negcolor attributes
        for pos0, pos1, val in data:
            pos0angle, pos0cos, pos0sin = self.canvas_angle(pos0)
            pos1angle, pos1cos, pos1sin = self.canvas_angle(pos1)

            # Calculate the heat color, based on the differential between
            # the value and the median value
            heat = colors.linearlyInterpolatedColor(
                graph.poscolor, graph.negcolor, maxval, minval, val
            )

            # Draw heat box
            heat_elements.append(
                self._draw_arc(btm, top, pos0angle, pos1angle, heat, border=heat)
            )
        return heat_elements

    def draw_scale(self, track):
        """Return list of elements in the scale and list of their labels.

        Arguments:
         - track     Track object

        """
        scale_elements = []  # holds axes and ticks
        scale_labels = []  # holds labels

        if not track.scale:
            # no scale required, exit early
            return [], []

        # Get track locations
        btm, ctr, top = self.track_radii[self.current_track_level]
        trackheight = top - ctr

        # X-axis
        start, end = self._current_track_start_end()
        if track.start is not None or track.end is not None:
            # Draw an arc, leaving out the wedge
            p = ArcPath(strokeColor=track.scale_color, fillColor=None)
            startangle, startcos, startsin = self.canvas_angle(start)
            endangle, endcos, endsin = self.canvas_angle(end)
            p.addArc(
                self.xcenter,
                self.ycenter,
                ctr,
                90 - (endangle * 180 / pi),
                90 - (startangle * 180 / pi),
            )
            scale_elements.append(p)
            del p
            # Y-axis start marker
            x0, y0 = self.xcenter + btm * startsin, self.ycenter + btm * startcos
            x1, y1 = self.xcenter + top * startsin, self.ycenter + top * startcos
            scale_elements.append(Line(x0, y0, x1, y1, strokeColor=track.scale_color))
            # Y-axis end marker
            x0, y0 = self.xcenter + btm * endsin, self.ycenter + btm * endcos
            x1, y1 = self.xcenter + top * endsin, self.ycenter + top * endcos
            scale_elements.append(Line(x0, y0, x1, y1, strokeColor=track.scale_color))
        elif self.sweep < 1:
            # Draw an arc, leaving out the wedge
            p = ArcPath(strokeColor=track.scale_color, fillColor=None)
            # Note reportlab counts angles anti-clockwise from the horizontal
            # (as in mathematics, e.g. complex numbers and polar coordinates)
            # in degrees.
            p.addArc(
                self.xcenter,
                self.ycenter,
                ctr,
                startangledegrees=90 - 360 * self.sweep,
                endangledegrees=90,
            )
            scale_elements.append(p)
            del p
            # Y-axis start marker
            x0, y0 = self.xcenter, self.ycenter + btm
            x1, y1 = self.xcenter, self.ycenter + top
            scale_elements.append(Line(x0, y0, x1, y1, strokeColor=track.scale_color))
            # Y-axis end marker
            alpha = 2 * pi * self.sweep
            x0, y0 = self.xcenter + btm * sin(alpha), self.ycenter + btm * cos(alpha)
            x1, y1 = self.xcenter + top * sin(alpha), self.ycenter + top * cos(alpha)
            scale_elements.append(Line(x0, y0, x1, y1, strokeColor=track.scale_color))
        else:
            # Draw a full circle
            scale_elements.append(
                Circle(
                    self.xcenter,
                    self.ycenter,
                    ctr,
                    strokeColor=track.scale_color,
                    fillColor=None,
                )
            )

        start, end = self._current_track_start_end()
        if track.scale_ticks:  # Ticks are required on the scale
            # Draw large ticks
            # I want the ticks to be consistently positioned relative to
            # the start of the sequence (position 0), not relative to the
            # current viewpoint (self.start and self.end)

            ticklen = track.scale_largeticks * trackheight
            tickiterval = int(track.scale_largetick_interval)
            # Note that we could just start the list of ticks using
            # range(0,self.end,tickinterval) and the filter out the
            # ones before self.start - but this seems wasteful.
            # Using tickiterval * (self.start/tickiterval) is a shortcut.
            for tickpos in range(
                tickiterval * (self.start // tickiterval), int(self.end), tickiterval
            ):
                if tickpos <= start or end <= tickpos:
                    continue
                tick, label = self.draw_tick(
                    tickpos, ctr, ticklen, track, track.scale_largetick_labels
                )
                scale_elements.append(tick)
                if label is not None:  # If there's a label, add it
                    scale_labels.append(label)
            # Draw small ticks
            ticklen = track.scale_smallticks * trackheight
            tickiterval = int(track.scale_smalltick_interval)
            for tickpos in range(
                tickiterval * (self.start // tickiterval), int(self.end), tickiterval
            ):
                if tickpos <= start or end <= tickpos:
                    continue
                tick, label = self.draw_tick(
                    tickpos, ctr, ticklen, track, track.scale_smalltick_labels
                )
                scale_elements.append(tick)
                if label is not None:  # If there's a label, add it
                    scale_labels.append(label)

        # Check to see if the track contains a graph - if it does, get the
        # minimum and maximum values, and put them on the scale Y-axis
        # at 60 degree intervals, ordering the labels by graph_id
        startangle, startcos, startsin = self.canvas_angle(start)
        endangle, endcos, endsin = self.canvas_angle(end)
        if track.axis_labels:
            for set in track.get_sets():
                if set.__class__ is GraphSet:
                    # Y-axis
                    for n in range(7):
                        angle = n * 1.0471975511965976
                        if angle < startangle or endangle < angle:
                            continue
                        ticksin, tickcos = sin(angle), cos(angle)
                        x0, y0 = (
                            self.xcenter + btm * ticksin,
                            self.ycenter + btm * tickcos,
                        )
                        x1, y1 = (
                            self.xcenter + top * ticksin,
                            self.ycenter + top * tickcos,
                        )
                        scale_elements.append(
                            Line(x0, y0, x1, y1, strokeColor=track.scale_color)
                        )

                        graph_label_min = []
                        graph_label_max = []
                        graph_label_mid = []
                        for graph in set.get_graphs():
                            quartiles = graph.quartiles()
                            minval, maxval = quartiles[0], quartiles[4]
                            if graph.center is None:
                                midval = (maxval + minval) / 2.0
                                graph_label_min.append(f"{minval:.3f}")
                                graph_label_max.append(f"{maxval:.3f}")
                                graph_label_mid.append(f"{midval:.3f}")
                            else:
                                diff = max(
                                    (graph.center - minval), (maxval - graph.center)
                                )
                                minval = graph.center - diff
                                maxval = graph.center + diff
                                midval = graph.center
                                graph_label_mid.append(f"{midval:.3f}")
                                graph_label_min.append(f"{minval:.3f}")
                                graph_label_max.append(f"{maxval:.3f}")
                        xmid, ymid = (x0 + x1) / 2.0, (y0 + y1) / 2.0
                        for limit, x, y in [
                            (graph_label_min, x0, y0),
                            (graph_label_max, x1, y1),
                            (graph_label_mid, xmid, ymid),
                        ]:
                            label = String(
                                0,
                                0,
                                ";".join(limit),
                                fontName=track.scale_font,
                                fontSize=track.scale_fontsize,
                                fillColor=track.scale_color,
                            )
                            label.textAnchor = "middle"
                            labelgroup = Group(label)
                            labelgroup.transform = (
                                tickcos,
                                -ticksin,
                                ticksin,
                                tickcos,
                                x,
                                y,
                            )
                            scale_labels.append(labelgroup)

        return scale_elements, scale_labels

    def draw_tick(self, tickpos, ctr, ticklen, track, draw_label):
        """Return drawing element for a tick on the scale.

        Arguments:
         - tickpos   Int, position of the tick on the sequence
         - ctr       Float, Y co-ord of the center of the track
         - ticklen   How long to draw the tick
         - track     Track, the track the tick is drawn on
         - draw_label    Boolean, write the tick label?

        """
        # Calculate tick coordinates
        tickangle, tickcos, ticksin = self.canvas_angle(tickpos)
        x0, y0 = self.xcenter + ctr * ticksin, self.ycenter + ctr * tickcos
        x1, y1 = (
            self.xcenter + (ctr + ticklen) * ticksin,
            self.ycenter + (ctr + ticklen) * tickcos,
        )
        # Calculate height of text label so it can be offset on lower half
        # of diagram
        # LP: not used, as not all fonts have ascent_descent data in reportlab.pdfbase._fontdata
        # label_offset = _fontdata.ascent_descent[track.scale_font][0]*\
        #               track.scale_fontsize/1000.
        tick = Line(x0, y0, x1, y1, strokeColor=track.scale_color)
        if draw_label:
            # Put tick position on as label
            if track.scale_format == "SInt":
                if tickpos >= 1000000:
                    tickstring = str(tickpos // 1000000) + " Mbp"
                elif tickpos >= 1000:
                    tickstring = str(tickpos // 1000) + " Kbp"
                else:
                    tickstring = str(tickpos)
            else:
                tickstring = str(tickpos)
            label = String(
                0,
                0,
                tickstring,  # Make label string
                fontName=track.scale_font,
                fontSize=track.scale_fontsize,
                fillColor=track.scale_color,
            )
            if tickangle > pi:
                label.textAnchor = "end"
            # LP: This label_offset depends on ascent_descent data, which is not available for all
            # fonts, so has been deprecated.
            # if 0.5*pi < tickangle < 1.5*pi:
            #    y1 -= label_offset
            labelgroup = Group(label)
            labelgroup.transform = (1, 0, 0, 1, x1, y1)
        else:
            labelgroup = None
        return tick, labelgroup

    def draw_test_tracks(self):
        """Draw blue test tracks with grene line down their center."""
        # Add lines only for drawn tracks
        for track in self.drawn_tracks:
            btm, ctr, top = self.track_radii[track]
            self.drawing.add(
                Circle(
                    self.xcenter,
                    self.ycenter,
                    top,
                    strokeColor=colors.blue,
                    fillColor=None,
                )
            )  # top line
            self.drawing.add(
                Circle(
                    self.xcenter,
                    self.ycenter,
                    ctr,
                    strokeColor=colors.green,
                    fillColor=None,
                )
            )  # middle line
            self.drawing.add(
                Circle(
                    self.xcenter,
                    self.ycenter,
                    btm,
                    strokeColor=colors.blue,
                    fillColor=None,
                )
            )  # bottom line

    def draw_greytrack(self, track):
        """Drawing element for grey background to passed Track object."""
        greytrack_bgs = []  # Holds track backgrounds
        greytrack_labels = []  # Holds track foreground labels

        if not track.greytrack:  # No greytrack required, return early
            return [], []

        # Get track location
        btm, ctr, top = self.track_radii[self.current_track_level]

        start, end = self._current_track_start_end()
        startangle, startcos, startsin = self.canvas_angle(start)
        endangle, endcos, endsin = self.canvas_angle(end)

        # Make background
        if track.start is not None or track.end is not None:
            # Draw an arc, leaving out the wedge
            p = ArcPath(strokeColor=track.scale_color, fillColor=None)
            greytrack_bgs.append(
                self._draw_arc(
                    btm, top, startangle, endangle, colors.Color(0.96, 0.96, 0.96)
                )
            )
        elif self.sweep < 1:
            # Make a partial circle, a large arc box
            # This method assumes the correct center for us.
            greytrack_bgs.append(
                self._draw_arc(
                    btm, top, 0, 2 * pi * self.sweep, colors.Color(0.96, 0.96, 0.96)
                )
            )
        else:
            # Make a full circle (using a VERY thick linewidth)
            greytrack_bgs.append(
                Circle(
                    self.xcenter,
                    self.ycenter,
                    ctr,
                    strokeColor=colors.Color(0.96, 0.96, 0.96),
                    fillColor=None,
                    strokeWidth=top - btm,
                )
            )

        if track.greytrack_labels:
            # Labels are required for this track
            labelstep = self.length // track.greytrack_labels  # label interval
            for pos in range(self.start, self.end, labelstep):
                label = String(
                    0,
                    0,
                    track.name,  # Add a new label at
                    fontName=track.greytrack_font,  # each interval
                    fontSize=track.greytrack_fontsize,
                    fillColor=track.greytrack_fontcolor,
                )
                theta, costheta, sintheta = self.canvas_angle(pos)
                if theta < startangle or endangle < theta:
                    continue
                x, y = (
                    self.xcenter + btm * sintheta,
                    self.ycenter + btm * costheta,
                )  # start text halfway up marker
                labelgroup = Group(label)
                labelangle = (
                    self.sweep * 2 * pi * (pos - self.start) / self.length - pi / 2
                )
                if theta > pi:
                    label.textAnchor = "end"  # Anchor end of text to inner radius
                    labelangle += pi  # and reorient it
                cosA, sinA = cos(labelangle), sin(labelangle)
                labelgroup.transform = (cosA, -sinA, sinA, cosA, x, y)
                if not self.length - x <= labelstep:  # Don't overrun the circle
                    greytrack_labels.append(labelgroup)

        return greytrack_bgs, greytrack_labels

    def canvas_angle(self, base):
        """Given base-pair position, return (angle, cosine, sin) (PRIVATE)."""
        angle = self.sweep * 2 * pi * (base - self.start) / self.length
        return (angle, cos(angle), sin(angle))

    def _draw_sigil_box(
        self, bottom, center, top, startangle, endangle, strand, **kwargs
    ):
        """Draw BOX sigil (PRIVATE)."""
        if strand == 1:
            inner_radius = center
            outer_radius = top
        elif strand == -1:
            inner_radius = bottom
            outer_radius = center
        else:
            inner_radius = bottom
            outer_radius = top
        return self._draw_arc(
            inner_radius, outer_radius, startangle, endangle, **kwargs
        )

    def _draw_arc(
        self,
        inner_radius,
        outer_radius,
        startangle,
        endangle,
        color,
        border=None,
        colour=None,
        **kwargs,
    ):
        """Return closed path describing an arc box (PRIVATE).

        Arguments:
         - inner_radius  Float distance of inside of arc from drawing center
         - outer_radius  Float distance of outside of arc from drawing center
         - startangle    Float angle subtended by start of arc at drawing center
           (in radians)
         - endangle      Float angle subtended by end of arc at drawing center
           (in radians)
         - color        colors.Color object for arc (overridden by backwards
           compatible argument with UK spelling, colour).

        Returns a closed path object describing an arced box corresponding to
        the passed values.  For very small angles, a simple four sided
        polygon is used.
        """
        # Let the UK spelling (colour) override the USA spelling (color)
        if colour is not None:
            color = colour

        strokecolor, color = _stroke_and_fill_colors(color, border)

        if abs(endangle - startangle) > 0.01:
            # Wide arc, must use full curves
            p = ArcPath(strokeColor=strokecolor, fillColor=color, strokewidth=0)
            # Note reportlab counts angles anti-clockwise from the horizontal
            # (as in mathematics, e.g. complex numbers and polar coordinates)
            # but we use clockwise from the vertical.  Also reportlab uses
            # degrees, but we use radians.
            p.addArc(
                self.xcenter,
                self.ycenter,
                inner_radius,
                90 - (endangle * 180 / pi),
                90 - (startangle * 180 / pi),
                moveTo=True,
            )
            p.addArc(
                self.xcenter,
                self.ycenter,
                outer_radius,
                90 - (endangle * 180 / pi),
                90 - (startangle * 180 / pi),
                reverse=True,
            )
            p.closePath()
            return p
        else:
            # Cheat and just use a four sided polygon.
            # Calculate trig values for angle and coordinates
            startcos, startsin = cos(startangle), sin(startangle)
            endcos, endsin = cos(endangle), sin(endangle)
            x0, y0 = self.xcenter, self.ycenter  # origin of the circle
            x1, y1 = (x0 + inner_radius * startsin, y0 + inner_radius * startcos)
            x2, y2 = (x0 + inner_radius * endsin, y0 + inner_radius * endcos)
            x3, y3 = (x0 + outer_radius * endsin, y0 + outer_radius * endcos)
            x4, y4 = (x0 + outer_radius * startsin, y0 + outer_radius * startcos)
            return draw_polygon([(x1, y1), (x2, y2), (x3, y3), (x4, y4)], color, border)

    def _draw_arc_line(
        self, path, start_radius, end_radius, start_angle, end_angle, move=False
    ):
        """Add a list of points to a path object (PRIVATE).

        Assumes angles given are in degrees!

        Represents what would be a straight line on a linear diagram.
        """
        x0, y0 = self.xcenter, self.ycenter  # origin of the circle
        radius_diff = end_radius - start_radius
        angle_diff = end_angle - start_angle
        dx = 0.01  # heuristic
        a = start_angle * pi / 180
        if move:
            path.moveTo(x0 + start_radius * cos(a), y0 + start_radius * sin(a))
        else:
            path.lineTo(x0 + start_radius * cos(a), y0 + start_radius * sin(a))
        x = dx
        if 0.01 <= abs(dx):
            while x < 1:
                r = start_radius + x * radius_diff
                a = (
                    (start_angle + x * (angle_diff)) * pi / 180
                )  # to radians for sin/cos
                # print(x0+r*cos(a), y0+r*sin(a))
                path.lineTo(x0 + r * cos(a), y0 + r * sin(a))
                x += dx
        a = end_angle * pi / 180
        path.lineTo(x0 + end_radius * cos(a), y0 + end_radius * sin(a))

    def _draw_arc_poly(
        self,
        inner_radius,
        outer_radius,
        inner_startangle,
        inner_endangle,
        outer_startangle,
        outer_endangle,
        color,
        border=None,
        flip=False,
        **kwargs,
    ):
        """Return polygon path describing an arc."""
        strokecolor, color = _stroke_and_fill_colors(color, border)

        x0, y0 = self.xcenter, self.ycenter  # origin of the circle
        if (
            abs(inner_endangle - outer_startangle) > 0.01
            or abs(outer_endangle - inner_startangle) > 0.01
            or abs(inner_startangle - outer_startangle) > 0.01
            or abs(outer_startangle - outer_startangle) > 0.01
        ):
            # Wide arc, must use full curves
            p = ArcPath(
                strokeColor=strokecolor,
                fillColor=color,
                # default is mitre/miter which can stick out too much:
                strokeLineJoin=1,  # 1=round
                strokewidth=0,
            )
            # Note reportlab counts angles anti-clockwise from the horizontal
            # (as in mathematics, e.g. complex numbers and polar coordinates)
            # but we use clockwise from the vertical.  Also reportlab uses
            # degrees, but we use radians.
            i_start = 90 - (inner_startangle * 180 / pi)
            i_end = 90 - (inner_endangle * 180 / pi)
            o_start = 90 - (outer_startangle * 180 / pi)
            o_end = 90 - (outer_endangle * 180 / pi)
            p.addArc(x0, y0, inner_radius, i_end, i_start, moveTo=True, reverse=True)
            if flip:
                # Flipped, join end to start,
                self._draw_arc_line(p, inner_radius, outer_radius, i_end, o_start)
                p.addArc(x0, y0, outer_radius, o_end, o_start, reverse=True)
                self._draw_arc_line(p, outer_radius, inner_radius, o_end, i_start)
            else:
                # Not flipped, join start to start, end to end
                self._draw_arc_line(p, inner_radius, outer_radius, i_end, o_end)
                p.addArc(x0, y0, outer_radius, o_end, o_start, reverse=False)
                self._draw_arc_line(p, outer_radius, inner_radius, o_start, i_start)
            p.closePath()
            return p
        else:
            # Cheat and just use a four sided polygon.
            # Calculate trig values for angle and coordinates
            inner_startcos, inner_startsin = (
                cos(inner_startangle),
                sin(inner_startangle),
            )
            inner_endcos, inner_endsin = cos(inner_endangle), sin(inner_endangle)
            outer_startcos, outer_startsin = (
                cos(outer_startangle),
                sin(outer_startangle),
            )
            outer_endcos, outer_endsin = cos(outer_endangle), sin(outer_endangle)
            x1, y1 = (
                x0 + inner_radius * inner_startsin,
                y0 + inner_radius * inner_startcos,
            )
            x2, y2 = (
                x0 + inner_radius * inner_endsin,
                y0 + inner_radius * inner_endcos,
            )
            x3, y3 = (
                x0 + outer_radius * outer_endsin,
                y0 + outer_radius * outer_endcos,
            )
            x4, y4 = (
                x0 + outer_radius * outer_startsin,
                y0 + outer_radius * outer_startcos,
            )
            return draw_polygon(
                [(x1, y1), (x2, y2), (x3, y3), (x4, y4)],
                color,
                border,
                # default is mitre/miter which can stick out too much:
                strokeLineJoin=1,  # 1=round
            )

    def _draw_sigil_cut_corner_box(
        self,
        bottom,
        center,
        top,
        startangle,
        endangle,
        strand,
        color,
        border=None,
        corner=0.5,
        **kwargs,
    ):
        """Draw OCTO sigil, box with corners cut off (PRIVATE)."""
        if strand == 1:
            inner_radius = center
            outer_radius = top
        elif strand == -1:
            inner_radius = bottom
            outer_radius = center
        else:
            inner_radius = bottom
            outer_radius = top

        strokecolor, color = _stroke_and_fill_colors(color, border)

        startangle, endangle = min(startangle, endangle), max(startangle, endangle)
        angle = endangle - startangle

        middle_radius = 0.5 * (inner_radius + outer_radius)
        boxheight = outer_radius - inner_radius

        corner_len = min(0.5 * boxheight, 0.5 * boxheight * corner)
        shaft_inner_radius = inner_radius + corner_len
        shaft_outer_radius = outer_radius - corner_len

        cornerangle_delta = max(
            0.0, min(abs(boxheight) * 0.5 * corner / middle_radius, abs(angle * 0.5))
        )
        if angle < 0:
            cornerangle_delta *= -1  # reverse it

        # Calculate trig values for angle and coordinates
        startcos, startsin = cos(startangle), sin(startangle)
        endcos, endsin = cos(endangle), sin(endangle)
        x0, y0 = self.xcenter, self.ycenter  # origin of the circle
        p = ArcPath(
            strokeColor=strokecolor,
            fillColor=color,
            strokeLineJoin=1,  # 1=round
            strokewidth=0,
            **kwargs,
        )
        # Inner curved edge
        p.addArc(
            self.xcenter,
            self.ycenter,
            inner_radius,
            90 - ((endangle - cornerangle_delta) * 180 / pi),
            90 - ((startangle + cornerangle_delta) * 180 / pi),
            moveTo=True,
        )
        # Corner edge - straight lines assumes small angle!
        # TODO - Use self._draw_arc_line(p, ...) here if we expose corner setting
        p.lineTo(x0 + shaft_inner_radius * startsin, y0 + shaft_inner_radius * startcos)
        p.lineTo(x0 + shaft_outer_radius * startsin, y0 + shaft_outer_radius * startcos)
        # Outer curved edge
        p.addArc(
            self.xcenter,
            self.ycenter,
            outer_radius,
            90 - ((endangle - cornerangle_delta) * 180 / pi),
            90 - ((startangle + cornerangle_delta) * 180 / pi),
            reverse=True,
        )
        # Corner edges
        p.lineTo(x0 + shaft_outer_radius * endsin, y0 + shaft_outer_radius * endcos)
        p.lineTo(x0 + shaft_inner_radius * endsin, y0 + shaft_inner_radius * endcos)
        p.closePath()
        return p

    def _draw_sigil_arrow(
        self, bottom, center, top, startangle, endangle, strand, **kwargs
    ):
        """Draw ARROW sigil (PRIVATE)."""
        if strand == 1:
            inner_radius = center
            outer_radius = top
            orientation = "right"
        elif strand == -1:
            inner_radius = bottom
            outer_radius = center
            orientation = "left"
        else:
            inner_radius = bottom
            outer_radius = top
            orientation = "right"  # backwards compatibility
        return self._draw_arc_arrow(
            inner_radius,
            outer_radius,
            startangle,
            endangle,
            orientation=orientation,
            **kwargs,
        )

    def _draw_sigil_big_arrow(
        self, bottom, center, top, startangle, endangle, strand, **kwargs
    ):
        """Draw BIGARROW sigil, like ARROW but straddles the axis (PRIVATE)."""
        if strand == -1:
            orientation = "left"
        else:
            orientation = "right"
        return self._draw_arc_arrow(
            bottom, top, startangle, endangle, orientation=orientation, **kwargs
        )

    def _draw_arc_arrow(
        self,
        inner_radius,
        outer_radius,
        startangle,
        endangle,
        color,
        border=None,
        shaft_height_ratio=0.4,
        head_length_ratio=0.5,
        orientation="right",
        colour=None,
        **kwargs,
    ):
        """Draw an arrow along an arc (PRIVATE)."""
        # Let the UK spelling (colour) override the USA spelling (color)
        if colour is not None:
            color = colour

        strokecolor, color = _stroke_and_fill_colors(color, border)

        # if orientation == 'right':
        #    startangle, endangle = min(startangle, endangle), max(startangle, endangle)
        # elif orientation == 'left':
        #    startangle, endangle = max(startangle, endangle), min(startangle, endangle)
        # else:
        startangle, endangle = min(startangle, endangle), max(startangle, endangle)
        if orientation != "left" and orientation != "right":
            raise ValueError(
                f"Invalid orientation {orientation!r}, should be 'left' or 'right'"
            )

        angle = endangle - startangle  # angle subtended by arc
        middle_radius = 0.5 * (inner_radius + outer_radius)
        boxheight = outer_radius - inner_radius
        shaft_height = boxheight * shaft_height_ratio
        shaft_inner_radius = middle_radius - 0.5 * shaft_height
        shaft_outer_radius = middle_radius + 0.5 * shaft_height
        headangle_delta = max(
            0.0, min(abs(boxheight) * head_length_ratio / middle_radius, abs(angle))
        )
        if angle < 0:
            headangle_delta *= -1  # reverse it
        if orientation == "right":
            headangle = endangle - headangle_delta
        else:
            headangle = startangle + headangle_delta
        if startangle <= endangle:
            headangle = max(min(headangle, endangle), startangle)
        else:
            headangle = max(min(headangle, startangle), endangle)
        if not (
            startangle <= headangle <= endangle or endangle <= headangle <= startangle
        ):
            raise RuntimeError(
                "Problem drawing arrow, invalid positions. "
                "Start angle: %s, Head angle: %s, "
                "End angle: %s, Angle: %s" % (startangle, headangle, endangle, angle)
            )

        # Calculate trig values for angle and coordinates
        startcos, startsin = cos(startangle), sin(startangle)
        headcos, headsin = cos(headangle), sin(headangle)
        endcos, endsin = cos(endangle), sin(endangle)
        x0, y0 = self.xcenter, self.ycenter  # origin of the circle
        if 0.5 >= abs(angle) and abs(headangle_delta) >= abs(angle):
            # If the angle is small, and the arrow is all head,
            # cheat and just use a triangle.
            if orientation == "right":
                x1, y1 = (x0 + inner_radius * startsin, y0 + inner_radius * startcos)
                x2, y2 = (x0 + outer_radius * startsin, y0 + outer_radius * startcos)
                x3, y3 = (x0 + middle_radius * endsin, y0 + middle_radius * endcos)
            else:
                x1, y1 = (x0 + inner_radius * endsin, y0 + inner_radius * endcos)
                x2, y2 = (x0 + outer_radius * endsin, y0 + outer_radius * endcos)
                x3, y3 = (x0 + middle_radius * startsin, y0 + middle_radius * startcos)
            # return draw_polygon([(x1,y1),(x2,y2),(x3,y3)], color, border,
            #                    stroke_line_join=1)
            return Polygon(
                [x1, y1, x2, y2, x3, y3],
                strokeColor=border or color,
                fillColor=color,
                strokeLineJoin=1,  # 1=round, not mitre!
                strokewidth=0,
            )
        elif orientation == "right":
            p = ArcPath(
                strokeColor=strokecolor,
                fillColor=color,
                # default is mitre/miter which can stick out too much:
                strokeLineJoin=1,  # 1=round
                strokewidth=0,
                **kwargs,
            )
            # Note reportlab counts angles anti-clockwise from the horizontal
            # (as in mathematics, e.g. complex numbers and polar coordinates)
            # but we use clockwise from the vertical.  Also reportlab uses
            # degrees, but we use radians.
            p.addArc(
                self.xcenter,
                self.ycenter,
                shaft_inner_radius,
                90 - (headangle * 180 / pi),
                90 - (startangle * 180 / pi),
                moveTo=True,
            )
            p.addArc(
                self.xcenter,
                self.ycenter,
                shaft_outer_radius,
                90 - (headangle * 180 / pi),
                90 - (startangle * 180 / pi),
                reverse=True,
            )
            if abs(angle) < 0.5:
                p.lineTo(x0 + outer_radius * headsin, y0 + outer_radius * headcos)
                p.lineTo(x0 + middle_radius * endsin, y0 + middle_radius * endcos)
                p.lineTo(x0 + inner_radius * headsin, y0 + inner_radius * headcos)
            else:
                self._draw_arc_line(
                    p,
                    outer_radius,
                    middle_radius,
                    90 - (headangle * 180 / pi),
                    90 - (endangle * 180 / pi),
                )
                self._draw_arc_line(
                    p,
                    middle_radius,
                    inner_radius,
                    90 - (endangle * 180 / pi),
                    90 - (headangle * 180 / pi),
                )
            p.closePath()
            return p
        else:
            p = ArcPath(
                strokeColor=strokecolor,
                fillColor=color,
                # default is mitre/miter which can stick out too much:
                strokeLineJoin=1,  # 1=round
                strokewidth=0,
                **kwargs,
            )
            # Note reportlab counts angles anti-clockwise from the horizontal
            # (as in mathematics, e.g. complex numbers and polar coordinates)
            # but we use clockwise from the vertical.  Also reportlab uses
            # degrees, but we use radians.
            p.addArc(
                self.xcenter,
                self.ycenter,
                shaft_inner_radius,
                90 - (endangle * 180 / pi),
                90 - (headangle * 180 / pi),
                moveTo=True,
                reverse=True,
            )
            p.addArc(
                self.xcenter,
                self.ycenter,
                shaft_outer_radius,
                90 - (endangle * 180 / pi),
                90 - (headangle * 180 / pi),
                reverse=False,
            )
            # Note - two staight lines is only a good approximation for small
            # head angle, in general will need to curved lines here:
            if abs(angle) < 0.5:
                p.lineTo(x0 + outer_radius * headsin, y0 + outer_radius * headcos)
                p.lineTo(x0 + middle_radius * startsin, y0 + middle_radius * startcos)
                p.lineTo(x0 + inner_radius * headsin, y0 + inner_radius * headcos)
            else:
                self._draw_arc_line(
                    p,
                    outer_radius,
                    middle_radius,
                    90 - (headangle * 180 / pi),
                    90 - (startangle * 180 / pi),
                )
                self._draw_arc_line(
                    p,
                    middle_radius,
                    inner_radius,
                    90 - (startangle * 180 / pi),
                    90 - (headangle * 180 / pi),
                )
            p.closePath()
            return p

    def _draw_sigil_jaggy(
        self,
        bottom,
        center,
        top,
        startangle,
        endangle,
        strand,
        color,
        border=None,
        **kwargs,
    ):
        """Draw JAGGY sigil (PRIVATE).

        Although we may in future expose the head/tail jaggy lengths, for now
        both the left and right edges are drawn jagged.
        """
        if strand == 1:
            inner_radius = center
            outer_radius = top
            teeth = 2
        elif strand == -1:
            inner_radius = bottom
            outer_radius = center
            teeth = 2
        else:
            inner_radius = bottom
            outer_radius = top
            teeth = 4

        # TODO, expose these settings?
        tail_length_ratio = 1.0
        head_length_ratio = 1.0

        strokecolor, color = _stroke_and_fill_colors(color, border)

        startangle, endangle = min(startangle, endangle), max(startangle, endangle)
        angle = endangle - startangle  # angle subtended by arc
        height = outer_radius - inner_radius

        assert startangle <= endangle and angle >= 0
        if head_length_ratio and tail_length_ratio:
            headangle = max(
                endangle
                - min(height * head_length_ratio / (center * teeth), angle * 0.5),
                startangle,
            )
            tailangle = min(
                startangle
                + min(height * tail_length_ratio / (center * teeth), angle * 0.5),
                endangle,
            )
            # With very small features, can due to floating point calculations
            # violate the assertion below that start <= tail <= head <= end
            tailangle = min(tailangle, headangle)
        elif head_length_ratio:
            headangle = max(
                endangle - min(height * head_length_ratio / (center * teeth), angle),
                startangle,
            )
            tailangle = startangle
        else:
            headangle = endangle
            tailangle = min(
                startangle + min(height * tail_length_ratio / (center * teeth), angle),
                endangle,
            )

        if not startangle <= tailangle <= headangle <= endangle:
            raise RuntimeError(
                "Problem drawing jaggy sigil, invalid "
                "positions. Start angle: %s, "
                "Tail angle: %s, Head angle: %s, End angle %s, "
                "Angle: %s" % (startangle, tailangle, headangle, endangle, angle)
            )

        # Calculate trig values for angle and coordinates
        startcos, startsin = cos(startangle), sin(startangle)
        headcos, headsin = cos(headangle), sin(headangle)
        endcos, endsin = cos(endangle), sin(endangle)
        x0, y0 = self.xcenter, self.ycenter  # origin of the circle

        p = ArcPath(
            strokeColor=strokecolor,
            fillColor=color,
            # default is mitre/miter which can stick out too much:
            strokeLineJoin=1,  # 1=round
            strokewidth=0,
            **kwargs,
        )
        # Note reportlab counts angles anti-clockwise from the horizontal
        # (as in mathematics, e.g. complex numbers and polar coordinates)
        # but we use clockwise from the vertical.  Also reportlab uses
        # degrees, but we use radians.
        p.addArc(
            self.xcenter,
            self.ycenter,
            inner_radius,
            90 - (headangle * 180 / pi),
            90 - (tailangle * 180 / pi),
            moveTo=True,
        )
        for i in range(teeth):
            p.addArc(
                self.xcenter,
                self.ycenter,
                inner_radius + i * height / teeth,
                90 - (tailangle * 180 / pi),
                90 - (startangle * 180 / pi),
            )
            # Curved line needed when drawing long jaggies
            self._draw_arc_line(
                p,
                inner_radius + i * height / teeth,
                inner_radius + (i + 1) * height / teeth,
                90 - (startangle * 180 / pi),
                90 - (tailangle * 180 / pi),
            )
        p.addArc(
            self.xcenter,
            self.ycenter,
            outer_radius,
            90 - (headangle * 180 / pi),
            90 - (tailangle * 180 / pi),
            reverse=True,
        )
        for i in range(teeth):
            p.addArc(
                self.xcenter,
                self.ycenter,
                outer_radius - i * height / teeth,
                90 - (endangle * 180 / pi),
                90 - (headangle * 180 / pi),
                reverse=True,
            )
            # Curved line needed when drawing long jaggies
            self._draw_arc_line(
                p,
                outer_radius - i * height / teeth,
                outer_radius - (i + 1) * height / teeth,
                90 - (endangle * 180 / pi),
                90 - (headangle * 180 / pi),
            )
        p.closePath()
        return p
