import logging
import os
import platform
import subprocess
from datetime import datetime

logger = logging.getLogger()


def launch_url(url):
    if subprocess.run(['which', 'xdg-open'], capture_output=True).returncode == 0:
        subprocess.run(['xdg-open', url])  # linux
    elif subprocess.run(['which', 'open'], capture_output=True).returncode == 0:
        subprocess.run(['open', url])  # macos
    elif subprocess.run(['which', 'start'], capture_output=True).returncode == 0:
        subprocess.run(['start', url])  # windows - need to validate this works
    else:
        logger.error(f"No valid launchers found to launch url: {url}")


def file_exists_in_mounts(filepath):
    """
    Check if a file exists in any mounted directory.
    It searches for the file in common mount points like '/Volumes', '/mnt', and '/media'.
    Returns the path to the file in the mount if found, otherwise returns None.

    Example:
    Before: filepath = '/path/to/file.txt'
    After: '/Volumes/ExternalDrive/path/to/file.txt'
    """

    def get_path_components(path):
        path = os.path.normpath(path)
        components = []
        while True:
            path, component = os.path.split(path)
            if component:
                components.append(component)
            else:
                if path:
                    components.append(path)
                break
        components.reverse()
        return components

    # Get path components of the directory of the file
    path_components = get_path_components(os.path.dirname(filepath).strip('/'))

    # Iterate over possible root paths - this may need to be rethought for Windows support
    for root in ['/Volumes', '/mnt', '/media']:
        if os.path.exists(root):
            # Iterate over mounts in the root path
            for mount in os.listdir(root):
                # Since we don't know the home directory, we iterate until we find matching parts of the path
                matching_components = [s for s in path_components if s in mount]
                for component in matching_components:
                    possible_mount_path = os.path.join(root, mount, filepath.split(component)[-1].lstrip('/'))
                    if os.path.exists(possible_mount_path):
                        return possible_mount_path


def get_time_elapsed(start_time=None, end_time=None):

    from string import Template

    class DeltaTemplate(Template):
        delimiter = "%"

    def strfdelta(tdelta, fmt='%H:%M:%S'):
        d = {"D": tdelta.days}
        hours, rem = divmod(tdelta.seconds, 3600)
        minutes, seconds = divmod(rem, 60)
        d["H"] = '{:02d}'.format(hours)
        d["M"] = '{:02d}'.format(minutes)
        d["S"] = '{:02d}'.format(seconds)
        t = DeltaTemplate(fmt)
        return t.substitute(**d)

    # calculate elapsed time
    elapsed_time = None

    if start_time:
        if end_time:
            elapsed_time = end_time - start_time
        else:
            elapsed_time = datetime.now() - start_time

    elapsed_time_string = strfdelta(elapsed_time) if elapsed_time else None
    return elapsed_time_string


def get_file_size_human(file_path):
    size_in_bytes = os.path.getsize(file_path)

    # Convert size to a human readable format
    if size_in_bytes < 1024:
        return f"{size_in_bytes} B"
    elif size_in_bytes < 1024 ** 2:
        return f"{size_in_bytes / 1024:.2f} KB"
    elif size_in_bytes < 1024 ** 3:
        return f"{size_in_bytes / 1024 ** 2:.2f} MB"
    elif size_in_bytes < 1024 ** 4:
        return f"{size_in_bytes / 1024 ** 3:.2f} GB"
    else:
        return f"{size_in_bytes / 1024 ** 4:.2f} TB"


# Convert path to the appropriate format for the current platform
def system_safe_path(path):
    if platform.system().lower() == "windows":
        return os.path.normpath(path)
    return path.replace("\\", "/")


def current_system_os():
    return platform.system().lower().replace('darwin', 'macos')


def current_system_os_version():
    return platform.mac_ver()[0] if current_system_os() == 'macos' else platform.release().lower()


def current_system_cpu():
    # convert all x86 64 to "x64"
    return platform.machine().lower().replace('amd64', 'x64').replace('x86_64', 'x64')


def resources_dir():
    resources_directory = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
                                       'resources')
    return resources_directory


def config_dir():
    config_directory = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
                                       'config')
    return config_directory