#!/usr/bin/python

import gi
import time
import threading

import json
import requests
import websocket
import logging
import os
import asyncio


gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Gdk, GLib

from KlippyWebsocket import KlippyWebsocket
from KlippyRest import KlippyRest
from files import KlippyFiles
from KlippyGtk import KlippyGtk
from printer import Printer

# Do this better in the future
from panels.screen_panel import *
from panels.bed_level import *
from panels.extrude import *
from panels.fan import *
from panels.fine_tune import *
from panels.job_status import *
from panels.main_menu import *
from panels.menu import *
from panels.move import *
from panels.network import *
from panels.preheat import *
from panels.print import *
from panels.splash_screen import *
from panels.system import *
from panels.temperature import *
from panels.zcalibrate import *

# Create logging
logger = logging.getLogger('KlipperScreen')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh = logging.FileHandler('/tmp/KlipperScreen.log')
fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)

ch = logging.StreamHandler()
ch.setLevel(logging.ERROR)
ch.setFormatter(formatter)

logger.addHandler(fh)
logger.addHandler(ch)

klipperscreendir = os.getcwd()
config = klipperscreendir + "/KlipperScreen.config"
logger.info("Config file: " + config)

class KlipperScreen(Gtk.Window):
    """ Class for creating a screen for Klipper via HDMI """
    currentPanel = None
    bed_temp_label = None
    number_tools = 1

    panels = {}
    _cur_panels = []
    filename = ""
    subscriptions = []
    last_update = {}
    shutdown = True
    printer = None

    def __init__(self):
        self.read_config()
        self.init_style()
        self.printer = Printer({
            'configfile': {
                'config': {}
            },
            'print_stats': {
                'state': 'disconnected'
            },
            'virtual_sdcard': {
                'is_active': False
            }
        })

        self.apiclient = KlippyRest("127.0.0.1",7125)
        Gtk.Window.__init__(self)

        self.set_default_size(Gdk.Screen.get_width(Gdk.Screen.get_default()), Gdk.Screen.get_height(Gdk.Screen.get_default()))
        self.set_resizable(False)
        logger.info("Screen resolution: %s", str(Gdk.Screen.get_width(Gdk.Screen.get_default()))+"x"+str(Gdk.Screen.get_height(Gdk.Screen.get_default())))

        self.printer_initializing("Connecting to Moonraker")

        # Disable DPMS
        os.system("/usr/bin/xset -display :0 s off")
        os.system("/usr/bin/xset -display :0 -dpms")
        os.system("/usr/bin/xset -display :0 s noblank")

        ready = False

        try:
            info = self.apiclient.get_info()
        except Exception:
            return

        if info == False:
            return

        if not hasattr(self, "_ws"):
            self.create_websocket()

        print(info)
        if info['result']['klippy_state'] == "disconnected":
            self.printer_initializing("Klipper is not connected to moonraker")
            return
        if info['result']['klippy_state'] == "error":
            logger.warning("Printer is emergency stopped")
            self.printer_initializing("Shutdown due to Emergency Stop")
            return

        status_objects = [
            'idle_timeout',
            'configfile',
            'gcode_move',
            'fan',
            'toolhead',
            'virtual_sdcard',
            'print_stats',
            'heater_bed',
            'extruder',
            'pause_resume'
        ]
        r = requests.get("http://127.0.0.1:7125/printer/objects/query?" + "&".join(status_objects))

        #TODO: Check that we get good data
        #print (r.content)
        try:
            data = json.loads(r.content)
        except:
            logger.info("Not able to load data. Klippy is most likely offline")
            return
        data = data['result']['status']
        for x in data:
            self.last_update[x] = data[x]

        self.printer_config = data['configfile']['config']
        #logger.debug("Printer config: %s" % json.dumps(self.printer_config, indent=2))
        self.printer.__init__(data)

        # Initialize target values. TODO: methodize this
        self.printer.set_dev_stat("heater_bed", "target", data['heater_bed']['target'])
        self.printer.set_dev_stat("extruder", "target", data['extruder']['target'])

        print (info)
        if (data['print_stats']['state'] == "printing" or data['print_stats']['state'] == "paused"):
            self.printer_printing()
        elif info['result']['klippy_state'] == "ready":
            self.printer_ready()

        self.files = KlippyFiles(self)

    def ws_subscribe(self):
        requested_updates = {
            "objects": {
                "configfile": ["config"],
                "extruder": ["target","temperature","pressure_advance","smooth_time"],
                "fan": ["speed"],
                "gcode_move": ["homing_origin","extrude_factor","speed_factor"],
                "heater_bed": ["target","temperature"],
                "print_stats": ["print_duration","total_duration","filament_used","filename","state","message"],
                "toolhead": ["homed_axes","estimated_print_time","print_time","position","extruder"],
                "virtual_sdcard": ["file_position","is_active","progress"]
            }
        }
        self._ws.klippy.object_subscription(requested_updates)

    def show_panel(self, panel_name, type, remove=None, pop=True, **kwargs):
        if remove == 2:
            self._remove_all_panels()
        elif remove == 1:
            self._remove_current_panel(pop)

        if panel_name not in self.panels:
            if type == "SplashScreenPanel":
                self.panels[panel_name] = SplashScreenPanel(self)
            elif type == "MainPanel":
                self.panels[panel_name] = MainPanel(self)
            elif type == "menu":
                self.panels[panel_name] = MenuPanel(self)
            elif type == "bed_level":
                self.panels[panel_name] = BedLevelPanel(self)
            elif type == "extrude":
                self.panels[panel_name] = ExtrudePanel(self)
            elif type == "finetune":
                self.panels[panel_name] = FineTune(self)
            elif type == "JobStatusPanel":
                self.panels[panel_name] = JobStatusPanel(self)
            elif type == "move":
                self.panels[panel_name] = MovePanel(self)
            elif type == "network":
                self.panels[panel_name] = NetworkPanel(self)
            elif type == "preheat":
                self.panels[panel_name] = PreheatPanel(self)
            elif type == "print":
                self.panels[panel_name] = PrintPanel(self)
            elif type == "temperature":
                self.panels[panel_name] = TemperaturePanel(self)
            elif type == "fan":
                self.panels[panel_name] = FanPanel(self)
            elif type == "system":
                self.panels[panel_name] = SystemPanel(self)
            elif type == "zcalibrate":
                self.panels[panel_name] = ZCalibratePanel(self)
            #Temporary for development
            else:
                self.panels[panel_name] = MovePanel(self)

            if kwargs != {}:
                self.panels[panel_name].initialize(panel_name, **kwargs)
            else:
                self.panels[panel_name].initialize(panel_name)

            if hasattr(self.panels[panel_name],"process_update"):
                self.panels[panel_name].process_update(self.printer.get_data())

        if hasattr(self.panels[panel_name],"activate"):
            self.panels[panel_name].activate()

        self.add(self.panels[panel_name].get())
        self.show_all()
        self._cur_panels.append(panel_name)
        logger.debug("Current panel hierarchy: %s", str(self._cur_panels))


    def read_config (self):
        with open(config) as config_file:
            self._config = json.load(config_file)


    def init_style(self):
        style_provider = Gtk.CssProvider()
        style_provider.load_from_path(klipperscreendir + "/style.css")

        Gtk.StyleContext.add_provider_for_screen(
            Gdk.Screen.get_default(),
            style_provider,
            Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
        )

    def create_websocket(self):
        self._ws = KlippyWebsocket(self, self._websocket_callback)
        self._ws.connect()
        self._curr = 0


    def _go_to_submenu(self, widget, name):
        logger.info("#### Go to submenu " + str(name))
        #self._remove_current_panel(False)

        # Find current menu item
        panels = list(self._cur_panels)
        if "job_status" not in self._cur_panels:
            cur_item = self._find_current_menu_item(name, self._config['mainmenu'], panels.pop(0))
            menu = cur_item['items']
        else:
            menu = self._config['printmenu']

        logger.info("#### Menu " + str(menu))
        #self.show_panel("_".join(self._cur_panels) + '_' + name, "menu", 1, False, menu=menu)

        self.show_panel(self._cur_panels[-1] + '_' + name, "menu", 1, False, items=menu)
        return

        grid = self.arrangeMenuItems(menu, 4)

        b = KlippyGtk.ButtonImage('back', 'Back')
        b.connect("clicked", self._menu_go_back)
        grid.attach(b, 4, 2, 1, 1)

        self._cur_panels.append(cur_item['name']) #str(cur_item['name']))
        self.panels[cur_item['name']] = grid
        self.add(self.panels[cur_item['name']])
        self.show_all()



    def _find_current_menu_item(self, menu, items, names):
        for item in items:
            if item['name'] == menu:
                return item
        #TODO: Add error check

    def _remove_all_panels(self):
        while len(self._cur_panels) > 0:
            self._remove_current_panel()



    def _remove_current_panel(self, pop=True):
        if len(self._cur_panels) > 0:
            self.remove(
                self.panels[
                    self._cur_panels[-1]
                ].get()
            )
            if pop == True:
                self._cur_panels.pop()
                if len(self._cur_panels) > 0:
                    self.add(self.panels[self._cur_panels[-1]].get())
                    self.show_all()

    def _menu_go_back (self, widget):
        logger.info("#### Menu go back")
        self._remove_current_panel()


    def add_subscription (self, panel_name):
        add = True
        for sub in self.subscriptions:
            if sub == panel_name:
                return

        self.subscriptions.append(panel_name)

    def remove_subscription (self, panel_name):
        for i in range(len(self.subscriptions)):
            if self.subscriptions[i] == panel_name:
                self.subscriptions.pop(i)
                return

    def _websocket_callback(self, action, data):
        #print(json.dumps([action, data], indent=2))

        if action == "notify_klippy_disconnected":
            logger.info("### Going to disconnected state")
            self.printer_initializing("Klipper has shutdown")
            return
        elif action == "notify_klippy_ready":
            logger.info("### Going to ready state")
            self.printer_ready()
        elif action == "notify_status_update":
            self.printer.process_update(data)
            if "webhooks" in data and "state" in data['webhooks']:
                if data['webhooks']['state'] == "ready":
                    logger.info("### Going to ready state")
                    self.printer_ready()
            else:
                active = self.printer.get_stat('virtual_sdcard','is_active')
                paused = self.printer.get_stat('pause_resume','is_paused')
                if "job_status" in self._cur_panels:
                    if active == False and paused == False:
                        self.printer_ready()
                else:
                    if active == True or paused == True:
                        self.printer_printing()
        elif action == "notify_filelist_changed":
            logger.debug("Filelist changed: %s", json.dumps(data,indent=2))
            #self.files.add_file()
        elif action == "notify_metadata_update":
            self.files.update_metadata(data['filename'])
        else:
            logger.debug(json.dumps([action, data], indent=2))

        for sub in self.subscriptions:
            self.panels[sub].process_update(data)


    def _send_action(self, widget, method, params):
        self._ws.send_method(method, params)

    def printer_initializing(self, text=None):
        self.shutdown = True
        self.show_panel('splash_screen',"SplashScreenPanel", 2)
        if text != None:
            self.panels['splash_screen'].update_text(text)
            self.panels['splash_screen'].show_restart_buttons()

    def printer_ready(self):
        self.shutdown = False

        status_objects = [
            'idle_timeout',
            'configfile',
            'toolhead',
            'virtual_sdcard',
            'print_stats',
            'heater_bed',
            'extruder',
            'pause_resume'
        ]
        r = requests.get("http://127.0.0.1:7125/printer/objects/query?" + "&".join(status_objects))

        #TODO: Check that we get good data
        data = json.loads(r.content)
        self.printer_config = data['result']['status']['configfile']['config']
        #logger.debug("Printer config: %s" % json.dumps(self.printer_config, indent=2))

        # Reinitialize printer, in case the printer was shut down and anything has changed.
        self.printer.__init__(data['result']['status'])
        self.ws_subscribe()

        #logger.debug("Config sections: %s", self.printer.get_config_section_list())
        #logger.debug("Bed_screws: %s", self.printer.get_config_section("bed_screws"))

        self.show_panel('main_panel', "MainPanel", 2, items=self._config['mainmenu'], extrudercount=self.printer.get_extruder_count())

    def printer_printing(self):
        self.ws_subscribe()
        self.show_panel('job_status',"JobStatusPanel", 2)

def main():

    win = KlipperScreen()
    win.connect("destroy", Gtk.main_quit)
    win.show_all()
    Gtk.main()


if __name__ == "__main__":
    main()