#
# Copyright (C) 2020 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
# Public License for more details.  You should have received a copy of the
# GNU General Public License along with this program; if not, write to the
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the
# source code or documentation are not subject to the GNU General Public
# License and may only be used or replicated with the express permission of
# Red Hat, Inc.
#
import fnmatch
import hashlib
import os
import rpm
from libdnf.transaction import TransactionItemState_ERROR

from blivet.size import Size

from pyanaconda.anaconda_loggers import get_module_logger
from pyanaconda.core.configuration.anaconda import conf
from pyanaconda.core.payload import parse_hdd_url
from pyanaconda.core.regexes import VERSION_DIGITS
from pyanaconda.core.util import execWithCapture
from pyanaconda.core.hw import is_lpae_available
from pyanaconda.core.path import join_paths
from pyanaconda.modules.common.constants.objects import DEVICE_TREE, DISK_SELECTION
from pyanaconda.modules.common.constants.services import STORAGE
from pyanaconda.modules.common.structures.packages import PackagesSelectionData
from pyanaconda.modules.payloads.constants import SourceType
from pyanaconda.core.product import get_product_name, get_product_version
from pyanaconda.modules.payloads.base.utils import sort_kernel_version_list

log = get_module_logger(__name__)

DNF_PACKAGE_CACHE_DIR_SUFFIX = 'dnf.package.cache'


def calculate_hash(data):
    """Calculate hash from the given data.

    :return: a string with the hash
    """
    m = hashlib.sha256()
    m.update(data.encode('ascii', 'backslashreplace'))
    return m.digest()


def get_kernel_package(dnf_manager, exclude_list):
    """Get an installable kernel package.

    :param dnf_manager: a DNF manager
    :param exclude_list: a list of excluded packages
    :return: a package name or None
    """
    if "kernel" in exclude_list:
        return None

    # Get the kernel packages.
    kernels = ["kernel"]

    # ARM systems use either the standard Multiplatform or LPAE platform.
    if is_lpae_available():
        kernels.insert(0, "kernel-lpae")

    # Find an installable one.
    for kernel_package in kernels:
        if kernel_package in exclude_list:
            continue

        if not dnf_manager.is_package_available(kernel_package):
            log.info("No such package: %s", kernel_package)
            continue

        return kernel_package

    log.error("Failed to select a kernel from: %s", kernels)
    return None


def get_product_release_version():
    """Get a release version of the product.

    :return: a string with the release version
    """
    try:
        release_version = VERSION_DIGITS.match(get_product_version()).group(1)
    except AttributeError:
        release_version = "rawhide"

    log.debug("Release version of %s is %s.", get_product_name(), release_version)
    return release_version


def get_installation_specs(data: PackagesSelectionData, default_environment=None):
    """Get specifications of packages, groups and modules for installation.

    :param data: a packages selection data
    :param default_environment: a default environment to install
    :return: a tuple of specification lists for inclusion and exclusion
    """
    # Note about package/group/module spec formatting:
    # - leading @ signifies a group or module
    # - no leading @ means a package
    include_list = []
    exclude_list = []

    # Handle the environment.
    if data.default_environment_enabled and default_environment:
        log.info("Selecting default environment '%s'.", default_environment)
        include_list.append("@{}".format(default_environment))
    elif data.environment:
        include_list.append("@{}".format(data.environment))

    # Handle the core group.
    if not data.core_group_enabled:
        log.info("Skipping @core group; system may not be complete.")
        exclude_list.append("@core")
    else:
        include_list.append("@core")

    # Handle groups.
    for group_name in data.excluded_groups:
        exclude_list.append("@{}".format(group_name))

    for group_name in data.groups:
        # Packages in groups can have different types
        # and we provide an option to users to set
        # which types are going to be installed.
        if group_name in data.groups_package_types:
            type_list = data.groups_package_types[group_name]
            group_spec = "@{group_name}/{types}".format(
                group_name=group_name,
                types=",".join(type_list)
            )
        else:
            # If group is a regular group this is equal to
            # @group/mandatory,default,conditional (current
            # content of the DNF GROUP_PACKAGE_TYPES constant).
            group_spec = "@{}".format(group_name)

        include_list.append(group_spec)

    # Handle packages.
    for pkg_name in data.excluded_packages:
        exclude_list.append(pkg_name)

    for pkg_name in data.packages:
        include_list.append(pkg_name)

    return include_list, exclude_list


