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


appx_package_name = "Microsoft.Windows.Photos"
appx_dir = makepath(programfiles, "WindowsAppsInstallers")
allow_remove = False


def install():
    # Declare local variables
    bins_dir = control.package.split("-", 1)[1]
    appx_bins_dir = makepath(appx_dir, bins_dir)

    # Remove from old path
    for appx_file in glob.glob(makepath(appx_dir, "%s_*" % appx_package_name)):
        remove_file(appx_file)

    # Placing bins for session-setup installs
    if isdir(appx_bins_dir):
        remove_tree(appx_bins_dir)
    mkdirs(appx_bins_dir)
    print(f"Creating: {appx_bins_dir}")
    for f in glob.glob(bins_dir + "/*"):
        filecopyto(f, appx_bins_dir)
    for f in glob.glob(appx_bins_dir + "/*"):
        if control.architecture == "all":
            fname = f.split(os.sep)[-1]
            if "x86" in glob.glob(makepath(appx_bins_dir, "%s_*" % appx_package_name))[0].split(os.sep)[-1]:
                if not "x86" in fname and not "neutral" in fname:
                    remove_file(f)
            else:
                if not get_host_architecture() in fname and not "neutral" in fname:
                    remove_file(f)
        else:
            if not control.architecture in fname and not "neutral" in fname:
                remove_file(f)


def session_setup():
    # Declare local variables
    bins_dir = control.package.split("-", 1)[1]
    appx_bins_dir = makepath(appx_dir, bins_dir)
    bin_path = glob.glob(makepath(appx_bins_dir, f"{appx_package_name}_*"))[0]
    dependencies_pathes = ",".join([f'"{a}"' for a in glob.glob(makepath(appx_bins_dir, "*")) if not appx_package_name in a])

    # Installing the UWP application in the user environment
    appx_version = get_powershell_str("Get-AppxPackage -Name %s" % appx_package_name, "Version")
    if not appx_version or Version(appx_version) < Version(control.get_software_version()) or force:
        print("Installing: %s" % bin_path.split("\\")[-1])
        killalltasks(control.get_impacted_process_list())
        add_appx_cmd = f'Add-AppxPackage -Path "{bin_path}"'
        if dependencies_pathes:
            add_appx_cmd += f" -DependencyPath {dependencies_pathes}"
        run_powershell(add_appx_cmd)
    else:
        print("%s is installed in correct version (%s)" % (appx_package_name, appx_version))


def uninstall():
    # Declare local variables
    bins_dir = control.package.split("-", 1)[1]
    appx_bins_dir = makepath(appx_dir, bins_dir)

    if allow_remove:
        remove_appx(appx_package_name)
    if isdir(appx_bins_dir):
        print("Remove: %s" % (appx_bins_dir))
        remove_tree(appx_bins_dir)
    if dir_is_empty(appx_dir):
        print("Remove: %s since it is empty" % (appx_dir))
        remove_tree(appx_dir)


def get_host_architecture():
    if isARM64():
        return "arm64"
    elif isARM():
        return "arm"
    elif is64():
        return "x64"
    elif is32():
        return "x86"

                                

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

try:
    from setupdevhelpers import *
except:
    from bs4 import BeautifulSoup
import waptguihelper
import re
import json


