# -*- coding: utf-8 -*-
"""
$Id$

Copyright 2011 Lars Kruse <devel@sumpfralle.de>

This file is part of PyCAM.

PyCAM 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.

PyCAM 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 PyCAM.  If not, see <http://www.gnu.org/licenses/>.
"""

import pycam.Plugins
import pycam.Geometry.Point


GTK_COLOR_MAX = 65535.0


class OpenGLViewModel(pycam.Plugins.PluginBase):

    DEPENDS = ["OpenGLWindow", "Models"]
    CATEGORIES = ["Model", "Visualization", "OpenGL"]

    def setup(self):
        import gtk
        import OpenGL.GL
        self._gtk = gtk
        self._GL = OpenGL.GL
        self._event_handlers = (("visualize-items", self.draw_model),
                ("model-changed","visual-item-updated"),
                ("model-list-changed","visual-item-updated"))
        self.core.get("register_display_item")("show_model", "Show Model", 10)
        self.core.get("register_color")("color_model", "Model", 10)
        self.core.register_chain("get_draw_dimension", self.get_draw_dimension)
        self.register_event_handlers(self._event_handlers)
        self.core.emit_event("visual-item-updated")
        self._cache = {}
        return True

    def teardown(self):
        self.unregister_event_handlers(self._event_handlers)
        self.core.unregister_chain("get_draw_dimension",
                self.get_draw_dimension)
        self.core.get("unregister_display_item")("show_model")
        self.core.get("unregister_color")("color_model")
        self.core.emit_event("visual-item-updated")

    def _get_cache_key(self, model, *args, **kwargs):
        if hasattr(model, "uuid"):
            return "%s - %s - %s" % (model.uuid, repr(args), repr(kwargs))
        else:
            return None

    def _is_visible(self):
        return self.core.get("show_model") \
                and not (self.core.get("show_simulation") \
                    and self.core.get("simulation_toolpath_moves"))

    def get_draw_dimension(self, low, high):
        if self._is_visible():
            mlow, mhigh = pycam.Geometry.Model.get_combined_bounds(
                    [m.model for m in self.core.get("models").get_visible()])
            if None in mlow or None in mhigh:
                return
            for index in range(3):
                if (low[index] is None) or (mlow[index] < low[index]):
                    low[index] = mlow[index]
                if (high[index] is None) or (mhigh[index] > high[index]):
                    high[index] = mhigh[index]

    def draw_model(self):
        GL = self._GL
        if self._is_visible():
            for model_dict in self.core.get("models").get_visible():
                model = model_dict.model
                col = model_dict["color"]
                color = (col["red"], col["green"], col["blue"], col["alpha"])
                GL.glColor4f(*color)
                # reset the material color
                GL.glMaterial(GL.GL_FRONT_AND_BACK,
                        GL.GL_AMBIENT_AND_DIFFUSE, color)
                # we need to wait until the color change is active
                GL.glFinish()
                if self.core.get("opengl_cache_enable"):
                    key = self._get_cache_key(model, color=color,
                            show_directions=self.core.get("show_directions"))
                    do_caching = not key is None
                else:
                    do_caching = False
                if do_caching and not key in self._cache:
                    # Rendering a display list takes less than 5% of the time
                    # for a complete rebuild.
                    list_index = GL.glGenLists(1)
                    if list_index > 0:
                        # Somehow "GL_COMPILE_AND_EXECUTE" fails - we render
                        # it later.
                        GL.glNewList(list_index, GL.GL_COMPILE)
                    else:
                        do_caching = False
                    # next: compile an OpenGL display list
                if not do_caching or (not key in self._cache):
                    self.core.call_chain("draw_models", [model])
                if do_caching:
                    if not key in self._cache:
                        GL.glEndList()
                        GL.glCallList(list_index)
                        self._cache[key] = list_index
                    else:
                        # render a previously compiled display list
                        GL.glCallList(self._cache[key])


class OpenGLViewModelTriangle(pycam.Plugins.PluginBase):

    DEPENDS = ["OpenGLViewModel"]
    CATEGORIES = ["Model", "Visualization", "OpenGL"]

    def setup(self):
        import OpenGL.GL
        self._GL = OpenGL.GL
        self.core.register_chain("draw_models", self.draw_triangle_model, 10)
        return True

    def teardown(self):
        self.core.unregister_chain("draw_models", self.draw_triangle_model)

    def draw_triangle_model(self, models):
        if not models:
            return
        GL = self._GL
        removal_list = []
        for index in range(len(models)):
            model = models[index]
            if not hasattr(model, "triangles"):
                continue
            get_coords = lambda p: (p.x, p.y, p.z)
            def calc_normal(main, normals):
                suitable = pycam.Geometry.Point.Vector(0, 0, 0)
                for normal, weight in normals:
                    dot = main.dot(normal)
                    if dot > 0:
                        suitable = suitable.add(normal.mul(weight * dot))
                return suitable.normalized()
            vertices = {}
            for t in model.triangles():
                for p in (t.p1, t.p2, t.p3):
                    coords = get_coords(p)
                    if not coords in vertices:
                        vertices[coords] = []
                    vertices[coords].append((t.normal.normalized(), t.get_area()))
            GL.glBegin(GL.GL_TRIANGLES)
            for t in model.triangles():
                # The triangle's points are in clockwise order, but GL expects
                # counter-clockwise sorting.
                for p in (t.p1, t.p3, t.p2):
                    coords = get_coords(p)
                    normal = calc_normal(t.normal.normalized(), vertices[coords])
                    GL.glNormal3f(normal.x, normal.y, normal.z)
                    GL.glVertex3f(p.x, p.y, p.z)
            GL.glEnd()
            removal_list.append(index)
        # remove all models that we processed
        removal_list.reverse()
        for index in removal_list:
            models.pop(index)


class OpenGLViewModelGeneric(pycam.Plugins.PluginBase):

    DEPENDS = ["OpenGLViewModel"]
    CATEGORIES = ["Model", "Visualization", "OpenGL"]

    def setup(self):
        self.core.register_chain("draw_models", self.draw_generic_model, 100)
        return True

    def teardown(self):
        self.core.unregister_chain("draw_models", self.draw_generic_model)

    def draw_generic_model(self, models):
        removal_list = []
        for index in range(len(models)):
            model = models[index]
            for item in model.next():
                # ignore invisble things like the normal of a ContourModel
                if hasattr(item, "to_OpenGL"):
                    item.to_OpenGL(show_directions=self.core.get("show_directions"))
            removal_list.append(index)
        removal_list.reverse()
        for index in removal_list:
            removal_list.pop(index)

