# -*- coding: utf-8 -*-
from setuphelpers import *
import platform
import bs4 as BeautifulSoup
import requests
import json


r"""
Usable WAPT package functions: install(), uninstall(), session_setup(), audit(), update_package()

[Others]
INI_Folder=%APPDATA%\IrfanView

[Language]
DLL=FRENCH1.DLL
Lang=Francais


"""
# Declaring global variables - Warnings: 1) WAPT context is only available in package functions; 2) Global variables are not persistent between calls
bin_lang_contains = "irfanview_lang_"
app_dir = makepath(programfiles, "IrfanView")


def install():
    # Declaring local variables
    package_version = control.version.split("-")[0]
    if control.architecture == "x64":
        ini_file = "i_view64.ini"
        app_uninstallkey = "IrfanView64"
    else:
        ini_file = "i_view32.ini"
        app_uninstallkey = "IrfanView"

    # getting binaries names
    binaries = glob.glob("*.exe")
    for binary in binaries:
        if "plugin" in binary.lower():
            plugin_binary = binary
        else:
            install_binary = binary

    # Installing the software
    print("Installing: %s" % install_binary)
    install_exe_if_needed(
        install_binary,
        #'/silent thumbs=0 /group=1 /allusers=1 /assoc=0 /assocallusers /ini="%s"' % app_dir,
        "/silent thumbs=0 /group=1 /allusers=1 /assoc=0 /assocallusers",
        key=app_uninstallkey,
        min_version=package_version,
    )

    # Adding QuietUninstallString for app
    quiet_uninstall_string = installed_softwares(uninstallkey=app_uninstallkey)[0]["uninstall_string"] + " /silent"
    register_uninstall(app_uninstallkey, quiet_uninstall_string=quiet_uninstall_string, win64app=iswin64())

    # Installing plugins
    print("Installing plugins: %s" % plugin_binary)
    install_exe_if_needed(plugin_binary, "/silent")

    # Adding LPs
    if control.locale == "fr":
        bin_lang = glob.glob("*%s*.zip" % bin_lang_contains)[0]
        print("Installing %s" % bin_lang)
        unzip(bin_lang, makepath(app_dir, "Languages"))

    # Writting global conf file
    app_conf_path = makepath(app_dir, ini_file)
    if isfile(app_conf_path):
        remove_file(app_conf_path)
    inifile_writestring(app_conf_path, "Others", "INI_Folder", r"%APPDATA%\IrfanView")


def session_setup():
    if is64:
        ini_file = "i_view64.ini"
    else:
        ini_file = "i_view32.ini"
    app_name = "IrfanView"
    user_app_conf_dir = makepath(user_appdata, "IrfanView")
    user_app_conf_path = makepath(user_app_conf_dir, ini_file)
    registry_readstring(HKEY_CURRENT_USER, r"SOFTWARE\WAPT\%s" % app_name, "ApplyLocaleOnce")

    if get_language() == "fr":
        if not registry_readstring(HKEY_CURRENT_USER, r"SOFTWARE\WAPT\%s" % app_name, "ApplyLocaleOnce") or force:
            if not isdir(user_app_conf_dir):
                mkdirs(user_app_conf_dir)
            if isfile(user_app_conf_path):
                remove_file(user_app_conf_path)
            inifile_writestring(user_app_conf_path, "Language", "DLL", "FRENCH1.DLL")
            inifile_writestring(user_app_conf_path, "Language", "Lang", "Francais")
            registry_setstring(HKEY_CURRENT_USER, r"SOFTWARE\WAPT\%s" % app_name, "ApplyLocaleOnce", "Done")


