import random
import time
import typing
import numpy as np


# Task 1
def filter(A: np.ndarray, threshold):
    position_list = np.argwhere(np.array(A) >= threshold)
    return [tuple(x) for x in position_list]


A = np.array([[random.random() * 50 for _ in range(5)] for _ in range(5)])


# tuple_list = filter(A, 25.3)
# print(A)
# print(tuple_list)

# Task 2
def check_moves_conditions(x, y, index_x, index_y):
    if (index_x == x or index_y == y or index_x + index_y == x + y or index_x - index_y == x - y) and not (
            index_x == x and index_y == y):
        return 1
    else:
        return 0


def get_queen_moves(y: int, x: int):
    moves = [[check_moves_conditions(x, y, index_x, index_y) for index_x in range(8)] for index_y in range(8)]
    return moves


# print(np.array(get_queen_moves(2, 4)))

# Task 3
# A = np.zeros((8, 8))
# A[0, 0] = 1
# A[2, 1] = 1
# A[1, 4] = 1
# A[4, 2] = 1
# A[6, 3] = 1
# A[3, 5] = 1
# A[5, 6] = 1
# A[7, 7] = 1


def check_queen_puzzle(A):
    positions = filter(A, 1)
    queens_moves = [np.array(get_queen_moves(x[0], x[1])) for x in positions]
    aggregated = np.sum(queens_moves, axis=0)
    unsafe_queens = not np.any([True for x in positions if aggregated[x[0], x[1]] != 0])
    return unsafe_queens


# print(A)
# print(check_queen_puzzle(A))


# Task 4
def generate_system(X):
    A = np.random.uniform(-1, 1, X.size ** 2).reshape((X.size, X.size))
    A[np.diag_indices(X.size)] = np.sum(np.abs(A), axis=1)
    B = np.dot(A, X)
    return A, B


# Task 5
def solve_system(A: np.ndarray, B: np.ndarray):
    a_diagonal = A.diagonal()
    A = -(A / np.expand_dims(a_diagonal, axis=1))
    B /= a_diagonal
    np.fill_diagonal(A, 0)
    X = np.zeros(B.size)
    for iteration in range(10000):
        old_X = np.array(X)
        X = np.dot(A, X) + B
        if np.isclose(X, old_X).all():
            break
    return X


X = np.array([1, 2, 3, 4, 5])
A, B = generate_system(X)
solved_x = np.dot(np.linalg.inv(A), B)
print(solved_x)
solved_x = solve_system(A, B)
print(solved_x)

for number_of_equations in [100, 200, 500, 2000, 5000]:
    X = np.array([x for x in range(number_of_equations)])
    A, B = generate_system(X)

    time0_inverse = time.time()
    inverse_x = np.dot(np.linalg.inv(A), B)
    print(f"Inverse time for {number_of_equations} equations: {time.time()-time0_inverse}")
    time0_jacobi = time.time()
    jacobi_x = solve_system(A, B)
    print(f"Jacobi time for {number_of_equations} equations: {time.time()-time0_jacobi}")