# import Boxer; reload(Boxer); import BoxerGui as bg; reload(bg);

#import FreeCAD
from FreeCAD import Base, Vector, Matrix, Placement, Rotation
import Part
from enum import Enum
import math


# These names are silly, should be X, Y, Z instead
class MeasurementDirection(Enum):
    width = 1  # X
    height = 2  # Z
    depth = 3  # Y


# X and Y rotation factors
class LineDirection(Enum):
    right = (1, 0, 0, 1)
    down = (0, -1, 1, 0)
    left = (-1, 0, 0, -1)
    up = (0, 1, -1, 0)

    def __init__(self, x_x, x_y, y_x, y_y):
        self.x_x = x_x
        self.x_y = x_y
        self.y_x = y_x
        self.y_y = y_y


# Configuration for each line in a box side
class SideConfig(Enum):
    large = (False, True, False, True, False, True, False, True)
    medium = (True, True, False, False, True, True, False, False)
    small = (True, False, True, False, True, False, True, False)

    def __init__(self, rightInv, rightIncludeStart, downInv, downIncludeStart, leftInv, leftIncludeStart, upInv, upIncludeStart):
        self.rightInv = rightInv
        self.rightIncludeStart = rightIncludeStart
        self.downInv = downInv
        self.downIncludeStart = downIncludeStart
        self.leftInv = leftInv
        self.leftIncludeStart = leftIncludeStart
        self.upInv = upInv
        self.upIncludeStart = upIncludeStart

    def inv(self, direction):
        if direction == LineDirection.right:
            return self.rightInv
        elif direction == LineDirection.down:
            return self.downInv
        elif direction == LineDirection.left:
            return self.leftInv
        elif direction == LineDirection.up:
            return self.upInv
        else:
            raise Exception("Unknown direction: " + repr(direction))

    def includeStart(self, direction):
        if direction == LineDirection.right:
            return self.rightIncludeStart
        elif direction == LineDirection.down:
            return self.downIncludeStart
        elif direction == LineDirection.left:
            return self.leftIncludeStart
        elif direction == LineDirection.up:
            return self.upIncludeStart
        else:
            raise Exception("Unknown direction: " + repr(direction))


class SideType(Enum):
    front = 1
    back = 2
    left = 3
    right = 4
    top = 5
    bottom = 6


class BoxSide(object):
    def __init__(self, title, directionX, directionY, sideConfig, extrudeVector):
        self.title = title
        self.directionX = directionX
        self.directionY = directionY
        self.sideConfig = sideConfig
        self.extrudeVector = Vector(extrudeVector)
        self.enabled = True


class NotchConfig(object):
    def __init__(self, count, size):
        self.count = count
        self.size = size

    def __str__(self):
        return "count = " + str(self.count) + ", size = " + str(self.size)


class BoxCfg(object):
    def __init__(self):
        self._thickness = 10
        self._notchSize = 10
        self.generateExtrudes = True
        self.generateCrossSections = False  # Not very useful so off by default
        self.outerDimmensions(100, 100, 100)
        self.sides = {
            SideType.front: BoxSide('Front', MeasurementDirection.width, MeasurementDirection.height, SideConfig.large, (0, -1, 0)),
            SideType.back: BoxSide('Back', MeasurementDirection.width, MeasurementDirection.height, SideConfig.large, (0, 1, 0)),
            SideType.left: BoxSide('Left', MeasurementDirection.depth, MeasurementDirection.height, SideConfig.small, (-1, 0, 0)),
            SideType.right: BoxSide('Right', MeasurementDirection.depth, MeasurementDirection.height, SideConfig.small, (1, 0, 0)),
            SideType.top: BoxSide('Top', MeasurementDirection.width, MeasurementDirection.depth, SideConfig.medium, (0, 0, 1)),
            SideType.bottom: BoxSide('Bottom', MeasurementDirection.width, MeasurementDirection.depth, SideConfig.medium, (0, 0, -1))
        }
        self.calculate()

    @property
    def thickness(self):
        return self._thickness

    @thickness.setter
    def thickness(self, thickness):
        self._thickness = thickness
        self.calculate()