def get_kernel_version_list():
    """Get a list of installed kernel versions.

    :return: a list of kernel versions
    """
    files = []
    efi_dir = conf.bootloader.efi_dir

    # Find all installed RPMs that provide 'kernel'.
    ts = rpm.TransactionSet(conf.target.system_root)
    mi = ts.dbMatch('providename', 'kernel')

    for hdr in mi:
        # Find all /boot/vmlinuz- files and strip off vmlinuz-.
        files.extend((
            f.split("/")[-1][8:] for f in hdr.filenames
            if fnmatch.fnmatch(f, "/boot/vmlinuz-*") or
            fnmatch.fnmatch(f, "/boot/efi/EFI/%s/vmlinuz-*" % efi_dir)
        ))

    # Sort the kernel versions.
    sort_kernel_version_list(files)

    return files


def get_free_space_map(current=True, scheduled=False):
    """Get the available file system disk space.

    :param bool current: use information about current mount points
    :param bool scheduled: use information about scheduled mount points
    :return: a dictionary of mount points and their available space
    """
    mount_points = {}

    if scheduled:
        mount_points.update(_get_scheduled_free_space_map())

    if current:
        mount_points.update(_get_current_free_space_map())

    return mount_points


def _get_current_free_space_map():
    """Get the available file system disk space of the current system.

    :return: a dictionary of mount points and their available space
    """
    mapping = {}

    # Generate the dictionary of mount points and sizes.
    output = execWithCapture('df', ['--output=target,avail'])
    lines = output.rstrip().splitlines()

    for line in lines:
        key, val = line.rsplit(maxsplit=1)

        if not key.startswith('/'):
            continue

        mapping[key] = Size(int(val) * 1024)

    # Add /var/tmp/ if this is a directory or image installation.
    if not conf.target.is_hardware:
        var_tmp = os.statvfs("/var/tmp")
        mapping["/var/tmp"] = Size(var_tmp.f_frsize * var_tmp.f_bfree)

    return mapping


def _get_scheduled_free_space_map():
    """Get the available file system disk space of the scheduled system.

    :return: a dictionary of mount points and their available space
    """
    device_tree = STORAGE.get_proxy(DEVICE_TREE)
    mount_points = {}

    for mount_point in device_tree.GetMountPoints():
        # we can ignore swap
        if not mount_point.startswith('/'):
            continue

        free_space = Size(
            device_tree.GetFileSystemFreeSpace([mount_point])
        )
        mount_point = os.path.normpath(
            conf.target.system_root + mount_point
        )
        mount_points[mount_point] = free_space

    return mount_points


def _pick_mount_points(mount_points, download_size, install_size):
    """Pick mount points for the package installation.

    :return: a set of sufficient mount points
    """
    suitable = {
        '/var/tmp',
        conf.target.system_root,
        join_paths(conf.target.system_root, 'home'),
        join_paths(conf.target.system_root, 'tmp'),
        join_paths(conf.target.system_root, 'var'),
    }

    sufficient = set()

    for mount_point, size in mount_points.items():
        # Ignore mount points that are not suitable.
        if mount_point not in suitable:
            continue

        if size >= (download_size + install_size):
            log.debug("Considering %s (%s) for download and install.", mount_point, size)
            sufficient.add(mount_point)

        elif size >= download_size and not mount_point.startswith(conf.target.system_root):
            log.debug("Considering %s (%s) for download.", mount_point, size)
            sufficient.add(mount_point)

    return sufficient


