"""
* SPDX-FileCopyrightText: 2023-2025 PeppermintOS Team
* (peppermintosteam@proton.me)
* SPDX-License-Identifier: GPL-3.0-or-later
*
* These functions will build the base of the fusato build folders
* As well as commonly used functions
"""

import os
import subprocess
import shutil
from python_modules.paths_modules import (
        HOME_FOLDER, PACKAGE_LIST, CHROOT_FOLDER, INCLUDES_INSTALLER,
        BOOTSTRAP_FOLDER, FUSATO_ROOT, DE_PATH, BUILD_FILE_PATH,
        make_bootstrap_shared, make_packages_shared,
        make_chroot_fusato_structure, make_chroot_installer_structure,
        make_chroot_fusato_server, installer_server_dirs,
        installer_mini_dirs
    )
from python_modules.lists_modules import (
    BINARY_LIST_SHARED, BINARY_LIST_64,
    BINARY_LIST_ARM, BINARY_LIST_32
    )
from python_modules.lists_modules import (
    ENV_LIST, XFCE_LIST,  DESKTOP_LIST, KDE_LIST, GNOME_FLASHBACK_LIST,
    OPENBOX_LIST, LOADED_LIST, SERVER_LIST, MINI_LIST
    )
from python_modules.lists_modules import (
    FIRMWARE_LIST, FIRMWARE_LIST_ARM, FIRMWARE_LIST_32_64
    )
from python_modules.lists_modules import (
    GRUB_LIST_SHARED, GRUB_LIST_64, GRUB_LIST_ARM64, GRUB_LIST_32
    )
from python_modules.lists_modules import (LIGHT_DM_LIST)
from python_modules.lists_modules import (GENERAL_SHARED_LIST)
from python_modules.lists_modules import (
    system_list,system_list_64, system_list_arm64,system_list_32
    )
from python_modules.lists_modules import (
    ARTWORK_LIST, PYTHON_LIST, CALAMARES_LIST, GENERAL_LIST,
    FLAG_SPECIFIC_LIST_32
    )

from python_modules.logger_modules import builder_logger as logger


def recreate_directory(path):
    """
    Recreate the fusato folder by removing it if it exists and then 
    creating it anew.
    Args:
    path (str): The full path of the directory to recreate.
    Returns:
    bool: True if the operation was successful, False otherwise.
    """
    logger.info("Attempting to recreate directory: %s", path)
    try:
        if os.path.exists(path):
            logger.debug("Directory exists, removing: %s", path)
            shutil.rmtree(path, ignore_errors=True)
            logger.info(
                "Successfully removed existing directory: %s", path)
        else:
            logger.warning(
                "Directory does not exist, will create new: %s", path)
        os.makedirs(path)
        logger.info("Successfully created new directory: %s", path)
        return True
    except OSError as _:
        logger.error("Error recreating directory %s: %s", path, str(_))
        return False
    except (ValueError, TypeError)as _:
        logger.critical(
            "Unexpected error recreating directory %s: %s",
            path, str(_))
        return False


def create_folders(base_path, folder_list):
    """
    This util function is a shared loop for bootstrap and packages
    Arguments Passed from the other util functions 
    base_path (str): The base path where folders will be created.
    folder_list (list): List of folder names to create.
    """
    logger.info("Starting folder creation at base path: %s", base_path)
    logger.info("Folder list to create: %s", folder_list)
    for folder in folder_list:
        full_path = os.path.join(base_path, folder)
        logger.info("Attempting to create folder: %s", full_path)
        try:
            #os.makedirs(full_path, exist_ok=True)
            subprocess.run(["mkdir", "-p", full_path], check=True)
            logger.info(
                "Successfully created/verified folder: %s", full_path)
        except OSError as _:
            logger.error(
                "Error creating folder %s: %s", full_path, str(_))
            exit()
        except (ValueError, TypeError)as _:
            logger.critical(
                "Unexpected error creating folder %s: %s",
                full_path, str(_))
            exit()
    logger.info("Folder creation process completed")


