# Copyright (C) 2006-2011, University of Maryland
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/ or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# Author: James Krycka, Nikunj Patel

"""
This module implements the AppPanel class which creates the main panel on top
of the frame of the GUI for the Bumps application.
"""

# ==============================================================================

import os
import threading
from copy import deepcopy

import wx
import wx.aui

from .. import plugin
from ..cli import load_best, load_model
from ..dream import stats as dream_stats
from ..util import redirect_console
from . import signal
from .convergence_view import ConvergenceView
from .fit_dialog import show_fit_config
from .fit_thread import EVT_FIT_COMPLETE, EVT_FIT_PROGRESS, FitThread
from .log_view import LogView
from .parameter_view import ParameterView
from .plot_view import PlotView
from .summary_view import SummaryView
from .uncertainty_view import CorrelationView, ModelErrorView, TraceView, UncertaintyView
from .util import nice
from .utilities import get_bitmap, phoenix

# File selection strings.
MODEL_EXT = ".pickle"
MODEL_FILES = "Model files (*%s)|*%s" % (MODEL_EXT, MODEL_EXT)
PYTHON_FILES = "Script files (*.py)|*.py"
DATA_FILES = "Data files (*.dat)|*.dat"
TEXT_FILES = "Text files (*.txt)|*.txt"
ALL_FILES = "All files (*.*)|*"
PARS_FILES = "Parameter files (*.par)|*.par"

# Custom colors.
WINDOW_BKGD_COLOUR = "#ECE9D8"

# ==============================================================================