def update_package():
    # Declaring local variables
    package_updated = False
    proxies = get_proxies()
    if not proxies:
        proxies = get_proxies_from_wapt_console()
    store_url = control.sources
    if not store_url:
        store_id = waptguihelper.input_dialog(
            "Choice of app", "Enter the windows store app id (foundable in package url: https://apps.microsoft.com/store/apps)", store_url
        ).split("/")[-1]
    else:
        store_id = store_url.split("/")[-1]
    store_id = store_id.split("?")[0]
    url_ms = "https://apps.microsoft.com/store/detail/%s" % store_id
    control.sources = url_ms
    control.save_control_to_wapt()
    package_prefix = control.package.split("-")[0]

    # check setup.py incase the package name doesnt match the installer file
    appx_package_name = ""
    with open("setup.py", "r", encoding="utf8") as f:
        for line in f.readlines():
            if line.startswith("appx_package_name"):
                appx_package_name = line.split("=")[1].split('"')[1]
                break

    # Getting info from adguard api
    res = requests.post(
        "https://store.rg-adguard.net/api/GetFiles",
        "type=ProductId&url=%s&ring=RP&lang=fr-FR" % store_id,
        headers={"content-type": "application/x-www-form-urlencoded"},
        proxies=proxies,
    )
    all_files = []
    page = BeautifulSoup.BeautifulSoup(res.content, features="html.parser")
    for bs_search in page.find_all("a"):
        if not "BlockMap" in bs_search.text and not "eappxbundle" in bs_search.text and not "emsixbundle" in bs_search.text:
            version = bs_search.text.split("_")[1]
            bin_name = bs_search.text.replace("~", "_")
            download_url = bs_search["href"]
            pkg_splitted = re.split(r"_\d+\.", bin_name)[0]
            package_name = package_prefix + "-" + pkg_splitted.split("_")[0].replace(".", "-").lower()
            software_name = bin_name.split("_")[0].replace("-", " ").replace(".", " ")

            package_arch = get_uwp_filename_arch(bin_name, appx_package_name)
            file_dict = {
                "version": version,
                "bin_name": bin_name,
                "package_name": package_name,
                "software_name": software_name,
                "package_arch": package_arch,
                "download_url": download_url,
            }
            all_files.append(file_dict)
    if (
        "template-microsoft-store" in control.package
        or not appx_package_name
        or not len([a for a in all_files if appx_package_name in a["bin_name"]]) != 0
    ):
        if not all_files:
            error("API returned an empty list, please try again")
        selected = waptguihelper.grid_dialog(
            "Please select the proper file",
            json.dumps(all_files),
            waptguihelper.GRT_SELECTED,
            '{"columns":[{"propertyname":"version","datatype":"String","required":false,"readonly":false,"width":130},{"propertyname":"bin_name","datatype":"String","required":false,"readonly":false,"width":420},{"propertyname":"package_name","datatype":"String","required":false,"readonly":false,"width":190},{"propertyname":"software_name","datatype":"String","required":false,"readonly":false,"width":172},{"propertyname":"package_arch","datatype":"String","required":false,"readonly":false,"width":88},{"propertyname":"download_url","datatype":"String","required":false,"readonly":false,"width":1472}]}',
        )
        appx_package_name = selected[0]["bin_name"].split("_")[0]

    # Downloading files
    for dependency in all_files:
        latest_bin = dependency["bin_name"]
        download_url = dependency["download_url"]
        if download_url.split("/")[2].endswith("microsoft.com"):
            if not isfile(latest_bin):
                print("Downloading: %s" % latest_bin)
                wget(download_url, latest_bin, proxies=proxies)
            else:
                print("Binary is present: %s" % latest_bin)
        else:
            error("ERROR: The retrieved URL will not download from microsoft's servers")

    # Import xmltodict for make_uwp_app_dict()
    if not isfile("xmltodict.py"):
        pip_download_xmltodict = "waptpython -m pip download xmltodict -d %s" % basedir
        if proxies:
            pip_download_xmltodict += " --proxy %s" % proxies["http"]
        run(pip_download_xmltodict)
        unzip(glob.glob("*.whl")[0], ".", "xmltodict.py")
        remove_file(glob.glob("*.whl")[0])
    import sys

    sys.path.append(basedir)

    # Keep app files
    uwp_app_dict = make_uwp_app_dict(appx_package_name)
    newer_version = "0"
    for uwp_app in uwp_app_dict:
        if uwp_app_dict[uwp_app]["Name"] != appx_package_name or uwp_app_dict[uwp_app]["TargetDeviceFamily"] != "Windows.Desktop":
            continue
        if Version(newer_version) < Version(uwp_app_dict[uwp_app]["Version"]):
            if control.max_os_version:
                if not Version(uwp_app_dict[uwp_app]["MinVersion"], 4) < Version(control.max_os_version, 4):
                    continue
            newer_uwp_app = uwp_app_dict[uwp_app]
            newer_version = newer_uwp_app["Version"]

    version = newer_uwp_app["Version"]

    # Get icon.png
    if "b4:Dependencies" in newer_uwp_app:
        unzip(newer_uwp_app["FileName"], ".", newer_uwp_app["b4:Dependencies"][0]["FileName"], False)
        icon_png = unzip(newer_uwp_app["b4:Dependencies"][0]["FileName"], ".", "*.targetsize-48.png", False)
        shutil.move(icon_png[0], "WAPT\\icon.png")
    else:
        icon_png = unzip(newer_uwp_app["FileName"], ".", "*.targetsize-48.png", False)
        shutil.move(icon_png[0], "WAPT\\icon.png")
    [remove_file(a) for a in glob.glob("*.png")]

    # Placing binaries in a dir ["appxbundle", "msixbundle", "appx", "msix]
    bins_dir = control.package.split("-", 1)[1]
    if isdir(bins_dir):
        remove_tree(bins_dir)
    mkdirs(bins_dir)
    if not isfile(makepath(bins_dir, newer_uwp_app["FileName"])):
        shutil.move(newer_uwp_app["FileName"], bins_dir)
    for l in [glob.glob(a["Name"] + "_*") for a in uwp_app_dict[newer_uwp_app["FileName"]]["Dependencies"]]:
        for f in l:
            if not isfile(makepath(bins_dir, f)):
                shutil.move(f, bins_dir)

    # Removing remaining files ["appxbundle", "msixbundle", "appx", "msix]
    for f in glob.glob("*.appxbundle") + glob.glob("*.msixbundle") + glob.glob("*.appx") + glob.glob("*.msix"):
        remove_file(f)

    # No dependencies since it will be contained
    control.depends = ""
    control.save_control_to_wapt()

    # Applying or asking control information if needed
    control.architecture = get_uwp_filename_arch(newer_uwp_app["FileName"], appx_package_name)
    control.min_os_version = newer_uwp_app["MinVersion"]
    if (
        control.max_os_version
        and Version(newer_uwp_app["MinVersion"], 4) <= Version("10.0.22000", 4)
        and Version(newer_uwp_app["MaxVersionTested"], 4) <= Version("10.0.22000", 4)
    ):
        control.max_os_version = newer_uwp_app["MaxVersionTested"]
    else:
        control.max_os_version = ""
    ask_control_categories()
    ask_control_package(package_name, "template-microsoft-store", remove_base_files=True)
    ask_control_name(software_name, "Template Microsoft Store")
    ask_control_description("update_package")

    # Changing setup.py appx_package_name variable
    new_lines = []
    with open("setup.py", "r", encoding="utf8") as f:
        for line in f.readlines():
            if line.startswith("appx_package_name"):
                line = 'appx_package_name = "%s"\n' % appx_package_name
            new_lines.append(line)
    with open("setup.py", "w", encoding="utf8") as f:
        f.writelines(new_lines)

    # Changing version of the package
    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()

    # Validating or not update-package-sources
    return package_updated