def create_bootstrap_folders():
    """Create bootstrap folders."""
    logger.debug("Starting creation of bootstrap folders")
    bootstrap_path = os.path.join(HOME_FOLDER, BOOTSTRAP_FOLDER)
    logger.info("Bootstrap path: %s", bootstrap_path)
    try:
        create_folders(bootstrap_path, make_bootstrap_shared)
        logger.info(
            "Successfully created bootstrap folders at %s",
            bootstrap_path)
    except (ValueError, TypeError) as _:
        logger.error("Error creating bootstrap folders: %s", str(_))
        exit()
    logger.info("Finished creating bootstrap folders")


def create_package_folders():
    """Create package folders."""
    logger.debug("Starting creation of package folders")
    package_path = os.path.join(HOME_FOLDER, PACKAGE_LIST)
    logger.info("Package path: %s", package_path)
    try:
        create_folders(package_path, make_packages_shared)
        logger.info("Successfully created package folders at %s", package_path)
    except (ValueError, TypeError) as _:
        logger.error("Error creating package folders: %s", str(_))
    logger.info("Finished creating package folders")


def delete_fusato_folder(fusato_root):
    """Delete the fusato folder if it exists using sudo rm."""
    if os.path.exists(fusato_root):
        logger.info("Fusato folder exists. Deleting: %s", fusato_root)
        try:
            subprocess.run(['sudo', 'rm', '-rf', fusato_root], check=True)
            logger.info("Fusato folder deleted successfully.")
        except subprocess.CalledProcessError as e:
            logger.error("Failed to delete fusato folder: %s", e)
    else:
        logger.info("Fusato folder does not exist: %s", fusato_root)


def set_fusato_structure():
    """ 
    Make some needed folders for the fusato build process.
    at this moment you deal with chroot and bootstrap
    """
    logger.debug("Starting to set up Fusato structure")
    try:
        fusato_root = os.path.join(HOME_FOLDER, FUSATO_ROOT)
        delete_fusato_folder(fusato_root)
        logger.info("Fusato root path: %s", fusato_root)
        logger.info("Changed directory to Fusato root")
        config_path = os.path.join(fusato_root, 'config')
        logger.info("Config path: %s", config_path)
        if not recreate_directory(config_path):
            logger.warning(
                "Failed to recreate config directory: %s", config_path)
            exit()
        for folder in make_chroot_fusato_structure:
            chroot_folder_path = os.path.join(
                HOME_FOLDER, CHROOT_FOLDER, folder)
            logger.info("Creating chroot folder: %s",
                chroot_folder_path)
            os.makedirs(chroot_folder_path, exist_ok=True)
        logger.debug("Creating bootstrap folders")
        create_bootstrap_folders()
        logger.debug("Creating package folders")
        create_package_folders()
        logger.info("Fusato structure set up successfully")
    except OSError as _:
        logger.error("Error setting up fusato structure: %s", str(_))
        exit()
        raise
    except (ValueError, TypeError) as _:
        logger.critical(
            "Unexpected error setting up fusato structure: %s", str(_))
        exit()
        raise


def set_fusato_server_structure():
    """ Make some needed folders for the fusato build process.
        at the moment you deal with chroot, bootstrap, and
        includes-installer
    """
    logger.info("Starting to set up Fusato server structure")
    try:
        fusato_root = os.path.join(HOME_FOLDER, FUSATO_ROOT)
        logger.debug("Fusato root path: %s", fusato_root)
        os.chdir(fusato_root)
        logger.debug("Changed directory to Fusato root")
        config_path = os.path.join(fusato_root, 'config')
        logger.debug("Config path: %s", config_path)
        if not recreate_directory(config_path):
            logger.warning(
                "Failed to recreate config directory: %s", config_path)
        for folder in make_chroot_fusato_server:
            chroot_folder_path = os.path.join(HOME_FOLDER,
                CHROOT_FOLDER, folder)
            logger.debug("Creating chroot folder: %s",
                chroot_folder_path)
            os.makedirs(chroot_folder_path, exist_ok=True)
        logger.info("Creating bootstrap folders")
        create_bootstrap_folders()
        logger.info("Creating package folders")
        create_package_folders()
        logger.info("Fusato server structure set up successfully")
    except OSError as _:
        logger.error(
            "Error setting up fusato server structure: %s", str(_))
        exit()
        raise
    except (ValueError, TypeError) as _:
        logger.critical(
            "Unexpected error setting up fusato server structure: %s",
            str(_))
        exit()
        raise