def _get_biggest_mount_point(mount_points, sufficient):
    """Get the biggest sufficient mount point.

    :return: a mount point or None
    """
    return max(sufficient, default=None, key=mount_points.get)


def pick_download_location(dnf_manager):
    """Pick the download location.

    :param dnf_manager: the DNF manager
    :return: a path to the download location
    """
    download_size = dnf_manager.get_download_size()
    install_size = dnf_manager.get_installation_size()
    mount_points = get_free_space_map()

    # Try to find mount points that are sufficient for download and install.
    sufficient = _pick_mount_points(
        mount_points,
        download_size,
        install_size
    )

    # Or find mount points that are sufficient only for download.
    if not sufficient:
        sufficient = _pick_mount_points(
            mount_points,
            download_size,
            install_size=0
        )

    # Ignore the system root if there are other mount points.
    if len(sufficient) > 1:
        sufficient.discard(conf.target.system_root)

    if not sufficient:
        raise RuntimeError(
            "Not enough disk space to download the "
            "packages; size {}.".format(download_size)
        )

    # Choose the biggest sufficient mount point.
    mount_point = _get_biggest_mount_point(mount_points, sufficient)

    log.info("Mount point %s picked as download location", mount_point)
    location = join_paths(mount_point, DNF_PACKAGE_CACHE_DIR_SUFFIX)

    return location


def calculate_required_space(dnf_manager):
    """Calculate the space required for the installation.

    :param DNFManager dnf_manager: the DNF manager
    :return Size: the required space
    """
    installation_size = dnf_manager.get_installation_size()
    download_size = dnf_manager.get_download_size()
    mount_points = get_free_space_map(scheduled=True)

    # Find sufficient mount points.
    sufficient = _pick_mount_points(
        mount_points,
        download_size,
        installation_size
    )

    # Choose the biggest sufficient mount point.
    mount_point = _get_biggest_mount_point(mount_points, sufficient)

    if not mount_point or mount_point.startswith(conf.target.system_root):
        log.debug("The install and download space is required.")
        required_space = installation_size + download_size
    else:
        log.debug("Use the %s mount point for the %s download.", mount_point, download_size)
        log.debug("Only the install space is required.")
        required_space = installation_size

    log.debug("The package installation requires %s.", required_space)
    return required_space


def collect_installation_devices(sources, repositories):
    """Collect devices of installation sources.

    :return: a list of device specifications
    """
    devices = set()

    configurations = [
        s.configuration
        for s in sources
        if s.type == SourceType.HDD
    ]

    for repository in configurations + repositories:
        if repository.url.startswith("hd:"):
            device, _path = parse_hdd_url(repository.url)
            devices.add(device)

    return devices


def protect_installation_devices(previous_devices, current_devices):
    """Protect installation devices.

    :param previous_devices: a list of device specifications
    :param current_devices: a list of device specifications
    """
    # Nothing has changed.
    if previous_devices == current_devices:
        return

    disk_selection_proxy = STORAGE.get_proxy(DISK_SELECTION)
    protected_devices = disk_selection_proxy.ProtectedDevices

    # Remove previous devices from the list.
    for spec in previous_devices:
        if spec in protected_devices:
            protected_devices.remove(spec)

    # Add current devices from the list.
    for spec in sorted(current_devices):
        if spec not in protected_devices:
            protected_devices.append(spec)

    disk_selection_proxy.ProtectedDevices = protected_devices


def transaction_has_errors(transaction):
    """Detect if finished DNF transaction has any errors.

    :param transaction: the DNF transaction
    :return: True if the transaction has any error, otherwise False
    """
    has_errors = False
    for tsi in transaction:
        if tsi.state == TransactionItemState_ERROR:
            log.error("The transaction contains item %s in error state.", tsi)
            has_errors = True
    return has_errors