import re
import numpy as np


def verify(message, expected, actual):
    a = "========================="
    print(a)
    print(message)
    if type(actual) != type(expected) or actual != expected:
        print("FAILED!")

        print(f"Expected value: {expected}")
        print(f"Actual value: {actual}")

        print(a)
        return False
    else:
        print("SUCCESS!")
        print(a)
        return True


def verify_all(dataset):
    summa_success = int()
    summa_failed = int()
    for result in dataset:
        if verify(result[0], result[1], result[2]):
            summa_success += 1
        else:
            summa_failed += 1
    print("Total:", len(dataset), "Successful:", summa_success, "Failed:", summa_failed)
    return True


def word_count(text):

    if text is None:
        return []

    if not isinstance(text, str):
        return []

    c = []
    final = {}
    a = re.sub("[^А-Яа-я-A-Z-a-z ]", " ", text).lower()
    b = str(a).split()
    c = list(b)
    unique_array, count_array = np.unique(c, return_counts=True)
    final = zip(unique_array, count_array)
    final2 = list(final)
    return final2


def sum_letters_in_sentence(dataset_sentence):

    if dataset_sentence is None:
        return -1, -1

    if not isinstance(dataset_sentence, str):
        return -1, -1

    lower = 0
    upper = 0

    for count in dataset_sentence:
        if count.isalpha():
            if count.islower():
                lower += 1
            else:
                upper += 1

    return upper, lower
# Функция, которая считает кол-во больших и маленьких букв в строке.
# Тип возвращаемого значения - двуразрядный кортеж,
# где первый элемент - кол-во больших букв,
# а второй элемент - кол-во маленьких букв.



dataset = [# Проверочные тесты, что вообще что-то работает
            ("slis0", (4, 6), sum_letters_in_sentence("АаБбВвГгдд")),
            ("slis1", (6, 4), sum_letters_in_sentence("AaBbCcDdEE")),
            ("slis2", (10, 10), sum_letters_in_sentence("AaBbCcDdEEАаБбВвГгдд")),
            ("slis3", (10, 10), sum_letters_in_sentence("A aBbC cDdEE АаБб ВвГг дд")),
            ("slis4", (10, 10), sum_letters_in_sentence("Aa,.BbCc%&§DdEEА&/(аБбВвГгдд")),

            # Тесты на пустые значения
            ("slis5", (0, 0), sum_letters_in_sentence('')),
            ("slis6", (-1, -1), sum_letters_in_sentence(None)),

            # Тесты на неверный тип
            ("slis7", (-1, -1), sum_letters_in_sentence(123)),
            ("slis8", (-1, -1), sum_letters_in_sentence(True)),

            # Тесты на редкие случаи
            ("slis9", (0, 0), sum_letters_in_sentence('123')),
            ("slis10", (0, 1), sum_letters_in_sentence('a')),
            ("slis11", (1, 0), sum_letters_in_sentence('B')),
            ("slis12", (0, 0), sum_letters_in_sentence(' ')),
        ]

dataset2 = [# Проверочные тесты, что вообще что-то работает
            ("word_count0", [('нашел', 1), ('пришел', 1), ('ушел', 1), ('я', 3)], word_count('Я пришел, я ушел, я нашел')),
            ("word_count1", [('слово', 4), ('точно', 1)], word_count("Слово: Слово! Точно слово? Слово...")),

            # Тесты на пустые значения
            ("word_count2", [], word_count('')),
            ("word_count3", [], word_count(None)),

            # Тесты на неверный тип
            ("word_count4", [], word_count(123)),
            ("word_count5", [], word_count(True)),

            # Тесты на редкие случаи
            ("word_count6", [('слово', 1)], word_count("Слово")),
            ("word_count7", [('слово', 1)], word_count("Слово ")),
            ("word_count8", [('слово', 1)], word_count(" Слово")),
            ("word_count9", [('слово', 2)], word_count("Слово.Слово")),
           ]

verify_all(dataset)
verify_all(dataset2)