def set_fusato_server_installer_structure():
    """ Make some needed folders for the fusato build process.
        at the moment you deal with the installer
        Define the directories to be created in includes-installer
        Create the directories in includes-installer
    """
    logger.info("Starting to set up Fusato server installer structure")
    for server_dir in installer_server_dirs:
        full_path = os.path.join(HOME_FOLDER, INCLUDES_INSTALLER,
            server_dir.strip('/'))
        logger.debug("Creating directory: %s", full_path)
        try:
            os.makedirs(full_path, exist_ok=True)
            logger.info("Created directory: %s", full_path)
        except OSError as _:
            logger.error("Error creating directory %s: %s", full_path,
                str(_))
            exit()
    logger.info("Finished setting up Fusato server installer structure")


def set_fusato_mini_structure():
    """ Make some needed folders for the fusato build process.
        at the moment you deal with chroot, bootstrap, and
        includes-installer
    """
    logger.debug("Starting to set up Fusato mini structure")
    try:
        fusato_root = os.path.join(HOME_FOLDER, FUSATO_ROOT)
        delete_fusato_folder(fusato_root)
        logger.info("Fusato root path: %s", fusato_root)
        config_path = os.path.join(fusato_root, 'config')
        logger.info("Config path: %s", config_path)
        if not recreate_directory(config_path):
            logger.warning(
                "Failed to recreate config directory: %s", config_path)
            exit()
        for folder in make_chroot_fusato_structure:
            chroot_folder_path = os.path.join(
                HOME_FOLDER, CHROOT_FOLDER, folder)
            logger.info("Creating chroot folder: %s",
                chroot_folder_path)
            os.makedirs(chroot_folder_path, exist_ok=True)
        logger.debug("Changed directory to Fusato root")
        os.chdir(fusato_root)
        logger.debug("Creating bootstrap folders")
        create_bootstrap_folders()
        logger.debug("Creating package folders")
        create_package_folders()
        logger.info("Fusato mini structure set up successfully")
    except OSError as _:
        logger.error(
            "Error setting up fusato mini structure: %s", str(_))
        exit()
        raise
    except (ValueError, TypeError) as _:
        logger.critical(
            "Unexpected error setting up fusato mini structure: %s",
            str(_))
        exit()
        raise


def set_fusato_mini_installer_structure():
    """ Make some needed folders for the fusato build process.
        at the moment you deal with the installer. Define the
        directories to be created in includes-installer
        Create the directories in includes-installer
    """
    print("catchme")
    logger.info("Starting to set up Fusato mini installer structure")
    try:
        fusato_root = os.path.join(HOME_FOLDER, FUSATO_ROOT)
    except OSError as _:
        logger.error("Error creating directory %s: %s", full_path,
            str(_))
        exit()
    for mine_dir in installer_mini_dirs:
        full_path = os.path.join(HOME_FOLDER, INCLUDES_INSTALLER, mine_dir.strip('/'))
        logger.debug("Creating directory: %s", full_path)
        try:
            os.makedirs(full_path, exist_ok=True)
            logger.info("Created directory: %s", full_path)
        except OSError as _:
            logger.error("Error creating directory %s: %s", full_path,
                str(_))
            exit()
    logger.info("Finished setting up Fusato mini installer structure")


def set_fusato_installer_structure():
    """
    Make the fusato installer structure
    """
    logger.debug("Starting to set up Fusato installer structure")
    try:
        fusato_root_path = os.path.join(HOME_FOLDER, FUSATO_ROOT)
        os.chdir(fusato_root_path)
        logger.info("Changed directory to: %s", fusato_root_path)
    except (ValueError, TypeError, IOError, OSError) as _:
        logger.error("Error changing directory: %s", str(_))
        exit()
        return
    for folder in make_chroot_installer_structure:
        full_path = os.path.join(HOME_FOLDER,
            CHROOT_FOLDER.strip('/'), folder.strip('/'))
        logger.info("Attempting to create directory: %s", full_path)
        try:
            os.makedirs(full_path, exist_ok=True)
            logger.info("Created directory: %s", full_path)
        except (ValueError, TypeError, IOError, OSError) as _:
            logger.error("Error creating directory %s: %s", full_path,
                str(_))
            exit()
    logger.info("Finished setting up Fusato installer structure")


