#!/usr/bin/env python3

import importlib.machinery
import logging
from threading import Thread
import wx

from CoreLibrary.Param_Model import Param_Model

from plotView import PlotPanel

LOGGER = logging.getLogger("my_logger")


class MainFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, wx.ID_ANY, "MESS MICH")
        self.configure_window()

        self.green = wx.Bitmap("./GUI/img/green.bmp")
        self.red = wx.Bitmap("./GUI/img/red.bmp")

        self.model, self.pd = self.init_api()
        # MENU BAR
        self.menu_bar()

        # self.status_bar()
        # self.tool_bar()

        self.panel = wx.Panel(self, wx.ID_ANY)
        grid_sizer_main = wx.GridBagSizer(0, 0)

        self.status = self.status_init(grid_sizer_main)
        self.tabs = self.plot_init(grid_sizer_main)

        grid_group = wx.GridBagSizer(10, 0)
        grid_sizer_main.Add(grid_group, (0, 2), (2, 1), wx.EXPAND, 0)
        self.b_run, self.b_start, self.b_stop = self.init_measurement_buttons(grid_group)
        self.plot_buttons(grid_sizer_main)

        self.panel.SetSizer(grid_sizer_main)

        self.Layout()
        # end wxGlade
        self.timer = wx.Timer(self, wx.ID_ANY)
        self.Bind(wx.EVT_CLOSE, self.on_close_window)
        self.Bind(wx.EVT_TIMER, self.update, self.timer)
        self.timer.Start(100, False)
        self.runner_thread = None

    def configure_window(self):
        self.SetSize((1920, 1080))
        self.SetTitle("My Fancy Measurements :D")

    def init_api(self):
        model = Param_Model()
        pd = model.get_plot_data()

        return model, pd

    def menu_bar(self):
        frame_menubar = wx.MenuBar()
        tmp_menu = wx.Menu()
        item = tmp_menu.Append(wx.ID_ANY, "Quit", "")
        self.Bind(wx.EVT_MENU, self.on_close_window, item)
        frame_menubar.Append(tmp_menu, "File")
        self.SetMenuBar(frame_menubar)

    def status_bar(self):
        frame_statusbar = self.CreateStatusBar(1)
        frame_statusbar.SetStatusWidths([-1])
        # statusbar fields
        frame_statusbar_fields = ["frame_statusbar"]
        for count, field in enumerate(frame_statusbar_fields):
            frame_statusbar.SetStatusText(field, count)

    def tool_bar(self):
        frame_toolbar = wx.ToolBar(self, -1)
        self.SetToolBar(frame_toolbar)
        frame_toolbar.Realize()

    def status_init(self, grid_sizer_main):
        sizer_status = wx.GridBagSizer(vgap=5, hgap=5)
        grid_sizer_main.Add(sizer_status, (0, 0), (2, 1), wx.EXPAND, 0)

        # STATUS
        data = {"over1": False, "over2": True, "motor": 123}
        status_dict = {}
        for row, (key, val) in enumerate(data.items()):
            label = wx.StaticText(self.panel, wx.ID_ANY, key)
            sizer_status.Add(label, (row, 0))
            if isinstance(val, bool):
                if val:
                    icon = wx.StaticBitmap(self.panel, bitmap=self.green)
                    status_dict[key] = icon
                    sizer_status.Add(icon, (row, 1))
                else:
                    icon = wx.StaticBitmap(self.panel, bitmap=self.red)
                    status_dict[key] = icon
                    sizer_status.Add(icon, (row, 1))
            else:
                label = wx.StaticText(self.panel, wx.ID_ANY, str(val))
                status_dict[key] = label
                sizer_status.Add(label, (row, 1))

        return status_dict

    def plot_init(self, grid_sizer_main):
        tabs = wx.Notebook(self.panel, wx.ID_ANY)
        grid_sizer_main.Add(tabs, (0, 1), (1, 1), wx.EXPAND, 0)

        plot = lambda ax, dat: ax.plot(dat["time"], dat["mess1"])
        update = lambda im, dat: im.set_data(dat["time"], dat["mess1"])
        plot_1 = PlotPanel(tabs, self.pd, plot, update)
        tabs.AddPage(plot_1, "Temp")

        plot = lambda ax, dat: ax.plot(dat["mess1"], dat["mess1"])
        update = lambda im, dat: im.set_data(dat["mess1"], dat["mess1"])
        plot_2 = PlotPanel(tabs, self.pd, plot, update)
        tabs.AddPage(plot_2, "Multi")
        return tabs

    def init_measurement_buttons(self, grid_upper):
        grid_sizer_measurement = wx.GridBagSizer(0, 0)
        grid_upper.Add(grid_sizer_measurement, (0, 0), (1, 1), wx.EXPAND, 0)

        b_start = wx.Button(self.panel, wx.ID_ANY, "Start")
        grid_sizer_measurement.Add(b_start, (0, 0), (1, 1), 0, 0)

        b_stop = wx.Button(self.panel, wx.ID_ANY, "Stop")
        grid_sizer_measurement.Add(b_stop, (1, 0), (1, 1), 0, 0)

        b_run = wx.Button(self.panel, wx.ID_ANY, "Run")
        grid_sizer_measurement.Add(b_run, (2, 0), (1, 1), 0, 0)

        self.Bind(wx.EVT_BUTTON, self.on_b_start, b_start)
        self.Bind(wx.EVT_BUTTON, self.on_b_stop, b_stop)
        self.Bind(wx.EVT_BUTTON, self.on_b_run, b_run)

        return b_run, b_start, b_stop

    def plot_buttons(self, grid_sizer_main):
        grid_sizer_ctrl_plot = wx.GridBagSizer(0, 0)
        grid_sizer_main.Add(grid_sizer_ctrl_plot, (1, 1), (1, 1), wx.EXPAND, 0)

        b_clear = wx.Button(self.panel, wx.ID_ANY, "Clear")
        grid_sizer_ctrl_plot.Add(b_clear, (0, 0), (1, 1), 0, 0)

        b_save = wx.Button(self.panel, wx.ID_ANY, "Save")
        grid_sizer_ctrl_plot.Add(b_save, (0, 1), (1, 1), 0, 0)

        self.Bind(wx.EVT_BUTTON, self.on_b_clear, b_clear)
        self.Bind(wx.EVT_BUTTON, self.on_b_save, b_save)

    def on_close_window(self, _):
        self.model.exit()
        LOGGER.info("Closing")
        wx.Exit()

    def update(self, _):
        # Repaint gui
        self.tabs.Refresh()
        self.model.refresh()
        # Unlock if script is finished
        if self.runner_thread is not None:
            if not self.runner_thread.is_alive():
                self.unlock()
                self.runner_thread = None
        # update Stuff
        data = {"over1": True, "over2": True, "motor": 12}
        for key, val in data.items():
            if type(val) is bool:
                if val:
                    self.status[key].SetBitmap(self.green)
                else:
                    self.status[key].SetBitmap(self.red)
            else:
                self.status[key].SetLabel(str(val))

    def lock(self):
        self.b_run.Disable()
        self.b_start.Disable()

    def unlock(self):
        self.b_run.Enable()
        self.b_start.Enable()

    def on_b_start(self, event):  # wxGlade: MyFrame.<event_handler>
        LOGGER.info("Event handler 'on_b_start'")
        self.model.start_measuring()
        event.Skip()

    def on_b_save(self, event):  # wxGlade: MyFrame.<event_handler>
        LOGGER.info("Event handler 'on_b_save'")
        with wx.FileDialog(
            self,
            "Save csv file",
            wildcard="CSV files (*.csv)|*.csv",
            style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT,
        ) as fileDialog:

            if fileDialog.ShowModal() == wx.ID_CANCEL:
                return  # the user changed their mind

            # save the current contents in the file
            pathname = fileDialog.GetPath()
            self.model.save_measuring(path=pathname)
        event.Skip()

    def on_b_run(self, event):  # wxGlade: MyFrame.<event_handler>
        LOGGER.info("Event handler 'on_b_run'")
        with wx.FileDialog(
            self,
            "Open PY file",
            wildcard="PY files (*.py)|*.py",
            style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST,
        ) as fileDialog:

            if fileDialog.ShowModal() == wx.ID_CANCEL:
                return  # the user changed their mind

            # Proceed loading the file chosen by the user
            pathname = fileDialog.GetPath()
            script = importlib.machinery.SourceFileLoader("ghf", pathname).load_module()
            self.runner_thread = Thread(target=script.main, args=(self.model,))
            self.lock()
            self.runner_thread.start()
        event.Skip()

    def on_b_stop(self, event):  # wxGlade: MyFrame.<event_handler>
        self.model.stop_measuring()
        LOGGER.info("Event handler 'on_b_stop'")
        event.Skip()

    def on_b_clear(self, event):  # wxGlade: MyFrame.<event_handler>
        self.model.clear()
        LOGGER.info("Event handler 'on_b_clear'")
        event.Skip()


# end of class MyFrame