#

# Copyright (C) 2013  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.

#

# Red Hat Author(s): Vratislav Podzimek <vpodzime@redhat.com>

#

"""Module with various utility functions used by the addon."""

import os

import os.path

import shutil

import glob

import hashlib

def ensure_dir_exists(dirpath):

    """

    Checks if a given directory exists and if not, it creates the directory as

    well as all the nonexisting directories in its path.

    :param dirpath: path to the directory to be checked/created

    :type dirpath: str

    """

    if not dirpath:

        # nothing can be done for an empty string

        return

    if not os.path.isdir(dirpath):

        os.makedirs(dirpath)

def universal_copy(src, dst):

    """

    Function that copies the files or directories specified by the src argument

    to the destination given by the dst argument. It should follow the same

    rules as the standard 'cp' utility.

    :param src: source to copy -- may be a glob, file path or a directory path

    :type src: str

    :param dst: destination to copy to

    :type src: str

    """

    if glob.has_magic(src):

        # src is a glob

        sources = glob.glob(src)

    else:

        # not a glob

        sources = [src]

    for item in sources:

        if os.path.isdir(item):

            if os.path.isdir(dst):

                item = item.rstrip("/")

                dirname = item.rsplit("/", 1)[-1]

                shutil.copytree(item, join_paths(dst, dirname))

            else:

                shutil.copytree(item, dst)

        else:

            shutil.copy2(item, dst)

def keep_type_map(func, iterable):

    """

    Function that maps the given function to items in the given iterable

    keeping the type of the iterable.

    :param func: function to be mapped on the items in the iterable

    :type func: in_item -> out_item

    :param iterable: iterable providing the items the function should be mapped

                     on

    :type iterable: iterable

    :return: iterable providing items produced by the function mapped on the

             input items

    :rtype: the same type as input iterable or generator if the iterable is not

            of any basic Python types

    """

    if isinstance(iterable, dict):

        return dict((func(key), iterable[key]) for key in iterable)

    items_gen = (func(item) for item in iterable)

    if isinstance(iterable, list):

        return list(items_gen)

    elif isinstance(iterable, tuple):

        if iterable.__class__ is tuple:

            return tuple(items_gen)

        else:

            return iterable.__class__(*items_gen)

    elif isinstance(iterable, set):

        return set(items_gen)

    elif isinstance(iterable, str):

        return "".join(items_gen)

    else:

        return items_gen

def join_paths(path1, path2):

    """

    Joins two paths as one would expect -- i.e. just like the os.path.join

    function except for doing crazy things when the second argument is an

    absolute path.

    :param path1: first path

    :type path1: str

    :param path2: second path

    :type path2: str

    :return: path1 and path2 joined with the file separator

    :rtype: str

    """

    # os.path.normpath doesn't squash two starting slashes

    path1.replace("//", "/")

    return os.path.normpath(path1 + os.path.sep + path2)

def get_hashing_algorithm(fingerprint):

    """

    Get hashing algorithm for the given fingerprint or None if fingerprint of

    unsupported length is given.

    :param fingerprint: hexa fingerprint to get the hashing algorithm for

    :type fingerprint: hexadecimal str

    :return: one of the hashlib.* hash objects

    :rtype: hashlib.HASH object

    """

    hashes = (hashlib.md5(), hashlib.sha1(), hashlib.sha224(),

              hashlib.sha256(), hashlib.sha384(), hashlib.sha512())

    if len(fingerprint) % 2 == 1:

        return None

    num_bytes = len(fingerprint) / 2

    for hash_obj in hashes:

        # pylint: disable-msg=E1103

        if hash_obj.digest_size == num_bytes:

            return hash_obj

    return None

def get_file_fingerprint(fpath, hash_obj):

    """

    Get fingerprint of the given file with the given hashing algorithm.

    :param fpath: path to the file to get fingerprint for

    :type fpath: str

    :param hash_obj: hashing algorithm to get fingerprint with

    :type hash_obj: hashlib.HASH

    :return: fingerprint of the given file with the given algorithm

    :rtype: hexadecimal str

    """

    with open(fpath, "rb") as fobj:

        bsize = 4 * 1024

        # process file as 4 KB blocks

        buf = fobj.read(bsize)

        while buf:

            hash_obj.update(buf)

            buf = fobj.read(bsize)

    return hash_obj.hexdigest()