def make_build_file(base, arch, extension, build_description):
    """
    This will get the base, arch, extension, and build, to write the
    file
    """
    logger.info("Starting to create build file for %s %s", base, arch)
    file_path = os.path.join(os.path.expanduser(HOME_FOLDER),
        FUSATO_ROOT, f'{base}.{arch}{extension}'
    )
    logger.debug("Build file path: %s", file_path)
    try:
        with open(file_path, 'w', encoding='UTF-8') as f_p:
            f_p.write(build_description)
        logger.info("Successfully created build file: %s", file_path)
    except IOError as _:
        logger.error("Error writing build file %s: %s", file_path,
            str(_))
        exit()
    except (ValueError, TypeError) as _:
        logger.critical("Unexpected error creating build file %s: %s",
            file_path, str(_))
        exit()
    logger.info("Finished creating build file for %s %s", base, arch)


def make_bld_xfce(base, arch):
    """Write the xfce build file"""
    logger.info("Creating XFCE build file for %s %s", base, arch)
    make_build_file(base, arch, 'xfc', 'XFCE Build')
    logger.info("XFCE build file created for %s %s", base, arch)


def make_bld_gnomeflashback(base, arch):
    """Write the gnome fb build file"""
    logger.info("Creating Gnome Flashback build file for %s %s", base,
        arch)
    make_build_file(base, arch, 'gfb', 'Gnome Flash Back Build')
    logger.info("Gnome Flashback build file created for %s %s", base,
        arch)


def make_bld_openbox(base, arch):
    """Write the openbox build file"""
    logger.info("Creating OpenBox build file for %s %s", base, arch)
    make_build_file(base, arch, 'opb', 'OpenBox Build')
    logger.info("OpenBox build file created for %s %s", base, arch)


def make_bld_kde(base, arch):
    """Write the kde build file"""
    logger.info("Creating KDE build file for %s %s", base, arch)
    make_build_file(base, arch, 'kde', 'KDE Build')
    logger.info("KDE build file created for %s %s", base, arch)


def make_bld_loaded(base, arch):
    """Write the loaded build file"""
    logger.info("Creating Loaded build file for %s %s", base, arch)
    make_build_file(base, arch, 'loaded', 'Loaded Build')
    logger.info("Loaded build file created for %s %s", base, arch)


def make_bld_server(base, arch):
    """Write the server build file"""
    logger.info("Creating Server build file for %s %s", base, arch)
    make_build_file(base, arch, 'server', 'Server Build')
    logger.info("Server build file created for %s %s", base, arch)


def make_bld_mini(base, arch):
    """Write the mini build file"""
    logger.info("Creating Mini build file for %s %s", base, arch)
    make_build_file(base, arch, 'mini', 'Mini Build')
    logger.info("Mini build file created for %s %s", base, arch)


def make_package_list(file_name, content, mode='a'):
    """Create the package list file with the specified content if it
        doesn't exist.
    """
    logger.info("Starting to create package list: %s", file_name)
    file_path = os.path.join(HOME_FOLDER, PACKAGE_LIST, file_name)
    logger.info("Package list file path: %s", file_path)
    if not os.path.exists(file_path):
        try:
            with open(file_path, mode, encoding='UTF-8') as f_p:
                f_p.write(content)
            logger.info("Created package list: %s", file_path)
        except IOError as _:
            logger.error("Error creating package list %s: %s",
                file_path, str(_))
            exit()
        except (ValueError, TypeError) as _:
            logger.critical(
                "Unexpected error creating package list %s: %s",
                    file_path, str(_))
            exit()
    else:
        logger.info("Package list already exists: %s", file_path)
    logger.debug("Finished processing package list: %s", file_name)


def set_general_shared():
    """ Create the list for general shared list"""
    logger.debug("Creating general shared list")
    package_list_string = "\n".join(GENERAL_SHARED_LIST)
    make_package_list('genshared.list.chroot', package_list_string, mode='x')
    logger.info("General shared list created")


