#    This file is part of Korman.
#
#    Korman is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    Korman is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with Korman.  If not, see <http://www.gnu.org/licenses/>.

import bpy
from PyHSPlasma import *
import weakref

from . import explosions
from . import material
from . import utils

_MAX_VERTS_PER_SPAN = 0xFFFF
_WARN_VERTS_PER_SPAN = 0x8000

class _RenderLevel:
    MAJOR_OPAQUE = 0
    MAJOR_FRAMEBUF = 1
    MAJOR_DEFAULT = 2
    MAJOR_BLEND = 4
    MAJOR_LATE = 8

    _MAJOR_SHIFT = 28
    _MINOR_MASK = ((1 << _MAJOR_SHIFT) - 1)

    def __init__(self, hsgmat, pass_index):
        # TODO: Use hsGMaterial to determine major and minor
        self.level = 0

        # We use the blender material's pass index (which we stashed in the hsGMaterial) to increment
        # the render pass, just like it says...
        self.level += pass_index

    def __eq__(self, other):
        return self.level == other.level

    def __hash__(self):
        return hash(self.level)

    def _get_major(self):
        return self.level >> _MAJOR_SHIFT
    def _set_major(self, value):
        self.level = ((value << _MAJOR_SHIFT) & 0xFFFFFFFF) | self.minor
    major = property(_get_major, _set_major)

    def _get_minor(self):
        return self.level & _MINOR_MASK
    def _set_minor(self, value):
        self.level = ((self.major << _MAJOR_SHIFT) & 0xFFFFFFFF) | value
    minor = property(_get_minor, _set_minor)


class _DrawableCriteria:
    def __init__(self, hsgmat, pass_index):
        _layer = hsgmat.layers[0].object # better doggone well have a layer...
        self.blend_span = bool(_layer.state.blendFlags & hsGMatState.kBlendMask)
        self.criteria = 0 # TODO
        self.render_level = _RenderLevel(hsgmat, pass_index)

    def __eq__(self, other):
        if not isinstance(other, _DrawableCriteria):
            return False
        for i in ("blend_span", "render_level", "criteria"):
            if getattr(self, i) != getattr(other, i):
                return False
        return True

    def __hash__(self):
        return hash(self.render_level) ^ hash(self.blend_span) ^ hash(self.criteria)

    @property
    def span_type(self):
        if self.blend_span:
            return "BlendSpans"
        else:
            return "Spans"


