# -*- coding: utf-8 -*-
"""
SPDX-FileCopyrightText: 2023-2025 PeppermintOS Team
(peppermintosteam@proton.me)

SPDX-License-Identifier: GPL-3.0-or-later

This module provides a function to install the specified kernel package within different
environments of the PeppermintOS build process, such as the root filesystem, the pep-target,
or the pep-host, using the host-execution strategy. It reads kernel package information
from a YAML configuration file, handling architecture-specific package names, and
uses the XBPS package manager for installation.

Credits:
  - PeppermintOS Team (peppermintosteam@proton.me) - Development and maintenance of the project.

License:
  This code is distributed under the GNU General Public License version 3 or later (GPL-3.0-or-later).
  For more details, please refer to the LICENSE file included in the project or visit:
  https://www.gnu.org/licenses/gpl-3.0.html
"""

import os
import sys
import logging

BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, BASE_DIR)

try:
    from builder.core.command_runner import run_command
    from builder.configs import logger_config
    from builder.core.bootstrap import bootstrap 

    logger = logger_config.setup_logger('install_kernel')
except ImportError as e:
    try:
        basic_logger = logging.getLogger(__name__)
        logging.basicConfig(level=logging.ERROR)
        basic_logger.error(f"Error importing necessary modules for install_kernel: {e}. Ensure your environment is set up correctly.")
    except Exception:
        print(f"Error importing necessary modules for install_kernel: {e}. Ensure your environment is set up correctly.")
    sys.exit(1)


def install_kernel(arch, kernel_type, kernels_config, target_env='rootfs', paths=None, host_arch=None, repositories_data=None):
    """
    Installs the specified kernel in the target environment (rootfs, pep-target, pep-host),
    using the host-execution strategy and handling architecture-specific package names.

    Args:
        arch (str): Architecture (e.g., 'aarch64').
        kernel_type (str): Kernel type (e.g., 'current', 'lts', 'mainline').
        kernels_config (dict): Kernel configuration loaded from the YAML file.
                               Expected structure: {kernels: {<kernel_type>: {<architecture>: package_name}}}
        target_env (str): Target environment to install the kernel in ('rootfs', 'pep-target', 'pep-host').
                                        Defaults to 'rootfs'.
        paths (dict): Dictionary of build paths. Required to get target path and cache dir.
        host_arch (str): The architecture of the host system.
        repositories_data (list): List of repository dictionaries from YAML config.
                                   Expected structure: [{'name': '...', 'uri': '...', 'architectures': [...]}, ...]

    Raises:
        subprocess.CalledProcessError: If the xbps-install command fails.
        ValueError: If configuration data is missing or incorrect.
        KeyError: If required paths are not found.
    """

    logger.info(f"=> Starting kernel installation: {kernel_type} for {arch} in environment: {target_env}...")

    if paths is None or not isinstance(paths, dict):
         logger.error("Paths dictionary is missing or incorrect.")
         raise ValueError("Paths dictionary is required.")

    kernel_package_name = None

    if kernels_config and 'kernels' in kernels_config and kernel_type in kernels_config['kernels']:
        kernel_info_for_type = kernels_config['kernels'][kernel_type]
        if isinstance(kernel_info_for_type, dict):
             kernel_package_name = kernel_info_for_type.get(arch)

    if kernel_package_name:
        logger.info(f"=> Selected Void Linux kernel package name (YAML) for {arch} / {kernel_type}: {kernel_package_name}")
    else:
        default_package_name = "linux"
        logger.warning(f"Kernel type '{kernel_type}' or architecture '{arch}' not found in the YAML configuration. Using '{default_package_name}' as default package name.")
        kernel_package_name = default_package_name

    if not kernel_package_name:
         logger.error(f"Kernel package name is empty even after fallback. Cannot install kernel.")
         raise ValueError("Kernel package name is not defined.")

    adapted_package_structure = {target_env: {arch: [kernel_package_name]}}

    kernel_packages_args = bootstrap.construct_xbps_install_args(
       target_env,
       paths,
       arch,
       repositories_data,
       adapted_package_structure
    )

    if not kernel_packages_args:
        logger.warning("Skipping kernel installation due to failure in constructing xbps-install arguments.")
    else:
         kernel_install_command = ["/usr/bin/xbps-install"] + kernel_packages_args

         logger.info(f"Executing kernel installation command (host) [TARGETED AT: {target_env}]: {' '.join(kernel_install_command)}")
         try:
             run_command(kernel_install_command)
             logger.info(f"=> Kernel installed successfully in the environment: {target_env}.")
         except Exception as e:
             logger.error(f"Error installing the kernel in the environment: {target_env}: {e}")
             raise


    logger.info(f"=> Kernel installation: {kernel_type} ({target_env}) completed.")
    logger.info(f"--------------------------------------------------------------------\n")