# -*- coding: utf-8 -*-
from setuphelpers import *
import subprocess
import chardet
import re
import json
import time
import sys
import os
import glob
from shutil import rmtree

try:
    import waptguihelper
except:
    pass

ext_uid_name = "MS-CEINTL.vscode-language-pack-fr"
locale_dict = {"locale": "fr"}


def install():
    # Initializing variables
    package_version = control.get_software_version()
    ext_file_name = glob.glob("*%s*.vsix" % ext_uid_name)[0]
    if get_os_name() == "Windows":
        app_dir = makepath(programfiles, "Microsoft VS Code")
        app_bin_path = makepath(app_dir, "bin", "code")
    elif get_os_name() == "Linux":
        app_dir = makepath("/", "usr", "share", "code")
        app_bin_path = makepath(app_dir, "bin", "code")
    elif get_os_name() == "Darwin":
        app_dir = makepath("/", "Applications", "Visual Studio Code.app")
        app_bin_path = makepath(app_dir, "Contents", "Resources", "app", "bin", "code")
    ext_path = makepath(app_dir, ext_file_name)

    # Removing old extensions from app_dir
    for ext in glob.glob(makepath(app_dir, "*%s*.vsix" % ext_uid_name)):
        print("Removing: %s" % ext)
        remove_file(ext)

    # Copying extension to app_dir
    print("Copying: %s to: %s" % (ext_file_name, app_dir))
    filecopyto(ext_file_name, app_dir)


def session_setup():
    # Initializing variables
    package_version = control.get_software_version()
    if get_os_name() == "Windows":
        app_dir = makepath(programfiles, "Microsoft VS Code")
        app_bin_path = makepath(app_dir, "bin", "code")
    elif get_os_name() == "Linux":
        app_dir = makepath("/", "usr", "share", "code")
        app_bin_path = makepath(app_dir, "bin", "code")
    elif get_os_name() == "Darwin":
        app_dir = makepath("/", "Applications", "Visual Studio Code.app")
        app_bin_path = makepath(app_dir, "Contents", "Resources", "app", "bin", "code")
    ext_path = glob.glob(makepath(app_dir, "*%s*.vsix" % ext_uid_name))[0]
    user_app_dir = makepath(user_home_directory, ".vscode")
    user_argv_conf_file = makepath(user_app_dir, "argv.json")

    # Installing extension in user env
    print("Installing: %s extension in user env" % (ext_path))
    result = run_notfatal('"%s" --install-extension "%s"' % (app_bin_path, ext_path))  # code extension always return exit status 0 for now
    print(result)
    if "Failed Installing Extensions" in result:
        print("Unable to install extension with: %s" % ext_path)
        print("Force install: %s extension in user env" % (ext_uid_name))
        result_force = run_notfatal('"%s" --install-extension "%s" --force' % (app_bin_path, ext_uid_name))
        print(result_force)
        if "Failed Installing Extensions" in result_force:
            print("Unable to force install %s extension" % ext_uid_name)

    # Editing argv.json once
    if not registry_readstring(HKEY_CURRENT_USER, r"Software\WAPT\Visual Studio Code", "ApplyLocaleOnce") == "Done" or force:
        mkdirs(user_app_dir)
        if isfile(user_argv_conf_file):
            user_argv_dict = json_load_file_with_comments(user_argv_conf_file)
            user_argv_dict.update(locale_dict)
            json_write_file(user_argv_conf_file, user_argv_dict)
        else:
            json_write_file(user_argv_conf_file, locale_dict)
        registry_setstring(HKEY_CURRENT_USER, r"Software\WAPT\Visual Studio Code", "ApplyLocaleOnce", "Done")

        # Rerun vscode
        if isrunning("code"):
            if "waptguihelper" in sys.modules and not params.get("running_as_luti"):
                waptguihelper.message_dialog(control.package, f"Visual Studio Code will be killed and rerun to apply:{control.name}")
            killalltasks(["Code", "code"])
            subprocess.Popen([app_bin_path if get_os_name() != "Windows" else makepath(app_dir, "Code.exe")])
        else:
            rerun_delay = 10
            if "waptguihelper" in sys.modules and not params.get("running_as_luti"):
                waptguihelper.message_dialog(
                    control.package, f"Visual Studio Code will be launched and killed in {rerun_delay} seconds to apply: {control.name}"
                )
            subprocess.Popen([app_bin_path if get_os_name() != "Windows" else makepath(app_dir, "Code.exe")])
            time.sleep(10)
            killalltasks(["Code", "code"])


