import numpy as np
import time
import concurrent.futures


def multiply_matrices(matrix_a, matrix_b):
    if len(matrix_a[0]) != len(matrix_b):
        raise ValueError("Incompatible matrix dimensions for multiplication")

    result = [[0 for _ in range(len(matrix_b[0]))] for _ in range(len(matrix_a))]

    for i in range(len(matrix_a)):
        for j in range(len(matrix_b[0])):
            for k in range(len(matrix_b)):
                result[i][j] += matrix_a[i][k] * matrix_b[k][j]

    return result


def multiply_matrices_parallel(matrix_a, matrix_b, num_threads):
    if len(matrix_a[0]) != len(matrix_b):
        raise ValueError("Incompatible matrix dimensions for multiplication")

    result = [[0 for _ in range(len(matrix_b[0]))] for _ in range(len(matrix_a))]

    with concurrent.futures.ThreadPoolExecutor(max_workers=num_threads) as executor:
        futures = []
        for i in range(len(matrix_a)):
            futures.append(executor.submit(_multiply_row, matrix_a, matrix_b, i))

        for i, future in enumerate(concurrent.futures.as_completed(futures)):
            result[i] = future.result()

    return result


def _multiply_row(matrix_a, matrix_b, i):
    row_result = [0 for _ in range(len(matrix_b[0]))]
    for j in range(len(matrix_b[0])):
        for k in range(len(matrix_b)):
            row_result[j] += matrix_a[i][k] * matrix_b[k][j]
    return row_result


def benchmark_sequential(size):
    matrix_a = np.random.rand(size, size)
    matrix_b = np.random.rand(size, size)

    start_time = time.time()
    multiply_matrices(matrix_a, matrix_b)
    end_time = time.time()

    return end_time - start_time


def benchmark_parallel(size, num_threads):
    matrix_a = np.random.rand(size, size)
    matrix_b = np.random.rand(size, size)

    start_time = time.time()
    multiply_matrices_parallel(matrix_a, matrix_b, num_threads)
    end_time = time.time()

    return end_time - start_time


if __name__ == "__main__":
    sizes = [300]
    threads = [2, 8]

    for size in sizes:
        sequential_time = benchmark_sequential(size)
        print(f"Время обычное: {sequential_time} с")
        print(f"Размер матрицы: {size}x{size}")

    for thread in threads:
        for size in sizes:
            parallel_time = benchmark_parallel(size, thread)
            print(f"Размер матрицы: {size}x{size}")
            print(f"Время параллельное: {parallel_time} с")
            print(f"Потоков:  {thread}")