def set_specific_32_packages():
    """Create the list for the 32bit flagship"""
    logger.info("Creating 32-bit specific package list")
    package_list_string = "\n".join(FLAG_SPECIFIC_LIST_32)
    make_package_list('flagspec32.list.chroot', package_list_string,
        mode='x')
    logger.info("32-bit specific package list created")


def set_grub_shared():
    """ Create the list for shared grub list"""
    logger.info("Creating shared GRUB list")
    package_list_string = "\n".join(GRUB_LIST_SHARED)
    make_package_list('grub.list.chroot', package_list_string, mode='x')
    logger.info("Shared GRUB list created")


def set_binary_shared():
    """ Create the shared list for grub binary"""
    logger.info("Creating shared binary list")
    package_list_string = "\n".join(BINARY_LIST_SHARED)
    make_package_list('installer.list.binary', package_list_string,
        mode='x')
    logger.info("Shared binary list created")


def set_lightdm():
    """ Create the list for the light dm list  """
    logger.info("Creating LightDM package list")
    package_list_string = "\n".join(LIGHT_DM_LIST)
    make_package_list('lightdm.list.chroot', package_list_string, mode='x')
    logger.info("LightDM package list created")


def set_xfce():
    """ Create the list for the xfce xfce list"""
    logger.info("Creating XFCE package list")
    package_list_string = "\n".join(XFCE_LIST)
    make_package_list('xfce.list.chroot', package_list_string, mode='x')
    logger.info("XFCE package list created")


def set_gfb():
    """ Create the list for the gnomeflashback list"""
    logger.info("Creating GNOME Flashback package list")
    package_list_string = "\n".join(GNOME_FLASHBACK_LIST)
    make_package_list('gfb.list.chroot', package_list_string , mode='x')
    logger.info("GNOME Flashback package list created")


def set_opb():
    """ Create the list for the openbox list"""
    logger.info("Creating Openbox package list")
    package_list_string = "\n".join(OPENBOX_LIST)
    make_package_list('opb.list.chroot', package_list_string, mode='x')
    logger.info("Openbox package list created")


def set_kde():
    """ Create the list file for the kde list"""
    logger.info("Creating KDE package list")
    package_list_string = "\n".join(KDE_LIST)
    make_package_list('kde.list.chroot', package_list_string, mode='x')
    logger.info("KDE package list created")


def set_loaded():
    """ Create the list for the loaded list"""
    logger.info("Creating Loaded package list")
    package_list_string = "\n".join(LOADED_LIST)
    make_package_list('loaded.list.chroot', package_list_string, mode='x')
    logger.info("Loaded package list created")


def set_server():
    """ Create the list for the server list"""
    logger.info("Creating Server package list")
    package_list_string = "\n".join(SERVER_LIST)
    make_package_list('server.list.chroot', package_list_string, mode='x')
    logger.info("Server package list created")


def set_mini():
    """ Create the list for the loaded list"""
    logger.info("Creating Mini package list")
    package_list_string = "\n".join(MINI_LIST)
    print(package_list_string)
    make_package_list('mini.list.chroot', package_list_string, mode='x')
    logger.info("Mini package list created")


def set_chroot_grub_64():
    """ Append the grub list for 64 bit grub"""
    logger.info("Appending 64-bit GRUB list")
    package_list_string = "\n".join(GRUB_LIST_64)
    make_package_list('gfb.list.chroot', package_list_string)
    logger.info("64-bit GRUB list appended")


def set_chroot_grub_arm():
    """ Append the grub list for the ARM grub"""
    logger.info("Appending ARM GRUB list")
    package_list_string = "\n".join(GRUB_LIST_ARM64)
    make_package_list('gfb.list.chroot', package_list_string)
    logger.info("ARM GRUB list appended")


def set_chroot_grub_32():
    """ Append the grub list for the 32 bit grub"""
    logger.info("Appending 32-bit GRUB list")
    package_list_string = "\n".join(GRUB_LIST_32)
    make_package_list('gfb.list.chroot', package_list_string)
    logger.info("32-bit GRUB list appended")


def set_binary_64():
    """ Create the list for grub binary packages for 64 bit"""
    logger.info("Creating 64-bit binary package list")
    package_list_string = "\n".join(BINARY_LIST_64)
    make_package_list('installer.list.binary', package_list_string)
    logger.info("64-bit binary package list created")



