# ***************************************************************************** #
 #
 # MIT License
 #
 # Copyright (c) 2018 Benjamin Collins (kion @ dashgl.com)
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in all
 # copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 #
 # ***************************************************************************** #

import os
import time
import bpy
import mathutils
from struct import *

class DashLoader:

	# Constructor

	def __init__(self):

		self.blocks = {
			'ATTR' : [],
			'NAME' : [],
			'BONE' : [],
			'VERT' : [],
			'TEX' : [],
			'MAT' : [],
			'FACE' : [],
			'ANIM' : []
		}

		self.attrs = {
			'vertex_weight' : 0,
			'uv_count' : 0,
			'vertex_normals' : 0,
			'vertex_colors' : 0
		}

		self.names = {
			'bone' : [],
			'tex' : [],
			'anim' : []
		}

		self.bones = []
		self.verts = []
		self.indices = []
		self.weights = []
		self.faces = []
		self.normals = []
		self.colors = []
		self.uvs = []
		self.texList = []
		self.matList = []

	def readMagic(self):
		bytes = self.view.read(4)
		magic = str(bytes, "ASCII")
		return magic

	def parse(self, filepath):

		self.view = open(filepath, 'rb')
		self.readHeader()
		self.readAttrs()
		self.readNames()
		self.readBones()
		self.readVertices()
		self.readTextures()
		self.readMaterials()
		self.readFaceGroups()
		self.readAnimations()

		self.createMesh()

	def readHeader(self):

		data = self.view.read(16)
		s = unpack('4sIII', data)

		magic = s[0]
		ofs = s[1]
		version = s[2]
		nbBlocks = s[3]

		if magic != b'DMF\x00':
			raise ValueError('Magic number does not indicate DMF file')

		if version != 1:
			raise ValueError('Version not supported')

		self.view.seek(ofs);

		for i in range(0, nbBlocks):
			data = self.view.read(16)
			s = unpack('4sIII', data)

			if s[0] == b'ATTR':
				self.blocks['ATTR'].append(s)
			elif s[0] == b'NAME':
				self.blocks['NAME'].append(s)
			elif s[0] == b'BONE':
				self.blocks['BONE'].append(s)
			elif s[0] == b'VERT':
				self.blocks['VERT'].append(s)
			elif s[0] == b'TEX\x00':
				self.blocks['TEX'].append(s)
			elif s[0] == b'MAT\x00':
				self.blocks['MAT'].append(s)
			elif s[0] == b'FACE':
				self.blocks['FACE'].append(s)
			elif s[0] == b'ANIM':
				self.blocks['ANIM'].append(s)
		return 0

	def readAttrs(self):

		if not len(self.blocks['ATTR']):
			return

		block = self.blocks['ATTR'][0]
		ofs = block[1]
		nbAttr = block[3]

		self.view.seek(ofs)
		data = self.view.read(8)
		s = unpack('4sI', data)

		if s[0] != b'ATTR':
			raise ValueError('Magic number does not indicate ATTR block')

		for i in range(0, nbAttr):
			data = self.view.read(8)
			s = unpack('4sI', data)

			if s[0] == b'VWGT':
				self.attrs['vertex_weight'] = s[1]
			elif s[0] == b'UVCT':
				self.attrs['uv_count'] = s[1]
			elif s[0] == b'VNRM':
				self.attrs['vertex_normals'] = s[1]
			elif s[0] == b'VCLR':
				self.attrs['vertex_colors'] = s[1]
		return 0

	def readNames(self):

		for block in self.blocks['NAME']:
			ofs = block[1]
			nbName = block[3]
			self.view.seek(ofs)
			data = self.view.read(12)
			s = unpack('4sI4s', data)

			if s[0] != b'NAME':
				raise ValueError('Magic number does not indicate NAME block')

			type = s[2].decode('ascii')
			data = self.view.read(s[1])
			data = data.split(b'\x00')

			for i in range(0, nbName):
				self.names[type].append(data[i].decode("ascii"))
		return 0

	def readBones(self):

		if not len(self.blocks['BONE']):
			return

		block = self.blocks['BONE'][0]
		ofs = block[1]
		nbBone = block[3]

		self.view.seek(ofs)
		data = self.view.read(8)
		s = unpack('4sI', data)

		if s[0] != b'BONE':
			raise ValueError('Magic number does not indicate BONE block')

		for i in range(0, nbBone):
			data = self.view.read(68)
			s = unpack('hhffffffffffffffff', data)
			self.bones.append(s)
		return 0

	def readVertices(self):

		if not len(self.blocks['VERT']):
			return

		block = self.blocks['VERT'][0]
		ofs = block[1]
		nbVert = block[3]

		self.view.seek(ofs)
		data = self.view.read(8)
		s = unpack('4sI', data)

		if s[0] != b'VERT':
			raise ValueError('Magic number does not indicate VERT block')

		for i in range(0, nbVert):
			data = self.view.read(12)
			s = unpack('fff', data)
			tpl = (s[0], s[2], s[1])
			self.verts.append(tpl)

			if not self.attrs['vertex_weight']:
				continue

			data = self.view.read(24)
			s = unpack('HHHHffff', data)
			self.weights.append(s)
		print(self.verts)

		return 0

	def readTextures(self):
		return 0

	def readMaterials(self):
		return 0

	def readFaceGroups(self):

		for block in self.blocks['FACE']:
			ofs = block[1]
			matIndex = block[2]
			nbIndex = block[3]
			self.view.seek(ofs)
			data = self.view.read(8)
			s = unpack('4sI', data)

			if s[0] != b'FACE':
				raise ValueError('Magic number does not indicate FACE block')

			for i in range(0, nbIndex):
				data = self.view.read(2)
				s = unpack('H', data)
				self.indices.append(s[0])

				for i in range(0, self.attrs['uv_count']):
					data = self.view.read(8)
					s = unpack('ff', data)
					self.uvs.append(s)

				if self.attrs['vertex_normals']:
					data = self.view.read(12)
					s = unpack('fff', data)
					self.normals.append(s)

				if self.attrs['vertex_colors']:
					data = self.view.read(12)
					s = unpack('fff', data)
					self.colors.append(s)

		for i in range(0, nbIndex, 3):
			a = self.indices[i + 0]
			b = self.indices[i + 1]
			c = self.indices[i + 2]
			tpl = (a, b, c)
			self.faces.append(tpl)
		return 0

	def readAnimations(self):
		return 0

	def createMesh(self):
		me = bpy.data.meshes.new("kion")
		me.from_pydata(self.verts, [], self.faces)
		ob = bpy.data.objects.new("balls", me)
		ob.data = me
		scene = bpy.context.scene
		scene.objects.link(ob)
		return 0