def make_uwp_app_dict(appx_package_name):
    import xmltodict

    ms_app_db = {}
    # for ms_app_file in (
    #     glob.glob("*.appxbundle")
    #     + glob.glob("*.msixbundle")
    #     + glob.glob("*.appx")
    #     + glob.glob("*.msix")
    # ):
    for ms_app_file in (
        glob.glob(f"{appx_package_name}*.appxbundle")
        + glob.glob(f"{appx_package_name}*.msixbundle")
        + glob.glob(f"{appx_package_name}*.appx")
        + glob.glob(f"{appx_package_name}*.msix")
    ):
        manifest = unzip(ms_app_file, ".", "AppxManifest.xml", False)
        bundle_manifest = unzip(ms_app_file, ".", "AppxMetadata\AppxBundleManifest.xml", False)
        if not manifest:
            before_dependencies = []
            if bundle_manifest:
                with open(bundle_manifest[0], encoding="utf8") as xml_file:
                    data_dict = xmltodict.parse(xml_file.read(), attr_prefix="")
                ms_app_info = {
                    "FileName": ms_app_file,
                    "Name": data_dict["Bundle"]["Identity"]["Name"],
                    "Version": data_dict["Bundle"]["Identity"]["Version"],
                }

                for app_pkg in data_dict["Bundle"]["Packages"]["Package"]:
                    if app_pkg["Type"] == "application":
                        if not "b4:Dependencies" in app_pkg:
                            ms_app_info.update({"TargetDeviceFamily": None})
                            before_dependency_info = {
                                "FileName": app_pkg["FileName"],
                                "Version": app_pkg["Version"],
                                "Architecture": app_pkg["Architecture"],
                                # "MinVersion": app_pkg["b4:Dependencies"]["b4:TargetDeviceFamily"]["MinVersion"],
                                # "MaxVersionTested": app_pkg["b4:Dependencies"]["b4:TargetDeviceFamily"]["MaxVersionTested"],
                            }
                            before_dependencies.append(before_dependency_info)
                            # ms_app_info.update(
                            #     {"MinVersion": before_dependency_info["MinVersion"], "MaxVersionTested": before_dependency_info["MaxVersionTested"]}
                            # )

                            continue
                        else:
                            if not "b4:TargetDeviceFamily" in app_pkg["b4:Dependencies"]:
                                ms_app_info.update({"TargetDeviceFamily": None})
                                continue
                            else:
                                if type(app_pkg["b4:Dependencies"]["b4:TargetDeviceFamily"]) == list:
                                    if not "Windows.Desktop" in app_pkg["b4:Dependencies"]["b4:TargetDeviceFamily"]:
                                        ms_app_info.update(
                                            {
                                                "TargetDeviceFamily": app_pkg["b4:Dependencies"]["b4:TargetDeviceFamily"][0]["Name"],
                                                "MinVersion": app_pkg["b4:Dependencies"]["b4:TargetDeviceFamily"][0]["MinVersion"],
                                                "MaxVersionTested": app_pkg["b4:Dependencies"]["b4:TargetDeviceFamily"][0]["MaxVersionTested"],
                                            }
                                        )
                                        continue
                                    else:
                                        app_pkg["b4:Dependencies"]["b4:TargetDeviceFamily"] = [
                                            a for a in app_pkg["b4:Dependencies"]["b4:TargetDeviceFamily"] if a["Name"] == "Windows.Desktop"
                                        ][0]
                                        ms_app_info.update(
                                            {
                                                "TargetDeviceFamily": before_dependency_info["TargetDeviceFamily"]["Name"],
                                                "MinVersion": before_dependency_info["MinVersion"],
                                                "MaxVersionTested": before_dependency_info["MaxVersionTested"],
                                            }
                                        )

                            before_dependency_info = {
                                "FileName": app_pkg["FileName"],
                                "Version": app_pkg["Version"],
                                "Architecture": app_pkg["Architecture"],
                                "TargetDeviceFamily": app_pkg["b4:Dependencies"]["b4:TargetDeviceFamily"]["Name"],
                                "MinVersion": app_pkg["b4:Dependencies"]["b4:TargetDeviceFamily"]["MinVersion"],
                                "MaxVersionTested": app_pkg["b4:Dependencies"]["b4:TargetDeviceFamily"]["MaxVersionTested"],
                            }
                            before_dependencies.append(before_dependency_info)
                            ms_app_info.update(
                                {
                                    "TargetDeviceFamily": before_dependency_info["TargetDeviceFamily"],
                                    "MinVersion": before_dependency_info["MinVersion"],
                                    "MaxVersionTested": before_dependency_info["MaxVersionTested"],
                                }
                            )

                if before_dependencies:
                    for dependency in before_dependencies:
                        unzip(
                            ms_app_file,
                            ".",
                            makepath(
                                dependency["FileName"],
                            ),
                            False,
                        )
                        manifest = unzip(dependency["FileName"], ".", makepath("AppxManifest.xml"), False)
                        if isfile(dependency["FileName"]):
                            remove_file(dependency["FileName"])
                        with open(manifest[0], encoding="utf8") as xml_file:
                            dependency_data_dict = xmltodict.parse(xml_file.read(), attr_prefix="")

                    sub_dependencies = []
                    for sub_app_pkg in dependency_data_dict["Package"]["Dependencies"]["PackageDependency"]:
                        sub_dependency_info = {
                            "Name": sub_app_pkg["Name"],
                            "MinVersion": sub_app_pkg["MinVersion"],
                        }
                        sub_dependencies.append(sub_dependency_info)

                    ms_app_info["b4:Dependencies"] = before_dependencies
                    ms_app_info["Dependencies"] = sub_dependencies
                    ms_app_info.update(
                        {
                            "TargetDeviceFamily": dependency_data_dict["Package"]["Dependencies"]["TargetDeviceFamily"]["Name"],
                            "MinVersion": dependency_data_dict["Package"]["Dependencies"]["TargetDeviceFamily"]["MinVersion"],
                            "MaxVersionTested": dependency_data_dict["Package"]["Dependencies"]["TargetDeviceFamily"]["MaxVersionTested"],
                        }
                    )
                ms_app_db[ms_app_file] = ms_app_info
            else:
                error("nothing to parse")
        else:
            manifest = unzip(ms_app_file, ".", makepath("AppxManifest.xml"), False)
            with open(manifest[0], encoding="utf8") as xml_file:
                simple_data_dict = xmltodict.parse(xml_file.read(), attr_prefix="")

            simple_dependencies = []

            for key, value in simple_data_dict["Package"]["Dependencies"].items():
                if key == "PackageDependency":
                    for simple_dependency in value:
                        simple_dependency_info = {
                            "Name": simple_dependency["Name"],
                            "MinVersion": simple_dependency["MinVersion"],
                        }
                        simple_dependencies.append(simple_dependency_info)
                if key == "TargetDeviceFamily":
                    simple_ms_app_info = {
                        "FileName": ms_app_file,
                        "Name": simple_data_dict["Package"]["Identity"]["Name"],
                        "Version": simple_data_dict["Package"]["Identity"]["Version"],
                        "Architecture": simple_data_dict["Package"]["Identity"]["ProcessorArchitecture"],
                        "TargetDeviceFamily": value["Name"],
                        "MinVersion": value["MinVersion"],
                        "MaxVersionTested": value["MaxVersionTested"],
                    }

            simple_ms_app_info["Dependencies"] = simple_dependencies
            ms_app_db[ms_app_file] = simple_ms_app_info

        for xml_file in glob.glob("AppxManifest.xml") + glob.glob("AppxBundleManifest.xml"):
            remove_file(xml_file)

    return ms_app_db


