__version__ = "0.0806"

import sys
from BBLuxMat import MatConverter


class Mesh(object):
    def __init__(self, sets):
        self.sets         = sets
        self.triangles    = []
        self.quadrangles  = []
        self.index_map    = {}
        self.used_indices = []
        self.opposites    = None

    def add_polygon(self, start, nv):
        imap = self.index_map
        used = self.used_indices
        verts = []
        for i in self.sets[start : start + nv]:
            if not imap.has_key(i):
                imap[i] = len(used)
                used.append(i)
            verts.append(imap[i])

        if nv == 3:
            self.triangles.append(verts)
        elif nv == 4:
            self.quadrangles.append(verts)
        else:
            for v in xrange(1, nv - 1):
                self.triangles.append([verts(0), verts(v), verts(v + 1)])

    def match_edges(self):
        vertex_pair_to_edge = {}
        opposites = {}

        for plist, nv in ((self.triangles, 3), (self.quadrangles, 4)):
            index_pairs = zip(xrange(0,nv-1), xrange(1,nv)) + [(nv-1, 0)]
            for n, poly in zip(xrange(len(plist)), plist):
                for i, j in index_pairs:
                    edge = (nv, n, i)
                    matching = vertex_pair_to_edge.get((poly[j], poly[i]))
                    if matching:
                        opposites[edge] = matching
                        opposites[matching] = edge
                    elif vertex_pair_to_edge.get((poly[i], poly[j])):
                        raise "Polygons don't match up properly!"

                    vertex_pair_to_edge[(poly[i], poly[j])] = edge

        self.opposites = opposites


class Subgeometry(object):
    def __init__(self, geometry, name):
        self.geometry = geometry
        self.name     = name
        self.mesh     = Mesh(geometry.Sets())
        self.tmesh    = Mesh(geometry.TexSets())
        self.empty    = True

    def add_polygon(self, poly, tpoly):
        self.empty = False
        self.mesh.add_polygon(poly.Start(), poly.NumVertices())
        self.tmesh.add_polygon(tpoly.Start(), tpoly.NumTexVertices())

    def unwrap_at_texture_seams(self):
        # >>> This does not work yet. <<<
        
        self.mesh.match_edges()
        self.tmesh.match_edges()

        count = 0
        for ((nv1, n1, i1), (nv2, n2, i2)) in self.mesh.opposites.items():
            if (nv1, n1, i1) < (nv2, n2, i2):
                count += 1

    def write(self, file):
        #self.unwrap_at_texture_seams()
        
        print >>file, 'Shape "mesh"'
        if self.mesh.triangles:
            file.write(' "integer triindices" [\n')
            for tri in self.mesh.triangles:
                print >>file, tri[0], tri[1], tri[2]
            file.write("]\n")
        if self.mesh.quadrangles:
            file.write(' "integer quadindices" [\n')
            for quad in self.mesh.quadrangles:
                print >>file, quad[0], quad[1], quad[2], quad[3]
            file.write("]\n")

        verts = self.geometry.WorldVertices()
        if verts and self.mesh.used_indices:
            print >>file, ' "point P" [\n'
            for i in self.mesh.used_indices:
                vert = verts[i]
                print >>file, vert.X(), vert.Y(), vert.Z()
            print >>file, ']\n'

        normals = self.geometry.WorldNormals()
        if normals and self.mesh.used_indices:
            print >>file, ' "normal N" [\n'
            for i in self.mesh.used_indices:
                norm = normals[i]
                print >>file, norm.X(), norm.Y(), norm.Z()
            print >>file, ']\n'


class LuxportActor(object):
    def __init__(self, actor):
        self.actor = actor

    def write(self, file):
        actor = self.actor

        geom = actor.Geometry()
        if geom is None: return

        figure = self.actor.ItsFigure()
        if figure:
            matKey = figure.Name()
        else:
            matKey = actor.Name()

        subgeometries = []
        for mat in geom.Materials():
            subgeometries.append(Subgeometry(geom, mat.Name()))

        for poly, tpoly in zip(geom.Polygons(), geom.TexPolygons()):
            subgeometries[poly.MaterialIndex()].add_polygon(poly, tpoly)

        for subgeom in subgeometries:
            if not subgeom.empty:
                mat = actor.Material(subgeom.name)
                mc = MatConverter(mat, matKey)
                print >>file, 'AttributeBegin'
                print >>file, mc.eval()
                subgeom.write(file)
                print >>file, 'AttributeEnd\n'