# -*- coding: utf-8 -*-
from setuphelpers import *

config_file = "mesh-conf.json"


def install():
    # Declaring local variables
    package_version = control.get_software_version()
    app_name = control.name
    mesh_config_dict = json_load_file(get_persistent_package_file(config_file))
    if mesh_config_dict["mesh_companyName"] != mesh_config_dict["mesh_serviceName"]:
        app_dir = makepath(programfiles, mesh_config_dict["mesh_companyName"], mesh_config_dict["mesh_serviceName"])
    else:
        app_dir = makepath(programfiles, mesh_config_dict["mesh_companyName"])
    app_path = makepath(app_dir, mesh_config_dict["mesh_fileName"] + ".exe")
    app_uninstallkey = mesh_config_dict["mesh_serviceName"]

    if iswin64():
        bin_name = glob.glob("*64-*.exe")[0]
    else:
        bin_name = glob.glob("*32-*.exe")[0]

    if not running_as_system():
        print(
            f'WARNING: {app_name} will NOT be installed as SYSTEM account, that will cause issues since it is installed as user: {get_current_user()} ("Waiting for key: {mesh_config_dict["mesh_serviceName"]}" will not complete), please uninstall it manually before deployment'
        )

    def get_app_version(key):
        return get_version_from_binary(app_path, "FileVersion")

    # Installing the software
    install_exe_if_needed(
        bin_name,
        silentflags="-fullinstall",
        key=app_uninstallkey,
        min_version=package_version,
        get_version=get_app_version,
        accept_returncodes=[0, 1, 3010, 3221226356],
    )

    # Adding QuietUninstallString in registry for software
    quiet_uninstall_string = f'"{app_path}" {"-fulluninstall"}'
    wait_uninstallkey_present(app_uninstallkey)
    register_uninstall(app_uninstallkey, quiet_uninstall_string=quiet_uninstall_string)


def uninstall():
    # Declaring local variables
    mesh_config_dict = json_load_file(get_persistent_package_file(config_file))
    app_dir = makepath(programfiles, mesh_config_dict["mesh_companyName"])
    app_uninstallkey = mesh_config_dict["mesh_serviceName"]

    # Removing remaining folders if possible
    if isdir(app_dir):
        killalltasks(control.get_impacted_process_list())
        wait_uninstallkey_absent(app_uninstallkey)
        print("Removing: %s" % (app_dir))
        remove_tree(app_dir)


def audit():
    # Declaring local variables
    mesh_config_dict = json_load_file(get_persistent_package_file(config_file))
    if mesh_config_dict["mesh_companyName"] != mesh_config_dict["mesh_serviceName"]:
        app_dir = makepath(programfiles, mesh_config_dict["mesh_companyName"], mesh_config_dict["mesh_serviceName"])
    else:
        app_dir = makepath(programfiles, mesh_config_dict["mesh_companyName"])
    app_path = makepath(app_dir, mesh_config_dict["mesh_fileName"] + ".exe")
    app_name = mesh_config_dict["mesh_displayName"]
    mesh_regkey = r"SOFTWARE\Open Source\%s" % mesh_config_dict["mesh_serviceName"]
    meshserverurl = registry_readstring(HKEY_LOCAL_MACHINE, mesh_regkey, "MeshServerUrl")
    nodeid = registry_readstring(HKEY_LOCAL_MACHINE, mesh_regkey, "NodeId")
    remotedesktopurl = "https://%s:%s/?viewmode=11&gotonode=%s&hide=25" % (mesh_config_dict["mesh_server"], mesh_config_dict["mesh_port"], nodeid)

    print(remotedesktopurl)
    """
    // SERVICE_STOPPED				  1    The service is not running.
    // SERVICE_START_PENDING		  2    The service is starting.
    // SERVICE_STOP_PENDING			  3    The service is stopping.
    // SERVICE_RUNNING				  4    The service is running.
    // SERVICE_CONTINUE_PENDING		  5    The service continue is pending.
    // SERVICE_PAUSE_PENDING		  6    The service pause is pending.
    // SERVICE_PAUSED				  7    The service is paused.
    // SERVICE_NOT_INSTALLED		100    The service is not installed.
    """
    # nodeid = run([app_path, "-nodeid"]).splitlines()[0]
    # run(f'"{app_path}" -exec "console.log(_MSH().meshServiceName);process.exit();"')
    state = run(f'"{app_path}" {"state"}')  # , accept_returncodes=[0, 1, 2, 3, 4, 5, 6, 7, 100]
    state_str = state.strip()
    print("%s service state is:" % app_name)
    print(state_str)
    if state_str.lower() == "RUNNING".lower():
        result = "OK"
    elif state_str.lower() == "NOT INSTALLED".lower():
        result = "WARNING"
        print(
            'INFO: "Not installed" Service state may be incorrect status, you may need to update your Mesh Server and Mesh Agent (more info here: https://github.com/Ylianst/MeshAgent/issues/87)'
        )
    else:
        result = "WARNING"

    try:
        WAPT.write_audit_data_if_changed("mesh", "meshserverurl", meshserverurl, keep_days=365)
        WAPT.write_audit_data_if_changed("mesh", "nodeid", nodeid, keep_days=365)
        WAPT.write_audit_data_if_changed("mesh", "agenthash", registry_readstring(HKEY_LOCAL_MACHINE, mesh_regkey, "AgentHash"), keep_days=365)
        WAPT.write_audit_data_if_changed("mesh", "remotedesktopurl", remotedesktopurl, keep_days=365)
    except:
        print("ERROR: write_audit_data failed")
        result = "ERROR"

    return result


