from typing import List

import numpy as np
import requests
import gradio as gr

from huggingface_hub import (
    create_repo,
    get_full_repo_name,
    upload_file,
)


def file_as_a_string(name_list: List[str]) -> str:
    """
    Returns the file that is going to be created in the new space as string.

    :param name_list: list of space names
    :return: file as a string
    """
    return (
        f"import gradio as gr"
        f"\nname_list = {name_list} "
        f"\ninterfaces = [gr.Interface.load(name) for name in name_list]"
        f"\ngr.mix.Parallel(*interfaces).launch()"
    )


def combine_several_space_inputs(names: str) -> str:
    """
    Combines several space inputs and returns the file that is going to be created in the new space as string.

    :param names: space inputs
    :return: file as a string
    """
    name_list = names.split("\n")
    interfaces = [gr.Interface.load(name) for name in name_list]
    if not control_input_and_output_types(interfaces):
        print("Spaces have different input or output types, could not combine them!")
        return ""
    else:
        return file_as_a_string(name_list)


def control_input_and_output_types(interface_list: List["gr.Interface"]) -> bool:
    """
    Controls whether if input and output types of the given interfaces are the same.

    :param interface_list: list of interfaces
    :return: True if all input and output types are the same
    """
    first_input_types = [type(input) for input in interface_list[0].input_components]
    first_output_types = [
        type(output) for output in interface_list[0].output_components
    ]
    for interface in interface_list:
        interface_input_types = [type(input) for input in interface.input_components]
        if not np.all(
            interface_input_types == first_input_types
        ):  # Vectorize the comparison and don't use double for loop
            return False
        interface_output_types = [
            type(output) for output in interface.output_components
        ]
        if not np.all(interface_output_types == first_output_types):
            return False

    return True


def check_space_name_availability(hf_token: str, space_name: str) -> bool:
    """
    Check whether if the space_name is currently used.

    :param hf_token: hugging_face token
    :param space_name:
    :return: True if the space_name is available
    """
    repo_name = get_full_repo_name(model_id=space_name, token=hf_token)
    url = f"https://huggingface.co/spaces/{repo_name}"
    response = requests.get(url)
    return not response.status_code == 200


def space_builder(spaces: str, hf_token: str, username: str, space_name: str, space_description: str) -> str:
    """
    Creates a space with given inputs
    :param spaces:
    :param hf_token:
    :param username:
    :param space_name:
    :param space_description:
    :return:
    """
    # return "Thank you for using the draft, it will be completed later"
    if spaces == "" or hf_token == "" or username == "" or space_name == "" or space_description == "":
        return "Please fill all the inputs"
    try:
        if check_space_name_availability(hf_token, space_name):
            return "The space_name is available"
        else:
            return "The space_name is already used for the token's user"
    except Exception as ex:
        return Exception


iface = gr.Interface(
    fn=space_builder,
    inputs=[
        gr.inputs.Textbox(
            lines=4,
            placeholder=(
                f"Drop space links at each line, ie:"
                f"\nspaces/Norod78/ComicsHeroHD"
                f"\nspaces/Amrrs/gradio-sentiment-analyzer"
            ),
        ),
        gr.inputs.Textbox(lines=1, placeholder="HF Write Token"),
        gr.inputs.Textbox(lines=1, placeholder="Your username"),
        gr.inputs.Textbox(lines=1, placeholder="Name for the space"),
        gr.inputs.Textbox(lines=1, placeholder="Description for the space"),
    ],
    outputs="text",
)
iface.launch()