# -*- 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 os

import pycam.Plugins
from pycam.Exporters.GCodeExporter import PATH_MODES
from pycam.Geometry.PointUtils import *


FILTER_GCODE = (("GCode files", ("*.ngc", "*.nc", "*.gc", "*.gcode")),)


class ToolpathExport(pycam.Plugins.PluginBase):

    UI_FILE = "toolpath_export.ui"
    DEPENDS = ["Toolpaths", "FilenameDialog"]
    CATEGORIES = ["Toolpath", "Export"]

    def setup(self):
        self._postprocessors = {}
        self.core.set("register_postprocessor",
                self.register_postprocessor)
        self.core.set("unregister_postprocessor",
                self.unregister_postprocessor)
        self._last_toolpath_file = None
        if self.gui:
            self._frame = self.gui.get_object("ToolpathExportFrame")
            self._frame.unparent()
            self.core.register_ui("toolpath_handling", "Export",
                    self._frame, -100)
            self._postproc_model = self.gui.get_object("PostprocessorList")
            self._postproc_selector = self.gui.get_object(
                    "PostprocessorSelector")
            self._gtk_handlers = (
                    (self.gui.get_object("ExportGCodeAll"), "clicked",
                        self.export_all),
                    (self.gui.get_object("ExportGCodeSelected"), "clicked",
                        self.export_selected),
                    (self.gui.get_object("ExportGCodeVisible"), "clicked",
                        self.export_visible))
            self._event_handlers = (
                    ("postprocessors-list-changed", self._update_postprocessors),
                    ("toolpath-list-changed", self._update_widgets),
                    ("toolpath-selection-changed", self._update_widgets),
                    ("toolpath-changed", self._update_widgets))
            self.register_gtk_handlers(self._gtk_handlers)
            self.register_event_handlers(self._event_handlers)
            self._update_postprocessors()
            self._update_widgets()
        return True

    def teardown(self):
        if self.gui:
            self.core.unregister_ui("toolpath_handling", self._frame)
            self.unregister_gtk_handlers(self._gtk_handlers)
            self.unregister_event_handlers(self._event_handlers)

    def register_postprocessor(self, name, label, func):
        if name in self._postprocessors:
            self.log.debug("Registering postprocessor '%s' again" % name)
        processor = {"name": name,
                "label": label,
                "func": func,
        }
        self._postprocessors[name] = processor
        self.core.emit_event("postprocessors-list-changed")

    def unregister_postprocessor(self, name):
        if not name in self._postprocessors:
            self.log.debug("Tried to unregister an unknown postprocessor: " + \
                    name)
        else:
            del self._postprocessors[name]
            self.core.emit_event("postprocessors-list-changed")

    def get_selected(self):
        index = self._postproc_selector.get_active()
        if index < 0:
            return None
        else:
            return self._postproc_model[index][1]

    def select(self, name):
        for index, row in enumerate(self._postproc_model):
            if row[1] == name:
                self._postproc_selector.set_active(index)
                break
        else:
            self._postproc_selector.set_active(-1)

    def _update_postprocessors(self):
        selected = self.get_selected()
        model = self._postproc_model
        model.clear()
        processors = self._postprocessors.values()
        processors.sort(key=lambda item: item["label"])
        for proc in processors:
            model.append((proc["label"], proc["name"]))
        if selected:
            self.select(selected)
        elif len(model) > 0:
            self._postproc_selector.set_active(0)
        else:
            pass

    def _update_widgets(self):
        toolpaths = self.core.get("toolpaths")
        for name, filtered in (("ExportGCodeAll", toolpaths),
                ("ExportGCodeVisible", toolpaths.get_visible()),
                ("ExportGCodeSelected", toolpaths.get_selected())):
            self.gui.get_object(name).set_sensitive(bool(filtered))

    def export_all(self, widget=None):
        self._export_toolpaths(self.core.get("toolpaths"))

    def export_visible(self, widget=None):
        self._export_toolpaths(self.core.get("toolpaths").get_visble())

    def export_selected(self, widget=None):
        self._export_toolpaths(self.core.get("toolpaths").get_selected())

    def _export_toolpaths(self, toolpaths):
        proc_name = self.get_selected()
        processor = self._postprocessors[proc_name]
        if not processor:
            self.log.warn("Unknown postprocessor: %s" % str(name))
            return
        generator_func = processor["func"]
        # we open a dialog
        if self.core.get("gcode_filename_extension"):
            filename_extension = self.core.get("gcode_filename_extension")
        else:
            filename_extension = None
        # TODO: separate this away from Gui/Project.py
        # TODO: implement "last_model_filename" in core
        filename = self.core.get("get_filename_func")("Save toolpath to ...",
                mode_load=False, type_filter=FILTER_GCODE,
                filename_templates=(self._last_toolpath_file, self.core.get("last_model_filename")),
                filename_extension=filename_extension)
        if filename:
            self._last_toolpath_file = filename
        # no filename given -> exit
        if not filename:
            return
        try:
            destination = open(filename, "w")
            safety_height = self.core.get("gcode_safety_height")
            # TODO: implement "get_meta_data()"
            #meta_data = self.get_meta_data()
            meta_data = ""
            machine_time = 0
            # calculate the machine time and store it in the GCode header
            for toolpath in toolpaths:
                machine_time += toolpath.get_machine_time()
            all_info = meta_data + os.linesep \
                    + "Estimated machine time: %.0f minutes" % machine_time
            minimum_steps = [self.core.get("gcode_minimum_step_x"),  
                    self.core.get("gcode_minimum_step_y"),  
                    self.core.get("gcode_minimum_step_z")]
            if self.core.get("touch_off_position_type") == "absolute":
                pos_x = self.core.get("touch_off_position_x")
                pos_y = self.core.get("touch_off_position_y")
                pos_z = self.core.get("touch_off_position_z")
                touch_off_pos = (pos_x, pos_y, pos_z)
            else:
                touch_off_pos = None
            generator = generator_func(destination,
                    metric_units=(self.core.get("unit") == "mm"),
                    safety_height=safety_height,
                    toggle_spindle_status=self.core.get("gcode_start_stop_spindle"),
                    spindle_delay=self.core.get("gcode_spindle_delay"),
                    comment=all_info, minimum_steps=minimum_steps,
                    touch_off_on_startup=self.core.get("touch_off_on_startup"),
                    touch_off_on_tool_change=self.core.get("touch_off_on_tool_change"),
                    touch_off_position=touch_off_pos,
                    touch_off_rapid_move=self.core.get("touch_off_rapid_move"),
                    touch_off_slow_move=self.core.get("touch_off_slow_move"),
                    touch_off_slow_feedrate=self.core.get("touch_off_slow_feedrate"),
                    touch_off_height=self.core.get("touch_off_height"),
                    touch_off_pause_execution=self.core.get("touch_off_pause_execution"))
            path_mode = self.core.get("gcode_path_mode")
            if path_mode == 0:
                generator.set_path_mode(PATH_MODES["exact_path"])
            elif path_mode == 1:
                generator.set_path_mode(PATH_MODES["exact_stop"])
            elif path_mode == 2:
                generator.set_path_mode(PATH_MODES["continuous"])
            else:
                naive_tolerance = self.core.get("gcode_naive_tolerance")
                if naive_tolerance == 0:
                    naive_tolerance = None
                generator.set_path_mode(PATH_MODES["continuous"],
                        self.core.get("gcode_motion_tolerance"),
                        naive_tolerance)
            for toolpath in toolpaths:
                params = toolpath.get_params()
                tool_id = params.get("tool_id", 1)
                feedrate = params.get("tool_feedrate", 300)
                spindle_speed = params.get("spindle_speed", 1000)
                generator.set_speed(feedrate, spindle_speed)
                # TODO: implement toolpath.get_meta_data()
                generator.add_moves(toolpath.get_basic_moves(),
                        tool_id=tool_id, comment="")
            generator.finish()
            destination.close()
            self.log.info("GCode file successfully written: %s" % str(filename))
        except IOError, err_msg:
            self.log.error("Failed to save toolpath file: %s" % err_msg)
        else:
            self.core.emit_event("notify-file-saved", filename)

