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

json_source = "cpu_w11.json"
result_dict = {}

def install():
    print("Copying: %s to: %s" % (json_source, persistent_dir))
    filecopyto(json_source, persistent_dir)

def audit():

    audit_status = "OK"

    audit_status = set_audit_status(audit_status,check_tpm_state())
    audit_status = set_audit_status(audit_status,check_free_space())
    audit_status = set_audit_status(audit_status,check_free_space_efi())
    audit_status = set_audit_status(audit_status,check_memory_space())
    audit_status = set_audit_status(audit_status,is_secure_boot_capable())
    audit_status = set_audit_status(audit_status,check_CPU_compatibility())

    if audit_status == "OK":
        result = "CAPABLE"
        WAPT.write_audit_data_if_changed("w11-requirements", "result", result)
        WAPT.write_audit_data_if_changed("w11-requirements", "audit_data", result_dict)
    else:
        result = "NOT CAPABLE"
        WAPT.write_audit_data_if_changed("w11-requirements", "result", result)
        WAPT.write_audit_data_if_changed("w11-requirements", "audit_data", result_dict)

    return audit_status

def check_tpm_state():

    dict_tpm = {}
    audit_tpm = "OK"
    get_tpm = run_powershell("Get-Tpm")

    if get_tpm["TpmPresent"] == False:
        print("ERROR: No TPM chip found on this system")
        audit_tpm = "ERROR"
        dict_tpm['TpmVersion'] = audit_tpm

    else:
        get_tpm_version = run_powershell("Get-WmiObject -Class Win32_Tpm -Namespace root\CIMV2\Security\MicrosoftTpm | Select-Object -Property SpecVersion")
        tpm_version = get_tpm_version["SpecVersion"].split(",")[0]
        if tpm_version != "2.0":
            print("ERROR: TPM chip not in version 2.0")
            audit_tpm = "ERROR"
            dict_tpm['TpmVersion'] = audit_tpm
        else:
            print("OK: TPM chip in version 2.0")
            audit_tpm = "OK"
            dict_tpm['TpmVersion'] = audit_tpm

    result_dict['TPM'] = dict_tpm
    return audit_tpm

def check_free_space():

    dict_disk = {}
    audit_disk = "OK"

    free_space = get_disk_free_space(systemdrive)
    free_space_GB = round(free_space / (1024**3),2)

    if free_space_GB <= 64:
        need_free = round((64 - free_space_GB),2)
        print("ERROR: Not enough space disk available")
        print(f'Need 64 GB, currently available {free_space_GB} GB')
        print(f'Need to free up {need_free} GB')
        audit_disk = "ERROR"
        dict_disk['Space Available'] = audit_disk
    else:
        print("OK: Enough space disk available")
        audit_disk = "OK"
        dict_disk['Space Available'] = audit_disk

    result_dict['Disk'] = dict_disk
    return audit_disk

def check_free_space_efi():

    dict_uefi = {}
    audit_efi = "OK"
    audit_space_efi = "OK"

    #{6F8CFC1A-0000-0000-0000-100000000000} - BIOS GUID
    #{c12a7328-f81f-11d2-ba4b-00a0c93ec93b} - UEFI GUID

    size_remaining = run_powershell("Get-Volume -UniqueId \"\\\\?\\Volume$(((Get-Partition).Where{$_.GptType -eq '{c12a7328-f81f-11d2-ba4b-00a0c93ec93b}'}.Guid))\\\" | Select-Object SizeRemaining")

    if size_remaining is None:
        print("ERROR: No EFI partition, check BIOS configuration")
        audit_efi = "ERROR"
        result_dict['UEFI - Activation'] = audit_efi
    else:
        free_space = size_remaining['SizeRemaining']
        free_space_efi = round(free_space / (1024**2),2)

        if free_space_efi <= 15:
            need_free = round((15 - free_space_efi),2)
            print("ERROR: Not enough space available on EFI Partition")
            print(f'Need 15 MB, currently available {free_space_efi} MB')
            print(f'Need to free up {need_free} MB')
            audit_efi = "OK"
            audit_space_efi = "ERROR"
            dict_uefi['Activation'] = audit_efi
            dict_uefi['Space Available'] = audit_space_efi
            result_dict['UEFI'] = dict_uefi
        else:
            print("OK: Enough space available on EFI Partition")
            print(f"{free_space_efi} MB available")
            audit_efi = "OK"
            audit_space_efi = "OK"
            dict_uefi['Activation'] = audit_efi
            dict_uefi['Space Available'] = audit_space_efi
            result_dict['UEFI'] = dict_uefi

    return audit_efi

def check_memory_space():

    dict_ram = {}
    audit_memory = "OK"

    total_memory = ceil(memory_status().ullTotalPhys / (1024**3))

    if total_memory < 4:
        print("ERROR: Not enough memory available")
        print(f'Need 4 GB of memory, currently {total_memory} GB')
        audit_memory = "ERROR"
        dict_ram['Total Memory'] = audit_memory
    else:
        print("OK: Enough memory available")
        audit_memory = "OK"
        dict_ram['Total Memory'] = audit_memory

    result_dict['RAM'] = dict_ram
    return audit_memory