# TODO: replace this with a way to set number of notches in each direction
#	@property
#	def notches(self):
#		return self._notches
#
#	@notches.setter
#	def notches(self, notches):
#		self._notches = notches
#		self.calculate()

    @property
    def notchSize(self):
        return self._notchSize

    @notchSize.setter
    def notchSize(self, notchSize):
        self._notchSize = notchSize

    def side(self, sideType):
        return self.sides[sideType]

    def outerDimmensions(self, width, height, depth):
        self.outerWidth = width
        self.outerHeight = height
        self.outerDepth = depth
        self.calculate()
        return self

    def notchConfig(self, direction):
        if direction == MeasurementDirection.width:
            return self._notchConfigWidth
        elif direction == MeasurementDirection.height:
            return self._notchConfigHeight
        elif direction == MeasurementDirection.depth:
            return self._notchConfigDepth
        else:
            raise Exception("Unknown MeasurementDirection: " + str(direction))

    def createNotchConfig(self, sideLength):
        count = sideLength / self._notchSize
        size = float(sideLength) / float(count * 2 + 1)
        return NotchConfig(count, size)

    def calculate(self):
        self.innerWidth = self.outerWidth - 2 * self._thickness
        self.innerHeight = self.outerHeight - 2 * self._thickness
        self.innerDepth = self.outerDepth - 2 * self._thickness
        self._notchConfigWidth = self.createNotchConfig(self.innerWidth)
        self._notchConfigHeight = self.createNotchConfig(self.innerHeight)
        self._notchConfigDepth = self.createNotchConfig(self.innerDepth)

    def prt(self):
        print("Box configuration")
        print("Thickness  : " + str(self._thickness))
        print("Outer w/h/d: " + str(self.outerWidth) + "/" + str(self.outerHeight) + "/" + str(self.outerDepth))
        print("Inner w/h/d: " + str(self.innerWidth) + "/" + str(self.innerHeight) + "/" + str(self.innerDepth))
        print("Sides:")
        for (sideType, boxSide) in self.sides.items():
            print("  {:<9}: enabled: {}".format(boxSide.title, boxSide.enabled))
        print("Notch size : " + str(self._notchSize))
        print("  Width:     " + str(self.notchConfig(MeasurementDirection.width)))
        print("  Height:    " + str(self.notchConfig(MeasurementDirection.height)))
        print("  Depth:     " + str(self.notchConfig(MeasurementDirection.depth)))


class VGen(object):
    def __init__(self, current, dir):
        self.current = current
        self.dir = dir
        self.list = []

    def move(self, x, y, z=0):
        pos = Vector(x, y, z)
        self.current = self.current.add(pos)
        self.list.append(self.current)

    def moveX(self, value):
        self.move(self.dir.x_x * value, self.dir.x_y * value, 0)

    def moveY(self, value):
        self.move(self.dir.y_x * value, self.dir.y_y * value, 0)


def line(cfg, start, lineDirection, sideConfig, notchConfig):

    inv = -1 if sideConfig.inv(lineDirection) else 1
    includeStart = sideConfig.includeStart(lineDirection)

    g = VGen(start, lineDirection)

    if includeStart:
        g.moveX(cfg.thickness)

    g.moveX(notchConfig.size)
    for i in range(0, notchConfig.count):
        g.moveY(-cfg.thickness * inv)
        g.moveX(notchConfig.size)
        g.moveY(cfg.thickness * inv)
        g.moveX(notchConfig.size)

    if includeStart:
        g.moveX(cfg.thickness)

    return g.list


def makeBoxSide(cfg, boxSide):
    notchConfigX = cfg.notchConfig(boxSide.directionX)
    notchConfigY = cfg.notchConfig(boxSide.directionY)

    # Offset the start so that the inner area starts at (0, 0)
    if boxSide.sideConfig is SideConfig.large:
        start = Vector(-cfg.thickness, cfg.thickness, 0)
    elif boxSide.sideConfig is SideConfig.medium:
        start = Vector(-cfg.thickness, 0, 0)
    else:
        start = Vector(0, 0, 0)

    v = [start]
    top = line(cfg, v[-1], LineDirection.right, boxSide.sideConfig, notchConfigX)
    v.extend(top)
    left = line(cfg, v[-1], LineDirection.down, boxSide.sideConfig, notchConfigY)
    v.extend(left)
    bottom = line(cfg, v[-1], LineDirection.left, boxSide.sideConfig, notchConfigX)
    v.extend(bottom)
    right = line(cfg, v[-1], LineDirection.up, boxSide.sideConfig, notchConfigY)
    v.extend(right)
    return v


