import foundation
from foundation import progress
import os
import requests
import tarfile


def humanReadableTimeDifference(seconds):
    """
    Convert time difference in seconds to a human readable format.

    For example, time difference of 125 seconds will be returned as 2:05
    """

    hours = int(seconds) // 60 // 60
    seconds = seconds - hours * 60 * 60
    minutes = int(seconds) // 60
    seconds = seconds - minutes * 60
    if hours == 0:
        return "%02d:%05.2f" % (minutes, seconds)
    else:
        return "%02d:%02d:%05.2f" % (hours, minutes, seconds)


def humanReadableTimeToSeconds(time):
    """
    Convert human readable string like HH:MM:SS to seconds.
    """

    tokens = time.split(".")
    result = 0
    if len(tokens) == 2:
        result = float("0." + tokens[1])
    mult = 1
    for token in reversed(tokens[0].split(":")):
        result += int(token) * mult
        mult *= 60
    return result


def queryMainScene(filepath, callbacks):
    """
    Return the equivalent to bpy.context.scene
    """

    from blendfile import blendfile

    with blendfile.open_blend(filepath) as blend:
        # There is no bpy.context.scene, we get it from the main window
        window_manager = [block for block in blend.blocks
                          if block.code == b'WM'][0]
        window = window_manager.get_pointer(b'winactive')
        screen = window.get_pointer(b'screen')
        scene = screen.get_pointer(b'scene')

        output = []
        for callback in callbacks:
            output.append(callback(scene))
        return output


def queryCurrentFrame(filepath):
    """
    Get frame number to render.
    """

    def get_cfra(scene):
        return scene.get((b'r', b'cfra'))
    cfra, = queryMainScene(filepath, [get_cfra])
    return cfra


def humanReadableSizeToMegabytes(size):
    if size[-1] == 'K':
        return float(size[:-1]) / 1024
    elif size[-1] == 'M':
        return float(size[:-1])
    else:
        return float(size)


def humanReadableSize(size):
    return "{} Mb" . format(size)


def downloadFile(url, filename):
    """
    Download file form given UTR and save it to filename
    """
    r = requests.get(url, stream=True)
    downloaded_size = 0
    total_size = 0
    if 'Content-length' in r.headers:
        total_size = r.headers['Content-length']
    with open(filename, 'wb') as f:
        for chunk in r.iter_content(chunk_size=1024):
            if chunk:
                f.write(chunk)
                downloaded_size += len(chunk)
                if total_size != 0:
                    progress.progress(downloaded_size, total_size)
    if total_size != 0:
        progress.progressClear()


def unpackArchive(filename, directory):
    """
    Unpack archive <filename> to given <directory>
    """
    if filename.endswith(".tar.bz2"):
        tar = tarfile.open(name=filename, mode="r:bz2")
        tar.extractall(directory)
    else:
        # TODO(sergey): Need to support more archive types.
        pass


def stripSensitiveInfo(s):
    """
    Strip any possibly sensitive information we want to avoid from the logs.
    """
    root_dir = getBundleRootDirectory()
    s = s.replace(root_dir, "<FARM_DIR>")
    return s

########################################
#  Directories manipulation
########################################


def getBundleRootDirectory():
    """
    Get fuill file path to the root directory of benchmark bundle.
    """
    script_directory = os.path.dirname(os.path.realpath(__file__))
    return os.path.dirname(os.path.dirname(script_directory))


def getGlobalConfigDirectory():
    """
    Get configuration directory global for the all components of this bundle.
    """
    return os.path.join(getBundleRootDirectory(), "config")