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

def host_as_nvidia_gpu():
    wmi = wmi_info(keys=['Win32_VideoController'])
    gpu = wmi['Win32_VideoController']

    if isinstance(gpu, dict):
        if 'NVIDIA' in gpu['Name']:
            return True

    if isinstance(gpu, list):
        for v in gpu:
            if 'NVIDIA' in v['Name']:
                return True
            
    return False

def install():
    # Declaring local variables
    bin_name = glob.glob("*.exe")[0]
    driver_path = makepath(systemdrive, 'NVIDIA')

    if not host_as_nvidia_gpu():
        error("The current computer doesn't have a nvidia GPU !")

    print("Extracting: " + bin_name)
    unzip_with_7zip(bin_name, driver_path)
    remove_file(bin_name)

    # Installing the software
    print("Installing: %s" % bin_name)

    install_exe_if_needed(
        makepath(driver_path, "setup.exe"),
        silentflags="-s -clean -noreboot -noeula",
        key="{B2FE1952-0186-46C3-BAEC-A80AA35AC5B8}_Display.Driver",
        min_version=control.get_software_version(),
        timeout=900,
    )

    print("Deletion of the driver folder")
    remove_tree(driver_path)

    del uninstallkey[:] # Clear uninstallkey list

def uninstall():
    print(f'Uninstallation of {control.asrequirement()}')

    nvidia_display_nvx_files = glob.glob('C:\\Program Files\\NVIDIA Corporation\\Installer2\\**\\DisplayDriver.NVX')
    for nvx_f in nvidia_display_nvx_files:
        with open(nvx_f) as f:
            data = f.read()
        data = data.replace('uninstallReboot="true"', 'uninstallReboot="false"')
        with open(nvx_f, 'w') as f:
            f.write(data)
    
    driversToUninstall = ["Display.Driver","HDAudio.Driver"]
    for driver in driversToUninstall:
        run(f"C:\\Windows\\SysWOW64\\RunDll32.EXE 'C:\\Program Files\\NVIDIA Corporation\\Installer2\\InstallerCore\\NVI2.DLL',UninstallPackage {driver} -silent")
                                

# -*- coding: utf-8 -*-
from typing import Union
from urllib.parse import urlparse, parse_qs
from setupdevhelpers import *
from setuphelpers import *
import xml.etree.ElementTree as ET
import waptguihelper
import waptlicences
import re

def get_lang():
    lang_dict = {
        "en-us": 1,
        "en-uk": 2,
        "en-in": 3,
        "de": 9,
        "es": 10,
        "fr": 12,
        "it": 13,
        "pl": 14,
        "pt": 15,
        "ru": 16,
    }
    lang_list = []
    for entry in lang_dict:
        lang_list.append({"Value": lang_dict[entry], "Short Name": entry})

    # Changing locale of the package
    return waptguihelper.grid_dialog("Select a language (Please select only one)", lang_list, waptguihelper.GRT_SELECTED)[0]

def get_whql():
    whql_dict = {
        "Recommended/Certified": 1,
        "Beta": 0,
        "All": '',
    }
    whql_list = []
    for entry in whql_dict:
        whql_list.append({"Value": whql_dict[entry], "Type": entry})

    # Changing locale of the package
    return waptguihelper.grid_dialog("Select a type of driver (Please select only one)", whql_list, waptguihelper.GRT_SELECTED)[0]['Value']

def xml_to_dict(xml_data: str):

    # Parse XML data
    root = ET.fromstring(xml_data)

    package_updated = []
    for lookup_value in root.findall('.//LookupValue'):
        name = lookup_value.find('Name').text
        value = int(lookup_value.find('Value').text)
        package_updated.append({'Value': value, 'Name': name})

    return package_updated

def api_lookup_value_search(type_id: Union[str, int], parent_id: Union[str, int] = None):
    url = f"https://www.nvidia.fr/Download/API/lookupValueSearch.aspx?TypeID={type_id}"

    if parent_id is not None:
        url += f"&ParentID={parent_id}"

    headers = {
        'Content-Type': 'text/xml; charset=utf-8'
    }

    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.content
    except requests.HTTPError as e:
        print(f"An error occurred: {e}")
        return None

