from array import array
from tidal3d import *


class Mesh:

    def __init__(self, filename):
        # A face is made of 3 vertices, a normal vector, and a material
        self.vertices = []
        self.normals = []
        self.colours = []

        # To prevent duplication of data (and therefore saving on expensive memory and calculation
        # time) we store each unique vertex, normal and material once and instead keep per-face
        # indices into the above lists
        self.vert_indices = []
        self.norm_indices = []
        self.col_indices = []

        # A face-oriented view into the above index data for convenience
        # It is a list of (vert_index, norm_index, col_index) tuples
        self.faces = []

        # Pre-allocated space for face index/depth pairs for depth-sorting faces
        self.depth_map = None

        # Pre-allocated space for transformed vertices and normals
        self.vertices_trans = None
        self.normals_trans = None

        # Load mesh and material data
        self._load(filename)

        # Position and linear velocity
        self.position = array('f', [0, 0, 0])
        self.velocity = array('f', [0, 0, 0])
        self.delta_v = array('f', [0, 0, 0])

        # Orientation and angular velocity
        self.orientation = array('f', [1, 0, 0, 0])
        self.angular = array('f', [0, 0, 0])
        self.axis = array('f', [0, 0, 0])

    def rotate_y(self, val):
        self.angular[1] = val

    def rotate_x(self, val):
        self.angular[0] = val

    def _load(self, filename):
        # Parse the geometry file
        op = ObjectParser()
        op.parse("apps/tidal_3d/" + filename)

        self.vertices = op.vertices
        self.vert_indices = [f['indices'] for f in op.faces]

        # Pre-calculate face normal vectors, a normal is the direction exactly perpendicular to
        # the plane of the face, the direction the front of the face is pointing
        a = array('f', [0, 0, 0])
        b = array('f', [0, 0, 0])
        for face in self.vert_indices:
            v_subtract(self.vertices[face[0]], self.vertices[face[1]], a)
            v_subtract(self.vertices[face[1]], self.vertices[face[2]], b)
            normal = array('f', [0, 0, 0])
            v_cross(a, b, normal)
            v_normalise(normal)
            # TODO normal deduplication -- "item in list" is not implemented in micropython for lists of arrays
            self.normals.append(normal)
            self.norm_indices.append(len(self.normals) - 1)

        # If the geometry has materials, let's also parse the accompanying material library file
        if op.mat_lib:
            mp = MaterialParser()
            mp.parse("apps/tidal_3d/" + op.mat_lib)

            # Use the material's diffuse colour for the colour of the faces
            self.col_indices = [0] * len(self.vert_indices)
            for material in mp.materials:
                self.colours.append(array('f', material['diffuse']))
                for i in range(len(op.faces)):
                    if op.faces[i]['material'] == material['name']:
                        self.col_indices[i] = len(self.colours) - 1
        else:
            # Just default to all white faces if no materials specified
            self.colours.append(array('f', [255, 255, 255]))
            self.col_indices = [0] * len(self.vert_indices)

        # Create a face-oriented view of index data
        for i in range(len(self.vert_indices)):
            self.faces.append([self.vert_indices[i], self.norm_indices[i], self.col_indices[i]])

        # Pre-allocate some working space for face index/depth pairs for depth-sorting faces
        self.depth_map = array('f', [0] * (len(self.faces) * 2))

        # Pre-allocate some working space for transforming vertices and normals
        self.vertices_trans = [None] * len(self.vertices)
        for i in range(len(self.vertices)):
            self.vertices_trans[i] = array('f', [0, 0, 0])
        self.normals_trans = [None] * len(self.normals)
        for i in range(len(self.normals)):
            self.normals_trans[i] = array('f', [0, 0, 0])

    def update(self, delta_t):
        # Move our position by our velocity
        v_scale(self.velocity, delta_t, self.delta_v)
        v_add(self.position, self.delta_v)
        # Rotate ourselves around the axis
        degrees = v_magnitude(self.angular)
        v_normalise(self.angular, self.axis)
        q_rotate(self.orientation, degrees * delta_t, self.axis)


class ParserInterface:
    """
    General interface for Wavefront geometry style file parsers, each non-comment line is tokenised
    and then passed into the parameter method for decoding; sub-classes implement the parameter
    method according to the specific file type they want to parse; the finish method will be called
    when the end of the file is reached
    """

    def parameter(self, name, values):
        pass

    def finish(self):
        pass

    def parse(self, file):
        with open(file) as f:
            while line := f.readline():
                # Ignore comments and empty lines
                line = line.strip()
                if not line or line.startswith("#"):
                    continue
                tokens = line.split()
                # Decode the parameter
                self.parameter(tokens[0], tokens[1:])
            # Do any tidy up the parser needs to do
            self.finish()


class ObjectParser(ParserInterface):
    """
    A parser for Wavefront object geometry files (*.obj)
    """

    def __init__(self):
        self.mat_lib = None
        self.current_mat = None
        self.vertices = []
        self.faces = []

    def parameter(self, name, values):
        # This gives the file containing the material library
        if name == 'mtllib':
            self.mat_lib = values[0]
        # Set the active material for the following faces
        if name == 'usemtl':
            self.current_mat = values[0]
        # Extract a vertex
        if name == 'v':
            self.vertices.append(array('f', [float(v) for v in values]))
        # Extract a face
        if name == 'f':
            # Faces are given as "vert_index/uv_index/normal_index" triplets but we don't support
            # texturing, so ignore the uv part, and we don't support anything other than flat shading,
            # so ignore the vertex normals part -- since we know face vertices have anti-clockwise
            # winding, we can just calculate face normals ourselves
            vert_indices = [int(a.split('/')[0]) - 1 for a in values]

            face = {'material':self.current_mat, 'indices':vert_indices}
            self.faces.append(face)


class MaterialParser(ParserInterface):
    """
    A parser for Wavefront material library files (*.mtl)
    """

    def __init__(self):
        self.materials = []
        self.current = None

    def parameter(self, name, values):
        # A new material is being defined
        if name == 'newmtl':
            if self.current:
                self.materials.append(self.current)
            self.current = {'name' : values[0]}
        # Extract the diffuse colour (base colour in Blender)
        if name == 'Kd':
            # RGB values are given as floating point values between 0 and 1, so convert them here
            # to byte values between 0 and 255
            self.current['diffuse'] = [int(255 if float(f) >= 1 else float(f) * 256) for f in values]

    def finish(self):
        self.materials.append(self.current)
        self.current = None