from .stitch import Stitch
from .stop import process_stop
from .trim import process_trim
from .ties import add_ties
from ..svg import PIXELS_PER_MM
from ..utils.geometry import Point
from ..threads import ThreadColor


def patches_to_stitch_plan(patches, collapse_len=3.0 * PIXELS_PER_MM):
    """Convert a collection of inkstitch.element.Patch objects to a StitchPlan.

    * applies instructions embedded in the Patch such as trim_after and stop_after
    * adds tie-ins and tie-offs
    * adds jump-stitches between patches if necessary
    """

    stitch_plan = StitchPlan()
    color_block = stitch_plan.new_color_block()

    need_trim = False
    for patch in patches:
        if not patch.stitches:
            continue

        if not color_block.has_color():
            # set the color for the first color block
            color_block.color = patch.color

        if color_block.color == patch.color:
            if need_trim:
                process_trim(color_block, patch.stitches[0])
                need_trim = False

            # add a jump stitch between patches if the distance is more
            # than the collapse length
            if color_block.last_stitch:
                if (patch.stitches[0] - color_block.last_stitch).length() > collapse_len:
                    color_block.add_stitch(patch.stitches[0].x, patch.stitches[0].y, jump=True)

        else:
            # add a color change (only if we didn't just do a "STOP after")
            if not color_block.last_stitch.color_change:
                stitch = color_block.last_stitch.copy()
                stitch.color_change = True
                color_block.add_stitch(stitch)

            color_block = stitch_plan.new_color_block()
            color_block.color = patch.color

        color_block.filter_duplicate_stitches()
        color_block.add_stitches(patch.stitches, no_ties=patch.stitch_as_is)

        if patch.trim_after:
            # a trim needs to be followed by a jump to the next stitch, so
            # we'll process it when we start the next patch
            need_trim = True

        if patch.stop_after:
            process_stop(color_block)

    add_jumps(stitch_plan)
    add_ties(stitch_plan)

    return stitch_plan


def add_jumps(stitch_plan):
    """Add a JUMP stitch at the start of each color block."""

    for color_block in stitch_plan:
        stitch = color_block.stitches[0].copy()
        stitch.jump = True
        color_block.stitches.insert(0, stitch)


class StitchPlan(object):
    """Holds a set of color blocks, each containing stitches."""

    def __init__(self):
        self.color_blocks = []

    def new_color_block(self, *args, **kwargs):
        color_block = ColorBlock(*args, **kwargs)
        self.color_blocks.append(color_block)
        return color_block

    def __iter__(self):
        return iter(self.color_blocks)

    def __len__(self):
        return len(self.color_blocks)

    def __repr__(self):
        return "StitchPlan(%s)" % ", ".join(repr(cb) for cb in self.color_blocks)

    @property
    def num_colors(self):
        """Number of unique colors in the stitch plan."""
        return len({block.color for block in self})

    @property
    def num_stops(self):
        return sum(block.num_stops for block in self)

    @property
    def num_trims(self):
        return sum(block.num_trims for block in self)

    @property
    def num_stitches(self):
        return sum(block.num_stitches for block in self)

    @property
    def bounding_box(self):
        color_block_bounding_boxes = [cb.bounding_box for cb in self]
        minx = min(bb[0] for bb in color_block_bounding_boxes)
        miny = min(bb[1] for bb in color_block_bounding_boxes)
        maxx = max(bb[2] for bb in color_block_bounding_boxes)
        maxy = max(bb[3] for bb in color_block_bounding_boxes)

        return minx, miny, maxx, maxy

    @property
    def dimensions(self):
        minx, miny, maxx, maxy = self.bounding_box
        return (maxx - minx, maxy - miny)

    @property
    def extents(self):
        minx, miny, maxx, maxy = self.bounding_box

        return max(-minx, maxx), max(-miny, maxy)

    @property
    def dimensions_mm(self):
        dimensions = self.dimensions
        return (dimensions[0] / PIXELS_PER_MM, dimensions[1] / PIXELS_PER_MM)


class ColorBlock(object):
    """Holds a set of stitches, all with the same thread color."""

    def __init__(self, color=None, stitches=None):
        self.color = color
        self.stitches = stitches or []

    def __iter__(self):
        return iter(self.stitches)

    def __repr__(self):
        return "ColorBlock(%s, %s)" % (self.color, self.stitches)

    def has_color(self):
        return self._color is not None

    @property
    def color(self):
        return self._color

    @color.setter
    def color(self, value):
        if isinstance(value, ThreadColor):
            self._color = value
        elif value is None:
            self._color = None
        else:
            self._color = ThreadColor(value)

    @property
    def last_stitch(self):
        if self.stitches:
            return self.stitches[-1]
        else:
            return None

    @property
    def num_stitches(self):
        """Number of stitches in this color block."""
        return len(self.stitches)

    @property
    def num_stops(self):
        """Number of pauses in this color block."""

        # Stops are encoded using two STOP stitches each.  See the comment in
        # stop.py for an explanation.

        return sum(1 for stitch in self if stitch.stop) / 2

    @property
    def num_trims(self):
        """Number of trims in this color block."""

        return sum(1 for stitch in self if stitch.trim)

    def filter_duplicate_stitches(self):
        if not self.stitches:
            return

        stitches = [self.stitches[0]]

        for stitch in self.stitches[1:]:
            if stitches[-1].jump or stitch.stop or stitch.trim:
                # Don't consider jumps, stops, or trims as candidates for filtering
                pass
            else:
                l = (stitch - stitches[-1]).length()
                if l <= 0.1:
                    # duplicate stitch, skip this one
                    continue

            stitches.append(stitch)

        self.stitches = stitches

    def add_stitch(self, *args, **kwargs):
        if isinstance(args[0], Stitch):
            self.stitches.append(args[0])
        elif isinstance(args[0], Point):
            self.stitches.append(Stitch(args[0].x, args[0].y, *args[1:], **kwargs))
        else:
            self.stitches.append(Stitch(*args, **kwargs))

    def add_stitches(self, stitches, *args, **kwargs):
        for stitch in stitches:
            if isinstance(stitch, (Stitch, Point)):
                self.add_stitch(stitch, *args, **kwargs)
            else:
                self.add_stitch(*(list(stitch) + args), **kwargs)

    def replace_stitches(self, stitches):
        self.stitches = stitches

    @property
    def bounding_box(self):
        minx = min(stitch.x for stitch in self)
        miny = min(stitch.y for stitch in self)
        maxx = max(stitch.x for stitch in self)
        maxy = max(stitch.y for stitch in self)

        return minx, miny, maxx, maxy
