from core.builtin_concepts import BuiltinConcepts


def is_same_success(sheerka, return_values):
    """
    Returns True if all returns values are successful and have the same value
    :param sheerka:
    :param return_values:
    :return:
    """
    assert isinstance(return_values, list)

    if not return_values[0].status:
        return False

    reference = sheerka.value(return_values[0].value)

    for return_value in return_values[1:]:
        if not return_value.status:
            return False

        actual = sheerka.value(return_value.value)
        if actual != reference:
            return False

    return True


def expect_one(context, return_values):
    """
    Checks if there is at least one success return value
    If there is more than one, check if it's the same value
    :param context:
    :param return_values:
    :return:
    """

    if not isinstance(return_values, list):
        return return_values

    sheerka = context.sheerka

    if len(return_values) == 0:
        return sheerka.ret(
            context.who,
            False,
            sheerka.new(BuiltinConcepts.IS_EMPTY, obj=return_values),
            parents=return_values)

    successful_results = [item for item in return_values if item.status]
    number_of_successful = len(successful_results)
    # total_items = len(return_values)

    # remove errors when a winner is found
    if number_of_successful == 1:
        # log.debug(f"1 / {total_items} good item found.")
        return sheerka.ret(
            context.who,
            True,
            successful_results[0].body,
            parents=return_values)

    # too many winners, which one to choose ?
    if number_of_successful > 1:
        if is_same_success(sheerka, successful_results):
            return sheerka.ret(
                context.who,
                True,
                successful_results[0].value,
                parents=return_values)
        else:
            return sheerka.ret(
                context.who,
                False,
                sheerka.new(BuiltinConcepts.TOO_MANY_SUCCESS, obj=successful_results),
                parents=return_values)

    # only errors, i cannot help you
    return sheerka.ret(
        context.who,
        False,
        sheerka.new(BuiltinConcepts.TOO_MANY_ERRORS, obj=return_values),
        parents=return_values)