def update_package():
    # Declaring local variables
    result = False
    language = control.locale
    app_name = control.name
    arch = control.architecture
    if arch == "x64":
        arch = "_x64"
        arch_dl = "64"

    else:
        arch = ""
        arch_dl = "32"
    url = "https://www.fosshub.com/IrfanView.html"

    # Getting proxy informations from WAPT settings
    proxies = get_proxies()
    if not proxies:
        proxies = get_proxies_from_wapt_console()
    app_name = control.name
    version = bs_find(
        url,
        "dd",
        "itemprop",
        "softwareVersion",
        proxies=proxies,
    ).text
    dotless_version = version.replace(".", "")

    # FOSSHUB function
    bin_url_dl = get_download_url_from_fosshub(url, file_type="%s-bit Windows Installer" % arch_dl, proxies=proxies)
    plugin_url_dl = get_download_url_from_fosshub(url, file_type="All Plugins - %s-bit Windows Installer" % arch_dl, proxies=proxies)

    latest_bin = bin_url_dl.split("/")[-1]
    latest_plugin = plugin_url_dl.split("/")[-1]
    print("Latest %s version is: %s" % (app_name, version))
    print("Download url is: %s" % bin_url_dl)

    # Downloading latest binaries
    if not isfile(latest_bin):
        print("Downloading: %s" % latest_bin)
        wget(bin_url_dl, latest_bin, proxies=proxies)

        # Downloading plugins
        if not isfile(latest_plugin):
            print("Downloading: %s" % latest_plugin)
            wget(plugin_url_dl, latest_plugin, proxies=proxies)

        # Checking version from file
        version_from_file = get_version_from_binary(latest_bin)
        if not version_from_file.startswith(version) and version_from_file != "":
            print("Changing version to the version number of the binary")
            os.rename(latest_bin, "iview" + arch + "-" + version_from_file + "_setup.exe")
            os.rename(latest_plugin, "iview" + arch + "-" + version_from_file + "_all_plugins_setup.exe")
            version = version_from_file
            dotless_version = version_from_file.replace(".", "")
        else:
            print("Binary file version corresponds to online version")

    # 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)))
        result = True
    else:
        print("Software version up-to-date (%s)" % Version(version))
    control.version = "%s-%s" % (Version(version), control.version.split("-", 1)[-1])
    # control.set_software_version(version)
    control.save_control_to_wapt()

    # Deleting outdated binaries
    remove_outdated_binaries(dotless_version)

    # Downloading language
    if language == "fr":
        lang_installer_url = "https://www.irfanview.net/lang/irfanview_lang_french.zip"
        lang_installer = lang_installer_url.rsplit("/", 1)[1]
        wget(lang_installer_url, lang_installer, proxies=proxies)

    # Validating or not update-package-sources
    return result


def get_download_url_from_fosshub(url, file_type="64-bit Windows Installer", proxies=None):
    url_api_fosshub = "https://university.fosshub.com/projects.json"

    for script in bs_find_all(
        url, "script", proxies=proxies, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Firefox/78.0"}
    ):
        if (len(script.contents) >= 1) and ("var settings" in script.contents[0]):
            var_settings = script.contents[0].replace("\n  var settings =", "").replace("\n", "")
            break

    for readapifosshub in json.loads(wgets(url_api_fosshub, proxies=proxies))["projects"]:
        if readapifosshub["url"].endswith(url.split("//")[-1]):
            for filename in readapifosshub["files"]:
                if filename["type"] == file_type:
                    file_name = filename["name"]

    settings = json.loads(var_settings)

    apiUrl = "https://api." + settings["domain"]
    downloadUrl = apiUrl + "/download/"

    def forming_fosshub_url(a, b, c, d, e):
        params = {"projectId": a, "releaseId": b, "projectUri": c, "fileName": d, "source": e}
        r = requests.post(downloadUrl, data=params)
        return r

    pool = settings["pool"]
    f = pool["f"]

    for c in f:
        r = forming_fosshub_url(pool["p"], c["r"], pool["u"], file_name, pool["c"])

    r = forming_fosshub_url(pool["p"], c["r"], pool["u"], file_name, pool["c"])
    rj = r.json()
    return rj["data"]["url"]


def get_version_from_binary(filename):
    if filename.endswith(".msi"):
        return get_msi_properties(filename)["ProductVersion"]
    else:
        return get_file_properties(filename)["ProductVersion"]


def get_proxies():
    r"""Return system proxy with the urllib python library

    >>> get_proxies()
    {'http': 'http://srvproxy.ad.domain.lan:8080',
    'https': 'http://srvproxy.ad.domain.lan:8080'}

    """
    if platform.python_version_tuple()[0] == "3":
        from urllib.request import getproxies
    else:
        from urllib import getproxies
    return getproxies()