def get_persistent_package_file(fname):
    if isdir(makepath(os.getcwd(), "WAPT", "persistent")):
        return makepath(os.getcwd(), "WAPT", "persistent", fname)
    else:
        return makepath(WAPT.persistent_root_dir, control.package_uuid, fname)


def get_persistent_package_dir():
    if isdir(makepath(os.getcwd(), "WAPT", "persistent")):
        return makepath(os.getcwd(), "WAPT", "persistent")
    else:
        return makepath(WAPT.persistent_root_dir, control.package_uuid)

                                

# -*- coding: utf-8 -*-
from setuphelpers import *
import waptguihelper
import json


def get_persistent_package_file(fname):
    if isdir(makepath(os.getcwd(), "WAPT", "persistent")):
        return makepath(os.getcwd(), "WAPT", "persistent", fname)
    else:
        return makepath(WAPT.persistent_root_dir, control.package_uuid, fname)


config_file = "mesh-conf.json"
mesh_config_dict_old = json_load_file(get_persistent_package_file(config_file))


def update_package():
    # Declaring local variables
    package_updated = False

    # Gathering informations for the package
    if "template" in control.package:
        package = waptguihelper.input_dialog(
            control.package, "Please change the template suffix with a term corresponding to your Mesh Agent", control.package
        )
        control.package = package
        control.save_control_to_wapt()

    dialog_response = waptguihelper.grid_dialog(
        "Adapt your Agent parameters (corresponding to: meshcentral-data/config.json)",
        format_dict_to_grid(mesh_config_dict_old),
        0,
        '{"columns":[{"propertyname":"parameter","datatype":"String","required":false,"readonly":true,"width":153},{"propertyname":"value","datatype":"String","required":false,"readonly":false,"width":172}]}',
    )
    json_write_file(get_persistent_package_file(config_file), format_grid_to_dict(dialog_response))
    mesh_config_dict = json_load_file(get_persistent_package_file(config_file))

    # Getting binaries
    if glob.glob("*.exe"):
        ask_for_binaries = waptguihelper.message_dialog(control.package, "Do you want to deploy new Mesh Agent binaries ?", waptguihelper.MB_YESNO)
    else:
        ask_for_binaries = 6

    # Deleting binaries
    if ask_for_binaries == 6:
        for f in glob.glob("*.exe") + glob.glob("*.msi"):
            print("Removing: %s" % f)
            remove_file(f)

        bin_path_x86 = waptguihelper.filename_dialog(
            "Please provide x86 Mesh Agent",
            "",
            "%s32-%s.exe" % (mesh_config_dict["mesh_fileName"].replace(" ", ""), mesh_config_dict["mesh_deviceGroup"].replace(" ", "")),
            "EXE Files|*.exe",
        )
        bin_path_x64 = waptguihelper.filename_dialog(
            "Please provide x64 Mesh Agent",
            "",
            "%s64-%s.exe" % (mesh_config_dict["mesh_fileName"].replace(" ", ""), mesh_config_dict["mesh_deviceGroup"].replace(" ", "")),
            "EXE Files|*.exe",
        )
        bin_name_x64 = bin_path_x64.split(os.sep)[-1].split(".")[0]
        if bin_path_x86:
            bin_name_x86 = bin_path_x86.split(os.sep)[-1].split(".")[0]
            filecopyto(bin_path_x86, basedir)
            if not bin_name_x86 in control.impacted_process:
                control.impacted_process = control.impacted_process + "," + bin_name_x86
                control.save_control_to_wapt()
        filecopyto(bin_path_x64, basedir)
        if not bin_name_x64 in control.impacted_process:
            control.impacted_process = control.impacted_process + "," + bin_name_x64
            control.save_control_to_wapt()

        # Changing version of the package
        version = get_file_properties(bin_path_x64).get("FileVersion", control.get_software_version())
        if Version(version) > Version(control.get_software_version()):
            print("Software version updated (from: %s to: %s)" % (control.get_software_version(), Version(version)))
            package_updated = True
        else:
            print("Software version up-to-date (%s)" % Version(version))
        control.set_software_version(version)
        control.save_control_to_wapt()
    if not mesh_config_dict["mesh_fileName"] in control.impacted_process:
        control.impacted_process = control.impacted_process + "," + mesh_config_dict["mesh_fileName"]
        control.save_control_to_wapt()

    # Editing control
    if not "template" in control.package:
        control.name = mesh_config_dict["mesh_displayName"]
        control.description = mesh_config_dict["mesh_displayName"]
        control.save_control_to_wapt()

    # Validating or not update-package-sources
    return package_updated


def format_dict_to_grid(dict_data, key_name="parameter", value_name="value"):
    dict_list_data = []
    for section in dict_data:
        dict_list_data.append({key_name: section, value_name: dict_data[section]})
    return json.dumps(dict_list_data)


def format_grid_to_dict(dict_list_data, key_name="parameter", value_name="value"):
    dict_data = {}
    for entry in dict_list_data:
        dict_data.update({entry[key_name]: entry[value_name]})
    return dict_data