import os
import sys

from .refit_logger import logger

# TODO: Make a standard function for reading config files, so it is
# reusable


def get_int_length(number: int) -> int:
    """Takes an number as its input and returns the numbers diget amount.

    This function takes an integer number, converts it into a string and
    converts its digets. It returns the length of the number as an integer.

    Args:
        number (int): The number you need the length of

    Examples:
        >>> get_int_length(100)
        '3'
        >>> get_int_length(10)
        '2'
        >>> get_int_length(4000)
        '4'
    """
    number_string = str(number)
    amount_didgets = len(number_string)
    return amount_didgets


def get_standard_name_number(current_number: int, number_str_length: int) -> str:
    """Returns a number string filled to the length of the input number

    This function returns the number in a standartized way as a string.
    As input it takes the current number of the string to build and a
    number which determines the length of the string.

    Args:
        current_number (str):   The current number of the item.
        number_str_length (int):    The length of the string which gets returned.

    Examples:
        >>> get_standard_name_number(1, 2)
        '01'
        >>> get_standard_name_number(23, 4)
        '0023'
    """
    # logger.debug(
    #     f"FUNC: get_standard_name_number() index={current_number} string_length={number_str_length}"
    # )
    temp_current_number = str(current_number)
    standard_name_number = str.zfill(temp_current_number, number_str_length)
    # logger.debug(
    #     f"FUNC: get_standard_name_number() return value= '{standard_name_number}'"
    # )
    return standard_name_number


def get_standard_folder_name(name: str) -> str:
    """Returnes a standard name either from a list or the default value.

    This function sanitizes the input, which gets passed as a list or None from
    argparse. The function either chooses the first entry of the list, given to
    the --name argument or returns the default value 'directory'

    Args:
        name (list[str] | None):    A list of names if passed to the --name argument
                                    or None if no name is passed.

    Returns:
        str:    The file name. Returns 'file' as default value if name argument is 'None'
                otherwise the first element of the list.

    Examples:
        >>> get_standard_file_name(None)
        'file'
        >>> get_standard_file_name(["example"])
        'example'
        >>> get_standard_file_name(["directory_name", "example"])
        'directory_name'
    """

    standard_folder_name = name[0] if name is not None else "directory"

    return standard_folder_name


def get_standard_file_name(name) -> str:
    """Returnes a name either from a list or the default value.

    This function sanitizes the input, which gets passed as a list or None from
    argparse. The function either chooses the first entry of the list, given to
    the --name argument or returns the default value 'file'

    Args:
        name (list[str] | None):    A list of names if passed to the --name argument
                                    or None if no name is passed.

    Returns:
        str:    The file name. Returns 'file' as default value if name argument is 'None'
                otherwise the first element of the list.

    Examples:
        >>> get_standard_file_name(None)
        'file'
        >>> get_standard_file_name(["example"])
        'example'
        >>> get_standard_file_name(["file_name", "example"])
        'file_name'
    """

    standard_file_name = name[0] if name is not None else "file"

    return standard_file_name


def get_current_path(path) -> str:
    """Checks if the path argument is emty and applies the current directory as working path.

    This function takes an list with strings as an input. If the input is `None` the current
    directory is taken as the working directory.
    If the path is passed, a check for its existence takes place.

    Args:
        path (str): _The current working directory._

    Returns:
        str: _Returns the path of the current directory after check for existence_
    """

    logger.debug(f"FUNC: get_current_path() MSG: entered function with path = '{path}'")
    if path is None:
        # Set the current directory if none is passed with the command.
        path = "."
        # logger.warning(
        #     f"FUNC: {get_current_path.__name__}() MSG: Path now has the value: '{path}'"
        # )
        return path
    else:
        # Checks if the path, entered by the user, exists.
        if os.path.exists(path) is True:
            # logger.debug(
            #     f"FUNC: {get_current_path.__name__} MSG: Path '{path}' exists, continue...."
            # )
            return path
        else:
            ERROR_MESSAGE = (
                f"FUNC: {get_current_path.__name__} MSG: '{path}' does not exist"
            )
            logger.warning(ERROR_MESSAGE)
            print(ERROR_MESSAGE)
            sys.exit(1)


def create_linear_directories(input_path, target_depth, current_depth, name):
    """Creates the linear directories for the x*y pattern"""

    # TODO: - add dynamic name input
    #       - add docstring
    # logger.debug(
    #     f"FUNC: create_linear_directories(entered) VALUES: path='{input_path}', target_depth='{target_depth}', current_depth='{current_depth}'"
    # )

    if name is None:
        base_name = "level"
    else:
        base_name = name[1]

    if current_depth > target_depth:
        return

    directory_name = (
        base_name
        + "_"
        + get_standard_name_number(current_depth, get_int_length(target_depth))
    )
    path = os.path.join(input_path, directory_name)

    os.mkdir(path)

    create_linear_directories(path, target_depth, current_depth + 1, name)


def create_parallel_directories(input_path, target_depth, width, name):
    """Creates directories after the pattern x*y"""

    # TODO: - add dynamic name input
    #       - add docstring
    logger.debug(
        f"FUNC: create_parallel_directories(entered) VALUES: path='{input_path}', target_depth='{target_depth}', width='{width}', name={name}"
    )
    if name is None:
        base_name = "branch"
    else:
        base_name = name[0]

    for i in range(width):
        directory_name = (
            base_name + "_" + get_standard_name_number(i, get_int_length(width))
        )
        path = os.path.join(input_path, directory_name)
        os.mkdir(path)

        create_linear_directories(
            input_path=path,
            target_depth=target_depth,
            current_depth=0,
            name=name,
        )