def audit():
    # Initializing variables
    package_version = control.get_software_version()
    if get_os_name() == "Windows":
        app_dir = makepath(programfiles, "Microsoft VS Code")
        app_bin_path = makepath(app_dir, "bin", "code")
    elif get_os_name() == "Linux":
        app_dir = makepath("/", "usr", "share", "code")
        app_bin_path = makepath(app_dir, "bin", "code")
    elif get_os_name() == "Darwin":
        app_dir = makepath("/", "Applications", "Visual Studio Code.app")
        app_bin_path = makepath(app_dir, "Contents", "Resources", "app", "bin", "code")

    try:
        ext_path = glob.glob(makepath(app_dir, "*%s*.vsix" % ext_uid_name))[0]
        print("OK: %s extension present" % ext_uid_name)
        return "OK"
    except:
        print("ERROR: %s extension absent" % ext_uid_name)
        return "ERROR"


def uninstall():
    # Initializing variables
    package_version = control.get_software_version()
    if get_os_name() == "Windows":
        app_dir = makepath(programfiles, "Microsoft VS Code")
        app_bin_path = makepath(app_dir, "bin", "code")
    elif get_os_name() == "Linux":
        app_dir = makepath("/", "usr", "share", "code")
        app_bin_path = makepath(app_dir, "bin", "code")
    elif get_os_name() == "Darwin":
        app_dir = makepath("/", "Applications", "Visual Studio Code.app")
        app_bin_path = makepath(app_dir, "Contents", "Resources", "app", "bin", "code")

    # Removing extensions from app_dir
    for ext in glob.glob(makepath(app_dir, "*%s*.vsix" % ext_uid_name)):
        print("Removing: %s" % ext)
        remove_file(ext)

    # Removing extension from user profiles
    killalltasks(["Code", "code"])
    print("Removed user folders: ")
    print(remove_tree_for_all_users(makepath(".vscode", "extensions", "%s-*" % ext_uid_name)))


def json_load_file_with_comments(file_path):
    """
    Load a JSON file with comments removed.

    Args:
        file_path (str): Path to the JSON file.

    Returns:
        dict: JSON data without comments.
    """
    contents = ""
    with open(file_path) as fh:
        for line in fh:
            cleaned_line = line.split("//", 1)[0]
            if len(cleaned_line) > 0 and line.endswith("\n") and "\n" not in cleaned_line:
                cleaned_line += "\n"
            contents += cleaned_line
    while "/*" in contents:
        pre_comment, post_comment = contents.split("/*", 1)
        contents = pre_comment + post_comment.split("*/", 1)[1]

    cleaned_json = json.loads(contents)
    return cleaned_json