def set_binary_arm():
    """ Create the list for grub binary packages for ARM"""
    logger.info("Creating ARM binary package list")
    package_list_string = "\n".join(BINARY_LIST_ARM)
    make_package_list('installer.list.binary', package_list_string)
    logger.info("ARM binary package list created")


def set_binary_32():
    """ Create the list for grub binary packages for 32 bit"""
    logger.info("Creating 32-bit binary package list")
    package_list_string = "\n".join(BINARY_LIST_32)
    make_package_list('installer.list.binary', package_list_string)
    logger.info("32-bit binary package list created")


def set_firmware():
    """ Create the list for the firmware support for general ISOs"""
    logger.info("Creating firmware list for general ISOs")
    package_list_string = "\n".join(FIRMWARE_LIST_32_64)
    make_package_list('firmware.list.chroot', package_list_string, mode='x')
    logger.info("Firmware list for general ISOs created")


def set_firmware_arm():
    """ Create the list for the firmware support for arm ISOs"""
    logger.info("Creating firmware list for ARM ISOs")
    package_list_string = "\n".join(FIRMWARE_LIST_ARM)
    make_package_list('firmware.list.chroot', package_list_string, mode='x')
    logger.info("Firmware list for ARM ISOs created")


def set_desktop_environment():
    """ Create the list for the desktop environment"""
    logger.info("Starting to create desktop environment list")
    try:
        os.chdir(HOME_FOLDER)
        logger.debug("Changed directory to: %s", HOME_FOLDER)
        current_dir = os.getcwd().replace('/', '/')
        logger.debug("Current directory: %s", current_dir)
        package_lists_dir = current_dir + DE_PATH
        os.chdir(package_lists_dir)
        logger.debug("Changed directory to package-lists: %s",
            package_lists_dir)
        desktop_list_file = 'desktop.list.chroot'
        logger.info("Creating desktop environment list file: %s",
            desktop_list_file)
        with open(desktop_list_file, 'x', encoding='UTF-8') as de_file:
            de_file.write(ENV_LIST)
        logger.info(
            "Desktop environment list file created successfully")
    except FileExistsError:
        logger.warning(
            "Desktop environment list file already exists: %s",
            desktop_list_file)
        exit()
    except IOError as _:
        logger.error(
            "Error creating desktop environment list file: %s",
            str(_))
        exit()
    except (ValueError, TypeError) as _:
        logger.critical(
            "Unexpected error in set_desktop_environment: %s", str(_))
        exit()
    logger.info("Finished creating desktop environment list")


def set_extra_packages():
    """ Create the list for the desktop environment extras goodies"""
    with open(
              'extra-desktop.list.chroot', 'x', encoding='UTF-8'
              ) as extra_file:
        extra_file.write(DESKTOP_LIST)


def set_general_packages():
    """ Create the list for standard install packages"""
    logger.info("Creating general packages list")
    try:
        with open(
            'packages.list.chroot', 'x', 
            encoding='UTF-8') as general_file:
            general_file.write(GENERAL_LIST)
        logger.info("General packages list created successfully")
    except IOError as _:
        logger.error("Error creating general packages list: %s", str(_))
        exit()


def set_system_packages():
    """ Create the list for system management packages"""
    logger.info("Creating system packages list")
    try:
        with open('system.list.chroot', 'x',
            encoding='UTF-8') as system_file:
            system_file.write(system_list)
        logger.info("System packages list created successfully")
    except IOError as _:
        logger.error("Error creating system packages list: %s", str(_))
        exit()


def set_system_packages_32():
    """ Create the list for system management packages"""
    logger.info("Appending 32-bit system packages list")
    try:
        with open('system.list.chroot', 'a',
            encoding='UTF-8') as system_file:
            system_file.write(system_list_32)
        logger.info("32-bit system packages list appended successfully")
    except IOError as _:
        logger.error(
            "Error appending 32-bit system packages list: %s", str(_))
        exit()


def set_system_packages_64():
    """ Create the list for system management packages"""
    logger.info("Appending 64-bit system packages list")
    try:
        with open('system.list.chroot', 'a',
            encoding='UTF-8') as system_file:
            system_file.write(system_list_64)
        logger.info("64-bit system packages list appended successfully")
        exit()
    except IOError as _:
        logger.error(
            "Error appending 64-bit system packages list: %s", str(_))
        exit()


