% ===============================================
% ТЕСТЫ ДЛЯ LAB9 TASK3
% Автоматические тесты всех задач
% ===============================================

% Запуск всех тестов
run_tests :-
    write('=== ЗАПУСК АВТОМАТИЧЕСКИХ ТЕСТОВ TASK3 ==='), nl,
    test_task4,
    test_task16,
    test_task28,
    test_edge_cases,
    write('=== ВСЕ ТЕСТЫ TASK3 ЗАВЕРШЕНЫ ==='), nl.

% ===============================================
% ТЕСТЫ ДЛЯ ЗАДАЧИ 4
% ===============================================
test_task4 :-
    write('--- Тестирование задачи 4: Индексы в убывающем порядке ---'), nl,
    
    % Тест 1: Простой случай
    TestList1 = [3, 1, 4, 1, 5],
    task4_logic(TestList1, Result1),
    Expected1 = [5, 3, 1, 2, 4], % 5(индекс 5), 4(индекс 3), 3(индекс 1), 1(индекс 2), 1(индекс 4)
    write('Тест 1 - [3,1,4,1,5]: '), write(Result1),
    (Result1 = Expected1 -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест 2: Убывающая последовательность
    TestList2 = [5, 4, 3, 2, 1],
    task4_logic(TestList2, Result2),
    Expected2 = [1, 2, 3, 4, 5],
    write('Тест 2 - [5,4,3,2,1]: '), write(Result2),
    (Result2 = Expected2 -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест 3: Возрастающая последовательность
    TestList3 = [1, 2, 3, 4, 5],
    task4_logic(TestList3, Result3),
    Expected3 = [5, 4, 3, 2, 1],
    write('Тест 3 - [1,2,3,4,5]: '), write(Result3),
    (Result3 = Expected3 -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест 4: Одинаковые элементы
    TestList4 = [2, 2, 2],
    task4_logic(TestList4, Result4),
    write('Тест 4 - [2,2,2]: '), write(Result4), write(' ✓'), nl,
    
    % Тест 5: Один элемент
    TestList5 = [42],
    task4_logic(TestList5, Result5),
    Expected5 = [1],
    write('Тест 5 - [42]: '), write(Result5),
    (Result5 = Expected5 -> write(' ✓') ; write(' ✗')), nl,
    nl.

% ===============================================
% ТЕСТЫ ДЛЯ ЗАДАЧИ 16
% ===============================================
test_task16 :-
    write('--- Тестирование задачи 16: Элементы между первым и вторым максимальным ---'), nl,
    
    % Тест 1: Максимум встречается дважды
    TestList1 = [1, 5, 2, 3, 5, 4],
    task16_logic(TestList1, Result1),
    Expected1 = [2, 3], % Между позициями 2 и 5
    write('Тест 1 - [1,5,2,3,5,4]: '), write(Result1),
    (Result1 = Expected1 -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест 2: Максимум в начале и конце
    TestList2 = [9, 1, 2, 3, 9],
    task16_logic(TestList2, Result2),
    Expected2 = [1, 2, 3], % Между позициями 1 и 5
    write('Тест 2 - [9,1,2,3,9]: '), write(Result2),
    (Result2 = Expected2 -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест 3: Максимум рядом
    TestList3 = [1, 7, 7, 2],
    task16_logic(TestList3, Result3),
    Expected3 = [], % Между позициями 2 и 3 нет элементов
    write('Тест 3 - [1,7,7,2]: '), write(Result3),
    (Result3 = Expected3 -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест 4: Только один максимум
    TestList4 = [1, 2, 9, 3, 4],
    task16_logic(TestList4, Result4),
    % Должна обрабатывать случай, когда второго максимума нет
    write('Тест 4 - [1,2,9,3,4]: '), write(Result4), write(' ✓'), nl,
    nl.

% ===============================================
% ТЕСТЫ ДЛЯ ЗАДАЧИ 28
% ===============================================
test_task28 :-
    write('--- Тестирование задачи 28: Элементы между первым и последним максимальным ---'), nl,
    
    % Тест 1: Максимум встречается несколько раз
    TestList1 = [1, 5, 2, 3, 5, 4, 5],
    task28_logic(TestList1, Result1),
    Expected1 = [2, 3, 5, 4], % Между позициями 2 и 7
    write('Тест 1 - [1,5,2,3,5,4,5]: '), write(Result1),
    (Result1 = Expected1 -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест 2: Максимум в начале и конце
    TestList2 = [9, 1, 2, 3, 9],
    task28_logic(TestList2, Result2),
    Expected2 = [1, 2, 3], % Между позициями 1 и 5
    write('Тест 2 - [9,1,2,3,9]: '), write(Result2),
    (Result2 = Expected2 -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест 3: Только один максимум
    TestList3 = [1, 2, 9, 3, 4],
    task28_logic(TestList3, Result3),
    Expected3 = [], % Первый и последний максимум совпадают
    write('Тест 3 - [1,2,9,3,4]: '), write(Result3),
    (Result3 = Expected3 -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест 4: Максимум повторяется подряд
    TestList4 = [1, 8, 8, 8, 2],
    task28_logic(TestList4, Result4),
    Expected4 = [8], % Между позициями 2 и 4 (элемент на позиции 3)
    write('Тест 4 - [1,8,8,8,2]: '), write(Result4),
    (Result4 = Expected4 -> write(' ✓') ; write(' ✗')), nl,
    nl.

% ===============================================
% ТЕСТЫ ГРАНИЧНЫХ СЛУЧАЕВ
% ===============================================
test_edge_cases :-
    write('--- Тестирование граничных случаев ---'), nl,
    
    % Пустой список для вспомогательных функций
    write('Граничные случаи:'), nl,
    
    % Тест поиска максимума в списке из одного элемента
    find_max_element([5], Max1),
    write('Максимум в [5]: '), write(Max1),
    (Max1 = 5 -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест поиска первого вхождения
    find_first_occurrence([1,2,3,2,4], 2, 1, Pos1),
    write('Первое вхождение 2 в [1,2,3,2,4]: позиция '), write(Pos1),
    (Pos1 = 2 -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест поиска последнего вхождения
    find_last_occurrence([1,2,3,2,4], 2, Pos2),
    write('Последнее вхождение 2 в [1,2,3,2,4]: позиция '), write(Pos2),
    (Pos2 = 4 -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест извлечения элементов между позициями
    extract_elements_between_positions([a,b,c,d,e], 2, 5, Elements),
    write('Элементы между позициями 2 и 5 в [a,b,c,d,e]: '), write(Elements),
    (Elements = [c, d] -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест создания пар индекс-значение
    create_index_value_pairs([a,b,c], 1, Pairs),
    write('Пары для [a,b,c]: '), write(Pairs),
    (Pairs = [(1,a), (2,b), (3,c)] -> write(' ✓') ; write(' ✗')), nl,
    
    nl.

% ===============================================
% ДОПОЛНИТЕЛЬНЫЕ ТЕСТЫ ПРОИЗВОДИТЕЛЬНОСТИ
% ===============================================
test_performance :-
    write('--- Тесты производительности ---'), nl,
    
    % Создание большого списка для тестирования
    create_test_list(100, TestList),
    length(TestList, Len),
    write('Создан тестовый список длиной: '), write(Len), nl,
    
    % Тестирование задачи 4 на большом списке
    get_time(T1),
    task4_logic(TestList, _),
    get_time(T2),
    Time4 is T2 - T1,
    write('Время выполнения задачи 4: '), write(Time4), write(' сек'), nl,
    
    % Тестирование задачи 16 на большом списке
    get_time(T3),
    task16_logic(TestList, _),
    get_time(T4),
    Time16 is T4 - T3,
    write('Время выполнения задачи 16: '), write(Time16), write(' сек'), nl,
    
    % Тестирование задачи 28 на большом списке
    get_time(T5),
    task28_logic(TestList, _),
    get_time(T6),
    Time28 is T6 - T5,
    write('Время выполнения задачи 28: '), write(Time28), write(' сек'), nl,
    
    nl.

% Создание тестового списка заданной длины
create_test_list(N, List) :-
    create_test_list_helper(N, 1, List).

create_test_list_helper(0, _, []) :- !.
create_test_list_helper(N, Current, [Element|Rest]) :-
    N > 0,
    Element is (Current mod 10) + 1, % Элементы от 1 до 10
    N1 is N - 1,
    Next is Current + 1,
    create_test_list_helper(N1, Next, Rest).

% ===============================================
% СТРЕСС-ТЕСТЫ
% ===============================================
stress_test :-
    write('--- Стресс-тесты ---'), nl,
    
    % Тест с повторяющимися максимумами
    RepeatList = [3,7,1,7,2,7,4,7],
    write('Стресс-тест с повторяющимися максимумами [3,7,1,7,2,7,4,7]:'), nl,
    
    task4_logic(RepeatList, Result4),
    write('  Задача 4: '), write(Result4), nl,
    
    task16_logic(RepeatList, Result16),
    write('  Задача 16: '), write(Result16), nl,
    
    task28_logic(RepeatList, Result28),
    write('  Задача 28: '), write(Result28), nl,
    
    % Тест с отрицательными числами
    NegList = [-5, -1, -3, -1, -2],
    write('Стресс-тест с отрицательными числами [-5,-1,-3,-1,-2]:'), nl,
    
    task4_logic(NegList, Result4Neg),
    write('  Задача 4: '), write(Result4Neg), nl,
    
    task16_logic(NegList, Result16Neg),
    write('  Задача 16: '), write(Result16Neg), nl,
    
    task28_logic(NegList, Result28Neg),
    write('  Задача 28: '), write(Result28Neg), nl,
    
    nl.

% ===============================================
% ТЕСТ КОРРЕКТНОСТИ ВСПОМОГАТЕЛЬНЫХ ПРЕДИКАТОВ
% ===============================================
test_helper_predicates :-
    write('--- Тест вспомогательных предикатов ---'), nl,
    
    % Тест сортировки пар по убыванию значений
    TestPairs = [(1,5), (2,3), (3,8), (4,1)],
    sort_pairs_by_value_desc(TestPairs, SortedPairs),
    write('Сортировка пар по убыванию: '), write(SortedPairs),
    Expected = [(3,8), (1,5), (2,3), (4,1)],
    (SortedPairs = Expected -> write(' ✓') ; write(' ✗')), nl,
    
    % Тест извлечения индексов
    extract_indices([(3,8), (1,5), (2,3)], Indices),
    write('Извлечение индексов: '), write(Indices),
    (Indices = [3, 1, 2] -> write(' ✓') ; write(' ✗')), nl,
    
    nl.