def get_product_type():
    return xml_to_dict(api_lookup_value_search(type_id=1))

def get_product_series(id_product: Union[str, int]):
    return xml_to_dict(api_lookup_value_search(type_id=2, parent_id=id_product))

def get_product(id_product: Union[str, int]):
    return xml_to_dict(api_lookup_value_search(type_id=3, parent_id=id_product))

def get_operating_system(id_product: Union[str, int]):
    return xml_to_dict(api_lookup_value_search(type_id=4, parent_id=id_product))

def make_download_url():
    
    product_type = waptguihelper.grid_dialog("Product Type (Please select only one)", get_product_type(), waptguihelper.GRT_SELECTED)[0]['Value']
    product_series = waptguihelper.grid_dialog("Product Series (Please select only one)", get_product_series(product_type), waptguihelper.GRT_SELECTED)[0]['Value']
    product = waptguihelper.grid_dialog("Product (Please select only one)", get_product(product_series), waptguihelper.GRT_SELECTED)[0]
    operating_sys = waptguihelper.grid_dialog("Operating System (Please select only one)", get_operating_system(product_series), waptguihelper.GRT_SELECTED)[0]
    lang = get_lang()
    whql = get_whql()

    # Hardcoded on nvidia website ...
    windows_list = ['Windows 10 64-bit', 'Windows Server 2022', 'Windows Server 2019', 'Windows Server 2016', 'Windows 11']
    product_type_list = [1, 3, 7, 11]

    dtcid = 1 if (operating_sys['Name'] in windows_list) and (product_type in product_type_list) else 0

    url_version = f"https://www.nvidia.fr/Download/processFind.aspx?psid={product_series}&pfid={product['Value']}&osid={operating_sys['Value']}" \
                  f"&lid={lang['Value']}&whql={whql}&lang={lang['Short Name']}&ctk=0&qnfslb=00&dtcid={dtcid}"
    
    return url_version

def update_package():
    # Declaring local variables
    package_updated = False
    proxies = get_proxies_from_wapt_console()
    if not proxies:
        proxies = get_proxies()
    app_name = control.name

    if not control.sources:
        control.sources = make_download_url()
        control.save_control_to_wapt()

        complete_control_package(control)
        complete_control_name(control)

        # User not modify the package name
        if "template" in control.package:
            error("Please rename the package.")

    url_version = control.sources

    # Getting latest version
    print("URL used is: %s" % url_version)
    download_redirect = ''
    for bs_search in bs_find_all(url_version, "tr", "id", "driverList", proxies=proxies, timeout=10):
        version_driver = bs_search.find_all('td')[2]
        version = re.search(r'(\d+(?:\.\d+)+)', version_driver.text).group(1)
        download_redirect = "https:" + bs_search.find('a').get('href')
        break
    
    if not download_redirect:
        print("No nvidia driver version was found with these settings! Relaunch the update package with different settings")
        control.sources = ""
        control.save_control_to_wapt()
        return package_updated

    button_href = bs_find(download_redirect, "btn_drvr_lnk_txt", proxies=proxies, timeout=10).find_parent('a').get('href')
    parsed_url = urlparse(button_href)
    query_params = parse_qs(parsed_url.query)
    path_download_url = query_params.get('url')[0]

    download_url = f"https://fr.download.nvidia.com{path_download_url}"
    latest_bin = download_url.split('/')[-1]

    print(f"Latest {app_name} version is: {version}")
    print(f"Download URL is: {download_url}")

    # Downloading latest binaries
    if not isfile(latest_bin):
        print(f"Downloading: {latest_bin}")
        wget(download_url, latest_bin, proxies=proxies)
    else:
        print(f"Binary is present: {latest_bin}")

    # Deleting outdated binaries
    for f in glob.glob('*.exe'):
        if f != latest_bin:
            remove_file(f)

    expected_issuer = 'NVIDIA Corporation'
    sign_name = waptlicences.check_exe_signing_certificate(latest_bin)[0]
    if sign_name != expected_issuer:
        error(f'Bad issuer {sign_name} != {expected_issuer} ')

    # Changing version of the package
    if Version(version) > Version(control.get_software_version()):
        print(f"Software version updated (from: {control.get_software_version()} to: {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()

    return package_updated