def makeParts(doc, cfg):
    parts = {}

    sep = cfg.outerWidth * 0.05

    def m(rotX, rotY, moveX, moveY, moveZ):
        if rotX and rotY:
            p = Placement(Vector(0, 0, 0), Rotation(Vector(1, 1, 1), 120))
            m = p.toMatrix()
        else:
            m = Matrix()
            if rotX:
                m.rotateX(math.radians(90))
            if rotY:
                m.rotateY(math.radians(90))

        v = Vector(cfg.innerWidth, cfg.innerDepth, cfg.innerHeight)
        v.scale(moveX, moveY, moveZ)

        m.move(v)
        return m

    # yapf: disable
    ms = {
        SideType.front:  m(True,  False, -0.5, -0.5,  0.5),
        SideType.back:   m(True,  False, -0.5,  0.5,  0.5),
        SideType.left:   m(True,  True,  -0.5, -0.5,  0.5),
        SideType.right:  m(True,  True,   0.5, -0.5,  0.5),
        SideType.top:    m(False, False, -0.5,  0.5,  0.5),
        SideType.bottom: m(False, False, -0.5,  0.5, -0.5)
    }
    # yapf: enable

    for sideType in SideType:
        boxSide = cfg.side(sideType)

        if not boxSide.enabled:
            continue

        s = Part.makePolygon(makeBoxSide(cfg, boxSide))
        s.transformShape(ms[sideType])
        feature = doc.addObject("Part::Feature", boxSide.title + '_Part')
        feature.Label = boxSide.title + ' Part'
        feature.Shape = s
        parts[sideType] = feature

    return parts


def makeExtrudes(doc, parts, cfg):
    def makeExtrude(doc, cfg, sideType):
        side = cfg.side(sideType)
        part = parts[sideType]
        extrude = doc.addObject("Part::Extrusion", side.title + "_Extrude")
        extrude.Base = part
        extrude.Dir = side.extrudeVector * cfg.thickness
        extrude.Solid = (True)
        extrude.TaperAngle = (0)
        extrude.Label = side.title + ' Extrude'

        partView = part.ViewObject
        extrudeView = extrude.ViewObject

        if partView is not None and extrudeView is not None:
            partView.Visibility = False
            extrudeView.ShapeColor = partView.ShapeColor
            extrudeView.LineColor = partView.LineColor
            extrudeView.PointColor = partView.PointColor

        return extrude

    extrudes = {}
    for sideType, part in parts.items():
        extrudes[sideType] = makeExtrude(doc, cfg, sideType)

    return extrudes


def makeCrossSections(doc, cfg, extrudes):
    def makeCrossSection(extrude, name):
        wires = list()
        shape = extrude.Shape

        for i in shape.slice(Base.Vector(0, 0, 1), cfg.thickness / 2):
            wires.append(i)

        comp = Part.Compound(wires)
        cs = doc.addObject("Part::Feature", name + "_Cross_Section")
        cs.Shape = comp
        cs.ViewObject.Visibility = False
        cs.purgeTouched()
        return cs

    crossSections = {}
    for key, extrude in extrudes.items():
        crossSections[key] = makeCrossSection(extrude, key.title())
    return crossSections


def make(doc, cfg):
    # Cretate the underlying parts
    parts = makeParts(doc, cfg)

    if cfg.generateExtrudes:
        extrudes = makeExtrudes(doc, parts, cfg)

        box = doc.addObject("App::DocumentObjectGroup", "Box")
        for e in extrudes.values():
            box.addObject(e)

    doc.recompute()

    crossSections = None
    if cfg.generateCrossSections:
        crossSections = makeCrossSections(doc, cfg, extrudes)
        crossSectionsGroup = doc.addObject("App::DocumentObjectGroup", "Cross Sections")
        [crossSectionsGroup.addObject(cs) for cs in crossSections.values()]

    return {'parts': parts, 'extrudes': extrudes, 'crossSections': crossSections}


def removeEverything(doc):
    def rm(name):
        if hasattr(doc, name):
            doc.removeObject(name)

    rm("Box")
    rm("Cross Sections")

    for key in ['Front', 'Back', 'Left', 'Right', 'Top', 'Bottom']:
        rm(key + '_Cross_Section')
        rm(key + '_Extrude')
        rm(key + '_Part')