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

#import FreeCAD
from FreeCAD import Base, Vector, Matrix
import Part
from enum import Enum

class MeasurementDirection(Enum):
	width = 1
	height = 2
	depth = 3

# 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 = (False, False, True, True, False, False, True, True)
	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 BoxSide(Enum):
	front = (MeasurementDirection.width, MeasurementDirection.height, SideConfig.large)
	back = (MeasurementDirection.width, MeasurementDirection.height, SideConfig.large)
	left = (MeasurementDirection.depth, MeasurementDirection.height, SideConfig.medium)
	right = (MeasurementDirection.depth, MeasurementDirection.height, SideConfig.small)
	top = (MeasurementDirection.width, MeasurementDirection.depth, SideConfig.small)
	bottom = (MeasurementDirection.width, MeasurementDirection.depth, SideConfig.medium)

	def __init__(self, directionX, directionY, sideConfig):
		self.directionX = directionX
		self.directionY = directionY
		self.sideConfig = sideConfig

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._notches = 10
		self._notchSize = 10
		self.outerDimmensions(100, 100, 100)
		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 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 = sideLength / (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("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.dir = dir

		self.current = current
		self.list = []

	def move(self, x, y, z):
		self.current = self.current.add(Vector(x, y, z))
		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)

	v = [Vector(0, 0, 0)]
	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 makeBox(doc, cfg):
	objects = {}
	# front back left
	# right top bottom

	# TODO: replace m.move() with a proper translation matrix so it looks assembled

	m = Matrix()
	m.move(cfg.outerWidth * -0.55, 0, 0)
	s = Part.makePolygon(makeBoxSide(cfg, BoxSide.front))
	s.transformShape(m)
	front = doc.addObject("Part::Feature", "Front")
	front.Shape = s

	m = Matrix()
	m.move(cfg.outerWidth * 0.55, 0, 0)
	s = Part.makePolygon(makeBoxSide(cfg, BoxSide.back))
	s.transformShape(m)
	back = doc.addObject("Part::Feature", "Back")
	back.Shape = s
	
	m = Matrix()
	m.move(cfg.outerWidth * 1.60, 0, 0)
	l = Part.makePolygon(makeBoxSide(cfg, BoxSide.left))
	l.transformShape(m)
	left = doc.addObject("Part::Feature", "Left")
	left.Shape = l

	m = Matrix()
	m.move(cfg.outerWidth * -0.55, cfg.outerWidth * -1.1, 0)
	l = Part.makePolygon(makeBoxSide(cfg, BoxSide.right))
	l.transformShape(m)
	right = doc.addObject("Part::Feature", "Right")
	right.Shape = l
	
	m = Matrix()
	m.move(cfg.outerWidth * 0.55, cfg.outerWidth * -1.1, 0)
	l = Part.makePolygon(makeBoxSide(cfg, BoxSide.top))
	l.transformShape(m)
	top = doc.addObject("Part::Feature", "Top")
	top.Shape = l
	
	m = Matrix()
	m.move(cfg.outerWidth * 1.60, cfg.outerWidth * -1.1, 0)
	l = Part.makePolygon(makeBoxSide(cfg, BoxSide.bottom))
	l.transformShape(m)
	bottom = doc.addObject("Part::Feature", "Bottom")
	bottom.Shape = l
	
	return {'front': front, 'back': back,
		'left': left, 'right': right,
		'top': top, 'bottom': bottom}

def makeExtrudes(doc, cfg):
	
	def makeExtrude(doc, cfg, name, part):
		extrude = doc.addObject("Part::Extrusion", name + "_Extrude")
		extrude.Base = part
		extrude.Dir = (0, 0, cfg.thickness)
		extrude.Solid = (True)
		extrude.TaperAngle = (0)
		extrude.Label = name + ' 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

	objects = {}
	objects['front'] = makeExtrude(doc, cfg, "Front", doc.Front)
	objects['back'] = makeExtrude(doc, cfg, "Back", doc.Back)
	objects['left'] = makeExtrude(doc, cfg, "Left", doc.Left)
	objects['right'] = makeExtrude(doc, cfg, "Right", doc.Right)
	objects['top'] = makeExtrude(doc, cfg, "Top", doc.Top)
	objects['bottom'] = makeExtrude(doc, cfg, "Bottom", doc.Bottom)
	return objects

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

	rm("Top_Extrude")
	rm("Back_Extrude")
	rm("Left_Extrude")
	rm("Front_Extrude")
	rm("Right_Extrude")
	rm("Bottom_Extrude")

	rm("Top")
	rm("Back")
	rm("Left")
	rm("Front")
	rm("Right")
	rm("Bottom")