from network.ValhallaServer import ValhallaServer
from utils.MachineData import MachineData
import argparse
from picotui.widgets import *
from picotui.menu import *
from picotui.context import Context
import os
import json

machine_data = MachineData()

def synchronize():
    server = ValhallaServer(
        server_address=machine_data.server_url,
        server_port=machine_data.server_port,
        server_user=machine_data.server_access_username,
        server_access_password=machine_data.server_password,
        logging_level=machine_data.client_loglevel,
    )
    server.authenticate()
    server.get_server_data()
    server.update_machine_data_on_server(machine_data=machine_data)
    vm_list = server.get_vm_list_from_server(machine_data=machine_data)
    print(vm_list)
    vm_data = server.get_vms_data_from_server()
    with open("vms_data.json", "w") as vm_data_file:
        vm_data_file.write(json.dumps(vm_data))
        vm_data_file.flush()
    server.update_vms_images_from_server()
    for image_id in vm_data:
        run_script_path = f"images/valhalla/{vm_data[image_id]['image_name']}/{vm_data[image_id]['image_version']}"
        print(run_script_path)
        machine_data.generate_runner_script(run_script_path)
 
def runner():
    d = None
    image_choice_vm_id = None
    vm_data = {}
    with open("vms_data.json", "r") as vm_data_file:
        try:
            vm_data = json.loads(vm_data_file.read())
        except Exception as ex:
            print(f"ERROR: {str(ex)}")
    # This routine is called to redraw screen "in menu's background"
    def screen_redraw(s, allow_cursor=False):
        with open("vms_data.json", "r") as vm_data_file:
            try:
                vm_data = json.loads(vm_data_file.read())
            except Exception as ex:
                print(f"ERROR: {str(ex)}")
        s.attr_color(C_WHITE, C_BLUE)
        s.cls()
        s.attr_reset()
        d.redraw()
    def main_loop():
        while 1:
            key = m.get_input()

            if isinstance(key, list):
                # Mouse click
                x, y = key
                if m.inside(x, y):
                    m.focus = True

            if m.focus:
                # If menu is focused, it gets events. If menu is cancelled,
                # it loses focus. Otherwise, if menu selection is made, we
                # quit with with menu result.
                res = m.handle_input(key)
                if res == ACTION_CANCEL:
                    m.focus = False
                elif res is not None and res is not True:
                    return res
            else:
                # If menu isn't focused, it can be focused by pressing F9.
                if key == KEY_F9:
                    m.focus = True
                    m.redraw()
                    continue
                # Otherwise, dialog gets input
                res = d.handle_input(key)
                if res is not None and res is not True:
                    return res
    with Context():

        d = Dialog(10, 5, 80, 24)
        d.add(12, 1, WLabel("Virtual Machine selection screen"))
        d.add(1, 2, WLabel("VMs:"))
        vm_names_table = []
        for vm_id in vm_data:
            vm_names_table.append(f"{vm_id}: {vm_data[vm_id]['image_name']} - ver. {vm_data[vm_id]['image_version']}")
        w_listbox = WListBox(64, 4, vm_names_table)
        d.add(1,3, w_listbox)

        d.add(1, 6, "Selected listbox value:")
        w_listbox_val = WLabel("", w=64)
        d.add(1, 7, w_listbox_val)

        def listbox_changed(w):
            val = w.items[w.choice]
            w_listbox_val.t = val
            w_listbox_val.redraw()
        
        w_listbox.on("changed", listbox_changed)

        b = WButton(8, "OK")
        d.add(10, 11, b)
        b.finish_dialog = ACTION_OK

        b = WButton(8, "Cancel")
        d.add(23, 11, b)
        b.finish_dialog = ACTION_CANCEL

        screen_redraw(Screen)
        Screen.set_screen_redraw(screen_redraw)

        menu_file = WMenuBox([("Exit", "ex")])
        m = WMenuBar([("File", menu_file), ("About", "About")])
        m.permanent = True
        m.redraw()

        res = main_loop()
        image_choice_vm_id = int(str(vm_names_table[int(w_listbox.choice)]).split(":")[0])
    print(image_choice_vm_id)
    try:
        print(f"Running VM: {vm_data[f'{image_choice_vm_id}']['image_name']}:{vm_data[f'{image_choice_vm_id}']['image_version']}")
        os.execvp(f"images/valhalla/{vm_data[f'{image_choice_vm_id}']['image_name']}/{vm_data[f'{image_choice_vm_id}']['image_version']}/run.sh")
    except Exception as ex:
        print(str(ex))

parser = argparse.ArgumentParser(
    prog="valhalla-client",
    description="Client for running VM machines",
)

function_mapper = {
    "runner": runner,
    "synchronize": synchronize,
}

parser.add_argument("command", choices=function_mapper)
args = parser.parse_args()

fun = function_mapper[args.command]
try:
    fun()
except Exception as ex:
    print(f"Invalid command: {str(ex)}")

# vim:ft=py