def remove_tree_for_all_users(user_folder_relative_path, ignored_users=None, ignore_system_users=True):
    """
    Remove a specific folder or folders for all user profiles.

    Args:
        user_folder_relative_path (str): Relative path to the user folder. Glob patterns can be used.
        ignored_users (str or list of str): Ignore specified users.
        ignore_system_users (bool): Ignore default, public, all users, etc. (True by default).

    Returns:
        list: List of deleted folders.

    >>> print(remove_tree_for_all_users(makepath(".vscode", "extensions", "ms-toolsai.jupyter-*")))
    ['C:\\Users\\username\\.vscode\\extensions\\ms-toolsai.jupyter-2022.2.1001817079', 'C:\\Users\\username\\.vscode\\extensions\\ms-toolsai.jupyter-keymap-1.0.0', 'C:\\Users\\username\\.vscode\\extensions\\ms-toolsai.jupyter-renderers-1.0.6']

    >>> print(remove_tree_for_all_users(makepath(".vscode", "extensions", "ms-toolsai.jupyter-")))
    []

    >>> print(remove_tree_for_all_users(makepath(".vscode", "extensions", "ms-toolsai.jupyter-[a-z]*")))
    ['C:\\Users\\username\\.vscode\\extensions\\ms-toolsai.jupyter-keymap-1.0.0', 'C:\\Users\\username\\.vscode\\extensions\\ms-toolsai.jupyter-renderers-1.0.6']

    >>> print(remove_tree_for_all_users(makepath(".vscode", "extensions", "ms-toolsai.jupyter-1.0.0")))
    ['/home/username/.vscode/extensions/ms-toolsai.jupyter-keymap-1.0.0']

    .. versionadded:: 2.3
    """
    system_users_list = ["All Users", "Default", "Default User", "Public", "Shared"]
    if ignored_users is None:
        ignored_users = []
    if not isinstance(ignored_users, list):
        ignored_users = [ignored_users]

    deleted_folders = []
    skipped_users = []
    if ignored_users:
        skipped_users.extend(ignored_users)
    if ignore_system_users:
        skipped_users.extend(system_users_list)

    users_dir = ""
    if os.name == "nt":
        users_dir = os.path.join(os.environ["SystemDrive"], "Users")
    elif os.name == "posix":
        users_dir = "/home"
    elif os.name == "mac":
        users_dir = "/Users"

    for user_profile in glob.glob(f"{users_dir}/*/"):
        for ignored_user in ignored_users:
            if user_profile.rstrip(os.path.sep).split(os.path.sep)[-1] == ignored_user:
                continue
        for user_folder_to_delete in glob.glob(f"{os.path.join(user_profile, user_folder_relative_path)}"):
            deleted_folders.append(user_folder_to_delete)
            rmtree(user_folder_to_delete)
    return deleted_folders

                                

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

# Declaring global variables - Warnings: 1) WAPT context is only available in package functions; 2) Global variables are not persistent between calls
ext_uid_name = "MS-CEINTL.vscode-language-pack-fr"
ext_publisher = ext_uid_name.split(".")[0]


def update_package():
    # Declaring local variables
    result = False
    proxies = get_proxies()
    if not proxies:
        proxies = get_proxies_from_wapt_console()
    app_name = control.name
    url = "https://marketplace.visualstudio.com/items?itemName=%s" % ext_uid_name

    # Getting latest version from official sources
    api_url = "https://api.github.com/repos/microsoft/vscode/releases/latest"

    # Getting latest version information from official sources
    print("API used is: %s" % api_url)
    json_load = json.loads(wgets(api_url, proxies=proxies))
    vscode_version = json_load["tag_name"]
    short_vscode_version = ".".join(vscode_version.split(".")[:2])
    print("URL used is %s" % url)
    for bs_search in bs_find(url, "script", "class", "jiContent", proxies=proxies):
        json_data = json.loads(bs_search.string)
        for v in json_data["Versions"]:
            if short_vscode_version in v["version"]:
                version = v["version"]
                break
        break

    download_url = "https://marketplace.visualstudio.com/_apis/public/gallery/publishers/%s/vsextensions/%s/%s/vspackage" % (
        ext_publisher,
        json_data["Resources"]["ExtensionName"],
        version,
    )
    latest_bin = ext_uid_name + "-%s.vsix" % version

    print("Latest %s version is: %s" % (app_name, version))
    print("Download URL is: %s" % download_url)

    # Downloading latest binaries
    if not isfile(latest_bin):
        print("Downloading: %s" % latest_bin)
        content = requests.get(download_url, stream=True)
        nb_wait = 0
        max_wait = 3600
        while str(content.status_code) == "429":
            timewait = int(content.headers["Retry-After"])
            print("Wait %s" % timewait)
            nb_wait = nb_wait + timewait
            if nb_wait > max_wait:
                error("Max wait ...")
            time.sleep(timewait)
            content = requests.get(download_url, stream=True)

        with open(latest_bin, "wb") as f:
            for chunk in content.iter_content(chunk_size=1024 * 1024):
                f.write(chunk)

    # 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(version, "vsix")

    # Validating or not update-package-sources
    return result