class AppPanel(wx.Panel):
    """
    This class builds the GUI for the application on a panel and attaches it
    to the frame.
    """

    def __init__(self, *args, **kw):
        # Create a panel on the frame.  This will be the only child panel of
        # the frame and it inherits its size from the frame which is useful
        # during resize operations (as it provides a minimal size to sizers).

        wx.Panel.__init__(self, *args, **kw)

        self.SetBackgroundColour("WHITE")

        # Modify the tool bar.
        frame = self.GetTopLevelParent()
        self.init_toolbar(frame)
        self.init_menubar(frame)

        # Reconfigure the status bar.
        self.init_statusbar(frame, [-34, -50, -16, -16])

        # Create the model views
        self.init_views()

        # Add data menu
        mb = frame.GetMenuBar()
        data_view = self.view["data"]
        if hasattr(data_view, "menu"):
            mb.Append(data_view.menu(), data_view.title)

        # Create a PubSub receiver.
        signal.connect(self.OnLogMessage, "log")
        signal.connect(self.OnModelNew, "model.new")
        signal.connect(self.OnModelChange, "model.update_structure")
        signal.connect(self.OnModelSetpar, "model.update_parameters")

        EVT_FIT_PROGRESS.Bind(self, wx.ID_ANY, wx.ID_ANY, self.OnFitProgress)
        EVT_FIT_COMPLETE.Bind(self, wx.ID_ANY, wx.ID_ANY, self.OnFitComplete)

        # _fit_abort and maybe _uncertainty_state are managed by fit_lock
        self.fit_lock = threading.Lock()
        self._fit_abort = False
        # self._uncertainty_state = None
        self.fit_thread = None
        self.fit_config = None

    def init_menubar(self, frame):
        """
        Adds items to the menu bar, menus, and menu options.
        The menu bar should already have a simple File menu and a Help menu.
        """
        mb = frame.GetMenuBar()

        file_menu_id = mb.FindMenu("File")
        file_menu = mb.GetMenu(file_menu_id)
        # help_menu = mb.GetMenu(mb.FindMenu("Help"))

        # Add items to the "File" menu (prepending them in reverse order).
        # Grey out items that are not currently implemented.
        file_menu.PrependSeparator()

        _item = file_menu.Prepend(wx.ID_ANY, "E&xport Results ...", "Save theory, data and parameters")
        frame.Bind(wx.EVT_MENU, self.OnFileExportResults, _item)

        _item = file_menu.Prepend(wx.ID_ANY, "&Reload", "Reload the existing model")
        frame.Bind(wx.EVT_MENU, self.OnFileReload, _item)

        _item = file_menu.Prepend(wx.ID_SAVEAS, "Save &As", "Save model as another name")
        frame.Bind(wx.EVT_MENU, self.OnFileSaveAs, _item)
        # file_menu.Enable(id=wx.ID_SAVEAS, enable=False)
        _item = file_menu.Prepend(wx.ID_SAVE, "&Save", "Save model")
        frame.Bind(wx.EVT_MENU, self.OnFileSave, _item)
        # file_menu.Enable(id=wx.ID_SAVE, enable=False)
        _item = file_menu.Prepend(wx.ID_OPEN, "&Open", "Open existing model")
        frame.Bind(wx.EVT_MENU, self.OnFileOpen, _item)
        # file_menu.Enable(id=wx.ID_OPEN, enable=False)
        _item = file_menu.Prepend(wx.ID_ANY, "Apply &Pararameters", "Apply parameters from .par file to loaded model")
        frame.Bind(wx.EVT_MENU, self.OnParsFileOpen, _item)
        _item = file_menu.Prepend(wx.ID_NEW, "&New", "Create new model")
        frame.Bind(wx.EVT_MENU, self.OnFileNew, _item)
        # file_menu.Enable(id=wx.ID_NEW, enable=False)

        # Add 'Fitting' menu to the menu bar and define its options.
        # Items are initially greyed out, but will be enabled after a script
        # is loaded.
        fit_menu = self.fit_menu = wx.Menu()

        _item = fit_menu.Append(wx.ID_ANY, "Start", "Start fitting operation")
        frame.Bind(wx.EVT_MENU, self.OnFitStart, _item)
        fit_menu.Enable(id=_item.GetId(), enable=False)
        self.fit_menu_start = _item

        _item = fit_menu.Append(wx.ID_ANY, "Stop", "Stop fitting operation")
        frame.Bind(wx.EVT_MENU, self.OnFitStop, _item)
        fit_menu.Enable(id=_item.GetId(), enable=False)
        self.fit_menu_stop = _item

        _item = fit_menu.Append(wx.ID_ANY, "&Options ...", "Edit fitting options")
        frame.Bind(wx.EVT_MENU, self.OnFitOptions, _item)
        self.fit_menu_options = _item

        # _item = fit_menu.Append(wx.ID_ANY,
        #                        "&Save ...",
        #                        "Save fit results")
        # frame.Bind(wx.EVT_MENU, self.OnFitSave, _item)
        # fit_menu.Enable(id=_item.GetId(), enable=False)
        self.fit_menu_options = _item

        mb.Append(fit_menu, "&Fitting")

    def init_toolbar(self, frame):
        """Populates the tool bar."""
        self.tb = frame.GetToolBar()

        script_bmp = get_bitmap("import_script.png", wx.BITMAP_TYPE_PNG)
        reload_bmp = get_bitmap("reload.png", wx.BITMAP_TYPE_PNG)
        start_bmp = get_bitmap("start_fit.png", wx.BITMAP_TYPE_PNG)
        stop_bmp = get_bitmap("stop_fit.png", wx.BITMAP_TYPE_PNG)

        _tool = self._add_tool(script_bmp, "Open model", "Load model from script")
        frame.Bind(wx.EVT_TOOL, self.OnFileOpen, _tool)
        _tool = self._add_tool(reload_bmp, "Reload model", "Reload model from script")
        frame.Bind(wx.EVT_TOOL, self.OnFileReload, _tool)
        # TODO: add reload

        self.tb.AddSeparator()

        _tool = self._add_tool(start_bmp, "Start Fit", "Start fitting operation")
        frame.Bind(wx.EVT_TOOL, self.OnFitStart, _tool)
        self.tb.EnableTool(_tool.GetId(), False)
        self.tb_start = _tool

        _tool = self._add_tool(stop_bmp, "Stop Fit", "Stop fitting operation")
        frame.Bind(wx.EVT_TOOL, self.OnFitStop, _tool)
        self.tb.EnableTool(_tool.GetId(), False)
        self.tb_stop = _tool

        self.tb.Realize()
        frame.SetToolBar(self.tb)

    def _add_tool(self, bitmap, label, help):
        if phoenix:
            return self.tb.AddTool(wx.ID_ANY, label, bitmap, shortHelp=help)
        else:
            return self.tb.AddSimpleTool(wx.ID_ANY, bitmap, label, help)

    def init_statusbar(self, frame, subbars):
        """Divides the status bar into multiple segments."""

        self.sb = frame.GetStatusBar()
        self.sb.SetFieldsCount(len(subbars))
        self.sb.SetStatusWidths(subbars)

    def init_views(self):
        # initial view
        self.aui = wx.aui.AuiNotebook(self)
        self.aui.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE, self.OnViewTabClose)
        self.view_constructor = {
            "data": plugin.data_view(),
            "model": plugin.model_view(),
            "parameter": ParameterView,
            "summary": SummaryView,
            "log": LogView,
            "convergence": ConvergenceView,
            "uncertainty": UncertaintyView,
            "correlation": CorrelationView,
            "trace": TraceView,
            "error": ModelErrorView,
        }
        self.view_list = [
            "data",
            "model",
            "parameter",
            "summary",
            "log",
            "convergence",
            "uncertainty",
            "correlation",
            "trace",
            "error",
        ]
        self.view = {}
        for v in self.view_list:
            if self.view_constructor[v]:
                self.view[v] = self.view_constructor[v](self.aui, size=(600, 600))
                self.aui.AddPage(self.view[v], self.view_constructor[v].title)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.aui, 1, wx.EXPAND)
        self.SetSizer(sizer)

    def show_view(self, tag):
        if self.view[tag].Parent == self.aui:
            self.aui.SetSelection(self.aui.GetPageIndex(self.view[tag]))
        else:
            self.view[tag].Raise()
            self.view[tag].SetFocus()

    def OnViewTabClose(self, evt):
        win = self.aui.GetPage(evt.GetSelection())
        # print "Closing tab",win.GetId()
        for k, w in self.view.items():
            if w == win:
                tag = k
                break
        else:
            raise RuntimeError("Lost track of view")
        # print "creating external frame"
        state = self.view[tag].get_state()
        constructor = self.view_constructor[tag]
        frame = wx.Frame(self, title=constructor.title, size=constructor.default_size)
        panel = constructor(frame)
        self.view[tag] = panel
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(panel, 1, wx.EXPAND)
        frame.SetSizer(sizer)
        frame.Bind(wx.EVT_CLOSE, self.OnViewFrameClose)
        frame.Show()
        panel.set_state(state)
        evt.Skip()

    def OnViewFrameClose(self, evt):
        win = evt.GetEventObject()
        # print "Closing frame",win.GetId()
        for k, w in self.view.items():
            if w.GetParent() == win:
                tag = k
                break
        else:
            raise RuntimeError("Lost track of view!")
        state = self.view[tag].get_state()
        constructor = self.view_constructor[tag]
        panel = constructor(self.aui)
        self.view[tag] = panel
        self.aui.AddPage(panel, constructor.title)
        panel.set_state(state)
        evt.Skip()

    # model viewer interface
    def OnLogMessage(self, message):
        for v in self.view.values():
            if hasattr(v, "log_message"):
                v.log_message(message)

    def OnModelNew(self, model):
        self.set_model(model)

    def OnModelChange(self, model):
        for v in self.view.values():
            if hasattr(v, "update_model"):
                v.update_model(model)

    def OnModelSetpar(self, model):
        for v in self.view.values():
            if hasattr(v, "update_parameters"):
                v.update_parameters(model)

    def OnFileNew(self, event):
        self.new_model()

    def OnFileOpen(self, event):
        # Load the script which will contain model definition and data.
        dlg = wx.FileDialog(
            self,
            message="Select File",
            # defaultDir=os.getcwd(),
            # defaultFile="",
            wildcard=(ALL_FILES),
            style=wx.FD_OPEN | wx.FD_CHANGE_DIR,
        )

        # Wait for user to close the dialog.
        status = dlg.ShowModal()
        path = dlg.GetPath()
        dlg.Destroy()

        # Process file if user clicked okay.
        if status == wx.ID_OK:
            self.load_model(path)

    def OnParsFileOpen(self, event):
        # Load a parameters (.pars) file to apply to current problem.
        dlg = wx.FileDialog(
            self,
            message="Select Parameters File",
            # defaultDir=os.getcwd(),
            # defaultFile="",
            wildcard=PARS_FILES,
            style=wx.FD_OPEN,
        )

        # Wait for user to close the dialog.
        status = dlg.ShowModal()
        path = dlg.GetPath()
        dlg.Destroy()

        # Process file if user clicked okay.
        if status == wx.ID_OK:
            self.apply_parameters(path)

    def OnFileReload(self, event):
        path = getattr(self, "_reload_path", self.model.path)
        self.load_model(path)

    def OnFileSave(self, event):
        if self.model is not None:
            # Force file extension to be MODEL_EXT
            self.model.path = os.path.splitext(self.model.path)[0] + MODEL_EXT
            self.save_model(self.model.path)
        else:
            self.OnFileSaveAs(event)

    def OnFileSaveAs(self, event):
        dlg = wx.FileDialog(
            self,
            message="Select File",
            defaultDir=os.getcwd(),
            defaultFile="",
            wildcard=(MODEL_FILES + "|" + ALL_FILES),
            style=wx.FD_SAVE | wx.FD_CHANGE_DIR | wx.FD_OVERWRITE_PROMPT,
        )
        # Wait for user to close the dialog.
        status = dlg.ShowModal()
        path = dlg.GetPath()
        dlg.Destroy()

        # Process file if user clicked okay.
        if status == wx.ID_OK:
            self.model.path = os.path.splitext(path)[0] + MODEL_EXT
            self.save_model(self.model.path)

    def OnFileExportResults(self, event):
        dlg = wx.DirDialog(self, message="Export results", defaultPath=os.getcwd(), style=wx.DD_DEFAULT_STYLE)
        # Wait for user to close the dialog.
        status = dlg.ShowModal()
        path = dlg.GetPath()
        dlg.Destroy()

        # Process file if user clicked okay.
        if status == wx.ID_OK:
            self.save_results(path)

    def set_fit_config(self, fit_config):
        self.fit_config = fit_config

    def OnFitOptions(self, event):
        # TODO: send fit_config to dialog rather than using options.FIT_CONFIG.
        # Wait until sasview wx is abandoned before making this change.
        show_fit_config(self)

    def OnFitStart(self, event):
        if self.fit_thread:
            self.sb.SetStatusText("Error: Fit already running")
            return
        # TODO: better access to model parameters
        if len(self.model.getp()) == 0:
            raise ValueError("Problem has no fittable parameters")

        # Start a new thread worker and give fit problem to the worker.
        fitclass = self.fit_config.selected_fitter
        options = self.fit_config.selected_values

        # Clear abort and uncertainty state
        self.abort = False
        self.uncertainty_state = None
        self.fit_thread = FitThread(
            win=self,
            abort_test=self._is_abort,
            problem=self.model,
            fitclass=fitclass,
            options=options,
            # Number of seconds between updates to the GUI, or 0 for no updates
            convergence_update=5,
            uncertainty_update=3600,
        )
        self.fit_thread.start()
        self.sb.SetStatusText("Fit status: Running", 3)

    def _is_abort(self):
        return self.abort

    @property
    def abort(self):
        with self.fit_lock:
            return self._fit_abort

    @abort.setter
    def abort(self, state):
        with self.fit_lock:
            self._fit_abort = state

    @property
    def uncertainty_state(self):
        """
        MCMC chain created by the DREAM optimizer.

        This is a thread-locked attribute maintained by the fitting thread.
        A deep copy of the attribute is made before setting so that state
        can continue to update within the fit thread while the user interface
        accesses the last state that was set.
        """
        with self.fit_lock:
            return self._uncertainty_state

    @uncertainty_state.setter
    def uncertainty_state(self, state):
        state_copy = deepcopy(state)
        with self.fit_lock:
            self._uncertainty_state = state_copy

    def OnFitStop(self, event):
        self.abort = True

    def OnFitComplete(self, event):
        if self.fit_thread is not None:
            self.fit_thread.join(1)  # 1 second timeout on join
            if self.fit_thread.is_alive():
                signal.log_message(message="fit thread failed to complete")
        self.fit_thread = None
        chisq = nice(2 * event.value / event.problem.dof)
        event.problem.setp(event.point)
        signal.update_parameters(model=event.problem)
        signal.log_message(message="done with chisq %g" % chisq)
        signal.log_message(message=event.info)
        self.sb.SetStatusText("Fit status: Complete", 3)
        beep()

    def OnFitSave(self, event):
        raise NotImplementedError()
        dlg = wx.FileDialog(
            self,
            message="Fit results",
            defaultDir=os.getcwd(),
            defaultFile="",
            wildcard=(MODEL_FILES + "|" + ALL_FILES),
            style=wx.FD_SAVE | wx.FD_CHANGE_DIR | wx.FD_OVERWRITE_PROMPT,
        )
        # Wait for user to close the dialog.
        status = dlg.ShowModal()
        path = dlg.GetPath()
        dlg.Destroy()

        # Process file if user clicked okay.
        if status == wx.ID_OK:
            self.save_fit(path)

    def OnFitProgress(self, event):
        self._fit_progress(event)
        return

        # Note: The following code was used to debugging plotting memory
        # and speed issues. It is here in case it might be useful again.
        if event.message == "uncertainty_final":
            event.message = "uncertainty_update"  # don't do model uncertainty
            n = 0
            import gc
            import time

            import psutil

            pid = os.getpid()
            proc = psutil.Process()
            t0 = time.perf_counter()
            signal.log_message("****** entering cycle ******")
            while True:
                self._fit_progress(event)
                t1 = time.perf_counter()
                msg = "========== cycle %d pid %d time %.3f s ===========" % (n, pid, t1 - t0)
                t0 = t1
                # signal.log_message(msg)
                # signal.log_message(f"memory {proc.memory_full_info()}")
                gc.collect()
                print(msg)
                print("memory", proc.memory_full_info())
                n += 1
                wx.Yield()
                # if n > 100: break

    def _fit_progress(self, event):
        if event.message == "progress":
            chisq = nice(2 * event.value / event.problem.dof)
            message = "step %5d chisq %g" % (event.step, chisq)
            signal.log_message(message=message)
        elif event.message == "improvement":
            event.problem.setp(event.point)
            event.problem.model_update()
            signal.update_parameters(model=event.problem)
        elif event.message == "convergence_update":
            self.view["convergence"].OnFitProgress(event)
        elif event.message in ("uncertainty_update", "uncertainty_final"):
            # TODO: revert to event.uncertainty_state if memory leak isn't fixed
            # Note: uncertainty_state is updated directly by the fit thread.
            # It's a copy protected by fit_lock so it should be self-consistent.
            state = self.uncertainty_state
            stats = dream_stats.var_stats(state.draw())
            self.console["state"] = self.uncertainty_state
            self.view["uncertainty"].fit_progress(event.problem, state, stats)
            self.view["correlation"].fit_progress(event.problem, state)
            self.view["trace"].fit_progress(event.problem, state)
            # TODO: send parameter stats to a view
            # It would be nice to have a "log scale" log of parameter history,
            # where the density of entries decreases exponentially over time.
            # So for example, the last 5, then 10 20 30 40 50, then 100, 200,
            # 300, 400, 500, ... Maybe have a slider so that you can drag it
            # forward and backward and see changes over time. Use box plots
            # to represent mode, median, mean, 68% and 95% intervals. Export
            # latest or all to CSV or text for pasting into word or excel.
            if event.message == "uncertainty_final":
                self.view["error"].fit_progress(event.problem, state)
                # Format the final variable nicely and show them on the console.
                # Note: only done at the end because GUI gets overwhelmed when
                # the text control has too much text.
                signal.log_message(dream_stats.format_vars(stats))
        else:
            raise ValueError("Unknown fit progress message " + event.message)

    def new_model(self):
        from ..plugin import new_model as gen

        self.set_model(gen())

    def load_model(self, path):
        self._reload_path = path
        model = load_model(path)
        signal.model_new(model=model)

    def apply_parameters(self, path):
        load_best(self.model, path)
        # TODO: remove this once LHS randomization is controlled from the command line. Ticket #51
        if hasattr(self.model, "undefined"):
            del self.model.undefined
        signal.update_parameters(model=self.model)

    def save_model(self, path):
        try:
            import dill

            dump = lambda obj, fid: dill.dump(obj, fid, recurse=True)
        except ImportError:
            from pickle import dump
        try:
            if hasattr(plugin, "save_json"):
                plugin.save_json(self.model, path)
            elif hasattr(self.model, "save_json"):
                self.model.save_json(path)
            with open(path, "wb") as fid:
                dump(self.model, fid)
        except Exception:
            import traceback

            signal.log_message(message=traceback.format_exc())

    def save_results(self, path):
        output_path = os.path.join(path, self.model.name)

        # Storage directory
        if not os.path.exists(path):
            os.mkdir(path)

        # Ask model to save its information
        self.model.save(output_path)

        # Save a snapshot of the model that can (hopefully) be reloaded
        self.save_model(output_path + MODEL_EXT)

        # Save the current state of the parameters
        with redirect_console(output_path + ".out"):
            self.model.show()
        pardata = "".join("%s %.15g\n" % (name, value) for name, value in zip(self.model.labels(), self.model.getp()))
        open(output_path + ".par", "wt").write(pardata)

        # Produce model plots
        self.model.plot(figfile=output_path)

        # Produce uncertainty plots
        if self.uncertainty_state is not None:
            with redirect_console(output_path + ".err"):
                self.uncertainty_state.show(figfile=output_path)
            self.uncertainty_state.save(output_path)

    def _add_measurement_type(self, type):
        """
        Add the panels needed to view a measurement of the given type.

        *type* is fitness.__class__, where fitness is the measurement cost function.
        """
        name = type.__name__
        if type not in self.data_tabs:
            tab = self.data_notebook.add_tab(type, name + " Data")
            constructor = getattr(type, "data_panel", PlotView)
            constructor(tab)
        if type not in self.model_notebook and hasattr(type, "model_panel"):
            tab = self.model_notebook.add_tab(type, name + " Model")
            type.model_panel(tab)

    def _view_problem(self, problem):
        """
        Set the model and data views to those necessary to display the problem.
        """
        # What types of measurements do we have?
        models = problem.models if hasattr(problem, "models") else [problem]
        types = set(p.fitness.__class__ for p in models)
        for p in types:
            self._add_measurement_type(p)

        # Show only the relevant views
        for p, tab in self.data_notebook.tabs():
            tab.Show(p in types)
        for p, tab in self.model_notebook.tabs():
            tab.Show(p in types)

    def set_model(self, model):
        # Inform the various tabs that the model they are viewing has changed.
        self.model = model

        # Point all of our views at the new model
        for v in self.view.values():
            if hasattr(v, "set_model"):
                v.set_model(model)
        self.console["model"] = model

        # Enable appropriate menu items.
        self.fit_menu.Enable(id=self.fit_menu_start.GetId(), enable=True)
        self.fit_menu.Enable(id=self.fit_menu_stop.GetId(), enable=True)
        self.fit_menu.Enable(id=self.fit_menu_options.GetId(), enable=True)

        # Enable appropriate toolbar items.
        self.tb.EnableTool(self.tb_start.GetId(), True)
        self.tb.EnableTool(self.tb_stop.GetId(), True)
        if hasattr(model, "broken_constraints"):
            signal.log_message(message="Unsatisfied constraints: \n\t%s" % (",\n\t".join(model.broken_constraints)))
        if hasattr(model, "path"):
            signal.log_message(message="loaded " + model.path)
            self.GetTopLevelParent().SetTitle("Bumps: %s" % model.name)
        else:
            signal.log_message(message="new model")
            self.GetTopLevelParent().SetTitle("Bumps")


SOUND = None


def beep():
    """
    Play fit completion sound.
    """
    wx.Bell()
    ## FIXME why doesn't sound work?
    # global SOUND
    # if SOUND is None:
    #    SOUND = wx.Sound(resource('done.wav'))
    # if SOUND.IsOk():
    #    SOUND.Play(wx.SOUND_ASYNC)