def getFloatArray(matrix):
    return [float(element) for element in matrix]


def matrixMinusMatrix(matrix_1, matrix_2):
    return np.subtract(np.array(matrix_1), np.array(getFloatArray(matrix_2)))


def matrixMultiplyVector(matrix, vector):
    result_array = [0 for index in range(0, len(matrix))]

    for line_index in range(0, len(matrix)):
        line_multiplication = 0
        for elements in matrix[line_index]:
            value = elements[0]
            column_index = elements[1]
            line_multiplication += value * vector[column_index]
            result_array[line_index] = line_multiplication

    return result_array


def verifyMatrix(matrix):
    for row in range(0, len(matrix)):
        flag_found_in_line = False
        for col in range(0, len(matrix[row])):
            if matrix[row][col][1] == row:
                flag_found_in_line = True
                if abs(matrix[row][col][0]) < Tema4.Epsilon:
                    return False
        if not flag_found_in_line:
            return False
    return True


def getValue(matrix, row, col):
    for index_array in range(0, len((matrix[row]))):
        if matrix[row][index_array][1] == col:
            return matrix[row][index_array][0]


def testConditions(xGS, index_line, elem, convergent, divergent):
    if abs(xGS[index_line] - elem) >= Tema4.Epsilon:
        convergent = False
    if abs(xGS[index_line] - elem) <= Tema4.DELTA_max:
        divergent = False
    return convergent, divergent


def calculateSums(matrix, index_line, xGS):
    count = 0
    sum_below_diag, sum_above_diag = 0, 0
    # Calculam sumele de care avem nevoie
    while count < len(matrix[index_line]) and matrix[index_line][count][1] < index_line:
        sum_below_diag += matrix[index_line][count][0] * xGS[matrix[index_line][count][1]]
        count += 1
    count += 1
    while count < len(matrix[index_line]) and matrix[index_line][count][1] < len(xGS):
        sum_above_diag += matrix[index_line][count][0] * xGS[matrix[index_line][count][1]]
        count += 1
    return sum_below_diag, sum_above_diag


def Gauss_Siedel(matrix, vector, arraySize):
    vector = getFloatArray(vector)
    # Initializam vectorul xGS pe care-l vom folosii mai tarziu
    xGS = [0.0 for index in range(0, arraySize)]
    # Folosim un for in care vom merge de maxim K_max ori
    convergent = True
    k = 0
    for k in range(0, Tema4.K_max):
        convergent = True
        divergent = True
        # Folosim un for pentru a parcurge fiecare linie
        for index_line in range(0, arraySize):
            # Resetam sumele de fiecare data
            sum_below_diag, sum_above_diag = calculateSums(matrix, index_line, xGS)
            # Calculam valoarea elementului
            value = (vector[index_line] - sum_below_diag - sum_above_diag) / getValue(matrix, index_line, index_line)
            # Verificam conditiile descrise in PDF de oprire
            convergent, divergent = testConditions(xGS, index_line, value, convergent, divergent)
            # Updatam vectorul cu valoarea elementului
            xGS[index_line] = value
        if convergent or divergent:
            break
    if convergent and k != Tema4.K_max - 1:
        return xGS, k
    else:
        return [], k