def get_uwp_filename_arch(appx_filename, appx_package_name=None):
    if not appx_package_name:
        appx_package_name = None
    if "arm64" in appx_filename:
        return "arm64"
    elif "arm" in appx_filename:
        return "arm"
    elif "x64" in appx_filename:
        return "x64"
    if appx_filename is not None and "x86" in appx_filename and (appx_package_name is None or not appx_package_name in appx_filename):
        return "x86"
    else:
        return "all"


def ask_control_description(blank_str=None):
    """Requesting that the user supply package description for the control.description field

    Args:
        blank_str   (str): The description will be cleared if it includes the specified string to avoid using the template description (default: do not clear description)
    """
    if not control.description:
        control.description = waptguihelper.input_dialog("Description", "Please fill the description", control.description)
        control.save_control_to_wapt()
    if blank_str is not None and blank_str in control.description:
        control.description = ""
        control.save_control_to_wapt()
    return control.description


def ask_control_categories():
    """Requesting that the user supply package categories for the control.categories field if empty or Template is selected"""

    if control.categories == "" or control.categories == "Template":
        categories = waptguihelper.grid_dialog(
            "Select package categories",
            [
                "Internet",
                "Utilities",
                "Messaging",
                "Security",
                "System and network",
                "Media",
                "Development",
                "Office",
                "Drivers",
                "Education",
                "Configuration",
                "CAD",
                "Template",
                "Dependency",
                "Extension",
            ],
            waptguihelper.GRT_SELECTED,
        )
        if categories:
            control.categories = ",".join([a["unknown"] for a in categories])
        else:
            control.categories = ""
        control.save_control_to_wapt()
    return control.categories