def set_system_packages_arm():
    """ Create the list for system management packages"""
    logger.info("Appending ARM system packages list")
    try:
        with open('system.list.chroot', 'a',
            encoding='UTF-8') as system_file:
            system_file.write(system_list_arm64)
        logger.info("ARM system packages list appended successfully")
    except IOError as _:
        logger.error("Error appending ARM system packages list: %s",
            str(_))
        exit()


def set_artwork_packages():
    """ Create the list for icons, wallpaper and themes"""
    logger.info("Creating artwork packages list")
    try:
        with open('artwork.list.chroot', 'x',
            encoding='UTF-8') as artwork_file:
            artwork_file.write(ARTWORK_LIST)
        logger.info("Artwork packages list created successfully")
    except IOError as _:
        logger.error("Error creating artwork packages list: %s", str(_))
        exit()


def set_python_packages():
    """ Create the list for python related needs"""
    logger.info("Creating Python packages list")
    try:
        with open('python.list.chroot', 'x',
            encoding='UTF-8') as python_file:
            python_file.write(PYTHON_LIST)
        logger.info("Python packages list created successfully")
    except IOError as _:
        logger.error("Error creating Python packages list: %s", str(_))
        exit()


def set_calamares_packages():
    """ Create the list for the calamares installer"""
    logger.info("Creating Calamares packages list")
    try:
        with open('installer.list.chroot', 'x',
            encoding='UTF-8') as calamares_file:
            calamares_file.write(CALAMARES_LIST)
        logger.info("Calamares packages list created successfully")
    except IOError as _:
        logger.error("Error creating Calamares packages list: %s",
            str(_))
        exit()


def set_firmware_packages():
    """ Create the list for the firmware support for general ISOs"""
    logger.info("Creating firmware packages list for general ISOs")
    try:
        with open('firmware.list.chroot', 'x',
            encoding='UTF-8') as firmware_file:
            firmware_file.write(FIRMWARE_LIST)
        logger.info("Firmware packages list for general ISOs created successfully")
    except IOError as _:
        logger.error(
            "Error creating firmware packages list for general ISOs: %s",
            str(_))
        exit()


def set_firmware_packages_arm():
    """ Create the list for the firmware support for arm ISOs"""
    logger.info("Creating firmware packages list for ARM ISOs")
    try:
        with open('firmware.list.chroot', 'x',
            encoding='UTF-8') as firmware_file:
            firmware_file.write(FIRMWARE_LIST_ARM)
        logger.info(
            "Firmware packages list for ARM ISOs created successfully")
    except IOError as _:
        logger.error(
            "Error creating firmware packages list for ARM ISOs: %s",
            str(_))
        exit()


def set_binary_packages_64():
    """ Create the list for grub binary packages for 64 bit"""
    logger.info("Creating binary packages list for 64-bit")
    try:
        with open('installer.list.binary', 'x',
            encoding='UTF-8') as binary_file:
            binary_file.write(BINARY_LIST_64)
        logger.info(
            "Binary packages list for 64-bit created successfully")
    except IOError as _:
        logger.error(
            "Error creating binary packages list for 64-bit: %s",
            str(_))
        exit()


def set_binary_packages_arm64():
    """ Create the list for grub binary packages for 64 bit"""
    logger.info("Creating binary packages list for ARM64")
    try:
        with open('installer.list.binary', 'x',
            encoding='UTF-8') as binary_file:
            binary_file.write(BINARY_LIST_ARM)
        logger.info(
            "Binary packages list for ARM64 created successfully")
    except IOError as _:
        logger.error(
            "Error creating binary packages list for ARM64: %s", str(_))
        exit()


def set_binary_packages_32():
    """ Create the list for grub binary packages for 32 bit"""
    logger.info("Creating binary packages list for 32-bit")
    try:
        with open('installer.list.binary', 'x',
            encoding='UTF-8') as binary_file:
            binary_file.write(BINARY_LIST_32)
        logger.info(
        "Binary packages list for 32-bit created successfully")
    except IOError as _:
        logger.error(
            "Error creating binary packages list for 32-bit: %s",
            str(_))
        exit()