def is_secure_boot_capable():

    dict_SB = {}
    audit_SB = "OK"

    try:
        secureboot_state = run_powershell("Confirm-SecureBootUEFI")
    except:
        print("SecureBoot not available")
        audit_SB = "ERROR"
        result_dict['SecureBoot'] = audit_SB
        return audit_SB

    # Check the value of the SecureBootEnabled property
    if secureboot_state == False:
        print("OK: SecureBoot is available and not enabled")
        audit_SB = "OK"
        result_dict['SecureBoot'] = audit_SB
    else:
        print("OK: SecureBoot is available and enabled")
        audit_SB = "OK"
        result_dict['SecureBoot'] = audit_SB

    return audit_SB

def check_CPU_compatibility():

    dict_cpu = {}
    audit_cpu_comp = "OK"

    wmi = wmi_info(keys=['Win32_Processor'])['Win32_Processor']

    if isinstance(wmi,list):
        wmi = wmi[0]

    cores = wmi['NumberOfCores']
    max_clock_speed = wmi['MaxClockSpeed']
    max_clock_speed_GHz = round(max_clock_speed / (1024),2)
    cpu_name = wmi['Name']
    cpu_manufacturer = wmi['Manufacturer'].lower()

    if 'amd' in cpu_manufacturer:
        cpu_manufacturer = 'amd'
    elif 'intel' in cpu_manufacturer:
        cpu_manufacturer = 'intel'
    elif 'qualcomm' in cpu_manufacturer:
        cpu_manufacturer = 'qualcomm'

    json_file = makepath(persistent_dir, json_source)
    with open(json_file) as f:
        data = json.load(f)

    cpu_compatible = False
    for cpu in data[cpu_manufacturer]:
        if cpu in cpu_name:
            cpu_compatible = True
            break

    if cpu_compatible:
        print(f"OK: Your processor {cpu_name} is compatible")
        audit_cpu = "OK"
        dict_cpu['Model'] = audit_cpu
        audit_cpu_comp = set_audit_status(audit_cpu_comp, audit_cpu)
    else:
        print(f"ERROR: Your processor {cpu_name} is not compatible")
        audit_cpu = "ERROR"
        dict_cpu['Model'] = audit_cpu
        audit_cpu_comp = set_audit_status(audit_cpu_comp, audit_cpu)

    if cores < 2:
        print(f"ERROR: Need 2 cores minimum, currently {cores} cores on your CPU")
        audit_cores = "ERROR"
        dict_cpu['Cores'] = audit_cores
        audit_cpu_comp = set_audit_status(audit_cpu_comp, audit_cores)
    else:
        print(f"OK: Currently {cores} cores on your CPU")
        audit_cores = "OK"
        dict_cpu['Cores'] = audit_cores
        audit_cpu_comp = set_audit_status(audit_cpu_comp, audit_cores)

    if max_clock_speed < 1000:
        print(f"ERROR: Frequency under 1GHz, currently {max_clock_speed_GHz}GHz")
        audit_clock = "ERROR"
        dict_cpu['Frequency'] = audit_clock
        audit_cpu_comp = set_audit_status(audit_cpu_comp, audit_clock)
    else:
        print(f"OK: Currently {max_clock_speed_GHz}GHz")
        audit_clock = "OK"
        dict_cpu['Frequency'] = audit_clock
        audit_cpu_comp = set_audit_status(audit_cpu_comp, audit_clock)

    result_dict['CPU'] = dict_cpu
    return audit_cpu_comp

def set_audit_status(old_audit_status, new_audit_status):
    """Maintain higher criticality for audit status."""
    audit_level = {"OK": 0, "WARNING": 1, "ERROR": 2}

    old_status = old_audit_status.upper().strip()
    new_status = new_audit_status.upper().strip()

    if audit_level.get(new_status, -1) > audit_level.get(old_status, -1):
        return new_status
    else:
        return old_audit_status

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


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

    json_file = "cpu_w11.json"

    base_url = 'https://learn.microsoft.com/fr-fr/windows-hardware/design/minimum/supported'

    brand_proco_url = [
        'windows-11-24h2-supported-amd-processors',
        'windows-11-24h2-supported-intel-processors',
        'windows-11-24h2-supported-qualcomm-processors'
    ]

    url_list = [ f"{base_url}/{brand}" for brand in brand_proco_url ]

    updated_date = None
    for url in url_list:
        date = bs_find(url, "meta", "name", "updated_at", proxies=proxies).get('content', '')
        date_to_version = date.split(' ', 1)[0].replace('-', '.')
        if updated_date or Version(date_to_version) > Version(updated_date):
            updated_date = date_to_version

    print(f"Latest version found for Windows 11 supported processors is {updated_date}")

    if Version(updated_date) > Version(control.get_software_version()):
        print("Update available for Windows 11 supported processors. Updating...")
        update_windows11_proco_requirements(url_list, json_file)
        package_updated = True
    else:
        print("No update available for Windows 11 supported processors.")

    control.set_software_version(updated_date)
    control.save_control_to_wapt()

    return package_updated


def update_windows11_proco_requirements(url_list, filename):

    def table_to_list(table):
        result = []
        for row in table.find_all('tr')[1:]:
            result.append(" ".join((row.find_all('td')[2].text).split()))
        return result

    proco_dict = dict()
    for url in url_list:
        cpu_manufacturer = url.rsplit('/')[-1].split('-')[-2]
        proco_dict[cpu_manufacturer] = table_to_list(bs_find(url, 'table'))

    with open(filename, 'w') as f:
        json.dump(proco_dict, f, indent=4)