def ask_control_package(control_package=control.package, conditionnal_package_name=None, remove_base_files=False):
    """Requesting that the user provide a package name to be entered into the control.package field, and offering the possibility of removing the base files (icon.png and changelog.txt) for template package usage

    Args:
        control_package             (str)   : prefilled control_package (default: actual control_package)
        conditionnal_package_name   (str)   : only ask when the control.package contains conditionnal_package_name (default: always ask for control_package)
        remove_base_files           (bool)  : removes base files if parameter is True and conditionnal_package_name is provided (default: False)
    """
    if conditionnal_package_name is None or conditionnal_package_name in control.package:
        control.package = waptguihelper.input_dialog(
            control.package,
            "You can redefine the package name",
            control_package.replace(conditionnal_package_name, "") if conditionnal_package_name is not None else control_package,
        )
        control.save_control_to_wapt()

    # Removing template files
    if conditionnal_package_name in control.package and remove_base_files:
        if isfile("WAPT\\changelog.txt"):
            remove_file("WAPT\\changelog.txt")
        if isfile("WAPT\\icon.png"):
            remove_file("WAPT\\icon.png")
    return control.package


def ask_control_name(control_name=control.name, conditionnal_package_name=None):
    """Requesting that the user provide a package name to be entered into control.name field

    Args:
        control_name                (str)   : prefilled control_name (default: control.name)
        conditionnal_package_name   (str)   : only ask when the control.name contains conditionnal_package_name (default: always ask for control_name)
    """
    if conditionnal_package_name is None or conditionnal_package_name in control.name:
        control.name = waptguihelper.input_dialog(control.name, "You can redefine the name for the self-service", control_name)
        control.save_control_to_wapt()
    return control.name