def get_proxies_from_wapt_console():
    r"""Return proxy information from the current user WAPT console

    >>> get_proxies_from_wapt_console()
    {'http': 'http://srvproxy.ad.domain.lan:8080',
    'https': 'http://srvproxy.ad.domain.lan:8080'}

    """
    proxies = {}
    if platform.system() == "Windows":
        waptconsole_ini_path = makepath(user_local_appdata(), "waptconsole", "waptconsole.ini")
    else:
        waptconsole_ini_path = makepath(user_home_directory(), ".config", "waptconsole", "waptconsole.ini")
    if isfile(waptconsole_ini_path):
        proxy_wapt = conf_file_readstring(waptconsole_ini_path, "global", "http_proxy")
        if proxy_wapt:
            proxies = {"http": proxy_wapt, "https": proxy_wapt}
    return proxies


def bs_find_all(url, element, attribute=None, value=None, user_agent=None, proxies=None, features="html.parser", **kwargs):
    r"""Parse html web page with BeautifulSoup and get a list of the result

    Args:
        url (str): url of the web page to parse
        element (str): searched element
        attribute (str): selected attribute of the element
        value (str): value of the selected attribute
        user_agent (str): specify a user-agent if needed
        proxies (dict): specify your proxy if needed
        **kwargs (str): joker for requests parameters
        features (str): bs feature to use


    >>> bs_find_all('https://www.w3.org/', 'a', 'title', 'Open Web Platform testing')[0]['href']
    'https://web-platform-tests.org/'

    >>> bs_find_all('https://www.w3.org/', 'span', 'class', 'alt-logo')[0].string
    'W3C'

    .. versionadded:: 2.0

    """
    if user_agent:
        page = requests.get(url, proxies=proxies, headers={"User-Agent": "%s" % user_agent}, **kwargs).text
    else:
        page = requests.get(url, proxies=proxies, **kwargs).text
    soup = BeautifulSoup.BeautifulSoup(page, features=features)
    if value:
        return soup.find_all(element, {attribute: value})
    else:
        return soup.find_all(element)


def get_version_from_binary(filename, property_name="ProductVersion"):
    r"""Get installer version from file informations, for now, only exe and msi files are compatibles

    Args:
        filename (str): path to the file
        property_name (str): selected property

    Returns:
        str: version number

    """
    if filename.endswith(".msi"):
        return get_msi_properties(filename)[property_name]
    else:
        return get_file_properties(filename)[property_name]


def remove_outdated_binaries(version, list_extensions=["exe", "msi", "deb", "rpm", "dmg", "pkg"], filename_contains=None):
    r"""Remove files based on the version contained in his filename, failing over on file version on compatible OSes

    Args:
        version (str): version number of keeped files
        list_extensions (str or list of str): file extensions of compared files
        filename_contains (str or list of str): Part of the filename that must be contained (useful for distinguishing architecture and os)

    Returns:
        list: list of deleted files

    .. versionadded:: 2.0

    .. versionchanged:: 2.2
        Now returns removed files, now checking .exe and .msi file versions

    """
    files = []
    if type(list_extensions) != list:
        list_extensions = [list_extensions]
    if filename_contains:
        if type(filename_contains) != list:
            filename_contains = [filename_contains]
    list_extensions = ["." + ext for ext in list_extensions if ext[0] != "."]
    for file_ext in list_extensions:
        for bin_in_dir in glob.glob("*%s" % file_ext):
            if not version in bin_in_dir:
                if platform.system() == "Windows":
                    if file_ext == ".exe" or file_ext == ".msi":
                        if Version(version) == Version(get_version_from_binary(bin_in_dir, "FileVersion")) or Version(version) == Version(
                            get_version_from_binary(bin_in_dir, "ProductVersion")
                        ):
                            print("%s file or product version is correct (%s)" % (bin_in_dir, version))
                            continue
                remove_file(bin_in_dir)
                files.append(bin_in_dir)
            if filename_contains:
                for filename_contain in filename_contains:
                    if not filename_contain in bin_in_dir:
                        remove_file(bin_in_dir)
                        files.append(bin_in_dir)
    return [fn for fn in files]