class MeshConverter:
    def __init__(self, exporter):
        self._exporter = weakref.ref(exporter)
        self.material = material.MaterialConverter(exporter)

        self._dspans = {}
        self._mesh_geospans = {}

    def _create_geospan(self, bo, mesh, bm, hsgmat):
        """Initializes a plGeometrySpan from a Blender Object and an hsGMaterial"""
        geospan = plGeometrySpan()
        geospan.material = hsgmat

        # GeometrySpan format
        # For now, we really only care about the number of UVW Channels
        numUVWchans = len(mesh.tessface_uv_textures)
        if numUVWchans > plGeometrySpan.kUVCountMask:
            raise explosions.TooManyUVChannelsError(bo, bm)
        geospan.format = numUVWchans

        # TODO: Props
        # TODO: RunTime lights (requires libHSPlasma feature)

        # If this object has a CI, we don't need xforms here...
        if self._mgr.find_key(bo, plCoordinateInterface) is not None:
            geospan.localToWorld = hsMatrix44()
            geospan.worldToLocal = hsMatrix44()
        else:
            geospan.worldToLocal = utils.matrix44(bo.matrix_basis)
            geospan.localToWorld = geospan.worldToLocal.inverse()
        return geospan

    def finalize(self):
        """Prepares all baked Plasma geometry to be flushed to the disk"""
        print("\nFinalizing Geometry...")

        for loc in self._dspans.values():
            for dspan in loc.values():
                print("    ... {} ...".format(dspan.key.name))
    
                # This mega-function does a lot:
                # 1. Converts SourceSpans (geospans) to Icicles and bakes geometry into plGBuffers
                # 2. Calculates the Icicle bounds
                # 3. Builds the plSpaceTree
                # 4. Clears the SourceSpans
                dspan.composeGeometry(True, True)

    def _export_geometry(self, mesh, geospans):
        _geodatacls = type("_GeoData",
                       (object,),
                       {
                           "blender2gs": [{} for i in mesh.vertices],
                           "triangles": [],
                           "vertices": []
                       })
        geodata = [_geodatacls() for i in mesh.materials]

        # Convert Blender faces into things we can stuff into libHSPlasma
        for i, tessface in enumerate(mesh.tessfaces):
            data = geodata[tessface.material_index]
            face_verts = []

            # Convert to per-material indices
            for j in tessface.vertices:
                # Unpack the UV coordinates from each UV Texture layer
                # NOTE: Blender has no third (W) coordinate
                uvws = [(uvtex.data[j].uv.x, uvtex.data[j].uv.y) for uvtex in mesh.uv_layers]

                # Grab VCols (TODO--defaulting to white for now)
                # This will be finalized once the vertex color light code baking is in
                color = (255, 255, 255, 255)

                # Now, we'll index into the vertex dict using the per-face elements :(
                # We're using tuples because lists are not hashable. The many mathutils and PyHSPlasma
                # types are not either, and it's entirely too much work to fool with all that.
                coluv = (color, tuple(uvws))
                if coluv not in data.blender2gs[j]:
                    source = mesh.vertices[j]
                    vertex = plGeometrySpan.TempVertex()
                    vertex.position = utils.vector3(source.co)
                    vertex.normal = utils.vector3(source.normal)
                    vertex.color = hsColor32(*color)
                    vertex.uvs = [hsVector3(uv[0], 1.0-uv[1], 0.0) for uv in uvws]
                    data.blender2gs[j][coluv] = len(data.vertices)
                    data.vertices.append(vertex)
                face_verts.append(data.blender2gs[j][coluv])

            # Convert to triangles, if need be...
            if len(face_verts) == 3:
                data.triangles += face_verts
            elif len(face_verts) == 4:
                data.triangles += (face_verts[0], face_verts[1], face_verts[2])
                data.triangles += (face_verts[0], face_verts[2], face_verts[3])

        # Time to finish it up...
        for i, data in enumerate(geodata):
            geospan = geospans[i][0]
            numVerts = len(data.vertices)

            # Soft vertex limit at 0x8000 for PotS and below. Works fine as long as it's a uint16
            # MOUL only allows signed int16s, however :/
            if numVerts > _MAX_VERTS_PER_SPAN or (numVerts > _WARN_VERTS_PER_SPAN and self._mgr.getVer() >= pvMoul):
                raise explosions.TooManyVerticesError(mesh.name, geospan.material.name, numVerts)
            elif numVerts > _WARN_VERTS_PER_SPAN:
                pass # FIXME

            # If we're still here, let's add our data to the GeometrySpan
            geospan.indices = data.triangles
            geospan.vertices = data.vertices

    def export_object(self, bo):
        # Have we already exported this mesh?
        try:
            drawables = self._mesh_geospans[bo.data]
        except LookupError:
            drawables = self._export_mesh(bo)

        # Create the DrawInterface
        diface = self._mgr.add_object(pl=plDrawInterface, bl=bo)
        for dspan_key, idx in drawables:
            diface.addDrawable(dspan_key, idx)
        return diface.key

    def _export_mesh(self, bo):
        # First, we need to grab the object's mesh...
        mesh = bo.data
        mesh.update(calc_tessface=True)

        # Step 1: Export all of the doggone materials.
        geospans = self._export_material_spans(bo, mesh)

        # Step 2: Export Blender mesh data to Plasma GeometrySpans
        self._export_geometry(mesh, geospans)

        # Step 3: Add plGeometrySpans to the appropriate DSpan and create indices
        _diindices = {}
        for geospan, pass_index in geospans:
            dspan = self._find_create_dspan(bo, geospan.material.object, pass_index)
            print("    Exported hsGMaterial '{}' geometry into '{}'".format(geospan.material.name, dspan.key.name))
            idx = dspan.addSourceSpan(geospan)
            if dspan not in _diindices:
                _diindices[dspan] = [idx,]
            else:
                _diindices[dspan].append(idx)

        # Step 3.1: Harvest Span indices and create the DIIndices
        drawables = []
        for dspan, indices in _diindices.items():
            dii = plDISpanIndex()
            dii.indices = indices
            idx = dspan.addDIIndex(dii)
            drawables.append((dspan.key, idx))
        return drawables

    def _export_material_spans(self, bo, mesh):
        """Exports all Materials and creates plGeometrySpans"""
        geospans = [None] * len(mesh.materials)
        for i, blmat in enumerate(mesh.materials):
            hsgmat = self.material.export_material(bo, blmat)
            geospans[i] = (self._create_geospan(bo, mesh, blmat, hsgmat), blmat.pass_index)
        return geospans

    def _find_create_dspan(self, bo, hsgmat, pass_index):
        location = self._mgr.get_location(bo)
        if location not in self._dspans:
            self._dspans[location] = {}

        # This is where we figure out which DSpan this goes into. To vaguely summarize the rules...
        # BlendSpans: anything with an alpha blended layer
        # [... document me ...]
        # We're using pass index to do just what it was designed for. Cyan has a nicer "depends on"
        # draw component, but pass index is the Blender way, so that's what we're doing.
        crit = _DrawableCriteria(hsgmat, pass_index)

        if crit not in self._dspans[location]:
            # AgeName_[District_]_Page_RenderLevel_Crit[Blend]Spans
            # Just because it's nice to be consistent
            node = self._mgr.get_scene_node(location)
            name = "{}_{:08X}_{:X}{}".format(node.name, crit.render_level.level, crit.criteria, crit.span_type)
            dspan = self._mgr.add_object(pl=plDrawableSpans, name=name, loc=location)

            dspan.criteria = crit.criteria
            # TODO: props
            dspan.renderLevel = crit.render_level.level
            dspan.sceneNode = node # AddViaNotify

            self._dspans[location][crit] = dspan
            return dspan
        else:
            return self._dspans[location][crit]

    @property
    def _mgr(self):
        return self._exporter().mgr