import sympy as sp
import time
import random

def genmatrix(rowcol, intmax, dif) :
    # generate a random matrices
    a = sp.randMatrix(rowcol, rowcol, 0, intmax)
    # if determinant non-zero, radnom value less than difficulty, set a to its inverse
    if a.det() != 0 and random.random() <= dif :
        a = a.inv()
    return a

# in function to take arbitrary matrix input from user
def inmat(rowcol) :
    # initialise list of lists
    mat=[[]]*rowcol
    # take input from user into list
    print("Enter line by line with entries separated by space:")
    for i in range(rowcol):
        mat[i]=input().split(" ")
        for j in range(len(mat[i])) :
            # convert list using nsimplify in order to take rational number symbolically
            mat[i][j] = sp.nsimplify(mat[i][j])
    return mat

# multcheck function to check if two matrices are multiplied together
def multcheck(a, b, rowcol, intmax) :
    sp.pprint(b)
    print("Multiply these two matrices together")
    # return bool based on if input equals the two matrices multiplied together
    return (sp.Matrix(inmat(rowcol)) == a*b)

# detcheck function to check if the determinant of the matrix is correct
def detcheck(a, b, rowcol, intmax):
    det = sp.det(a)
    # return bool based on if input equals determinant
    return (det == sp.nsimplify(input("What is the determinant of this matrix?: ")))

# invcheck function to check if the inverse of the matrix is correct
def invcheck(a, b, rowcol, intmax):
    det = a.det()
    if det != 0 :
        # return bool based on if input equals inverse of matrix
        print("What is the inverse of this matrix?")
        return (sp.Matrix(inmat(rowcol)) == a.inv())

# eigcheck function to check if the eigenvalues are correct
def eigcheck(a, b, rowcol, intmax):
    eigs = a.eigenvals()
    for i in range(len(eigs)) :
        val = sp.nsimplify(input("Input eigenvalue: "))
        if not (val in eigs and eigs[val] == sp.nsimplify(input("Input its algebraic multiplicity: "))) :
            # return false if the eigenvalue not in dictionary and wrong alg multiplicity
            return False
    return True

def diagcheck(a, b, rowcol, intmax):
    return (a.diagonalize()[1] == sp.Matrix(inmat(rowcol)))

# practice function
def practice(t) :
    count = 0
    rowcol = int(input("What size of matrix do you want to practice with? "))
    intmax = int(input("What maximum size of integer do you want the matrix to be made out of? "))
    dif = float(input("What difficulty (probability for a matrix of rational values between 0, 1) do you want? "))

    # choose the function of the program that you want
    if t == "mult" :
        f = multcheck
    elif t == "det" :
        f = detcheck
    elif t == "inv" :
        f = invcheck
    elif t == "eig" :
        f = eigcheck
    elif t == "diag" :
        f = diagcheck
    else :
        exit()

    # initialise time measurement
    tic = time.perf_counter()

    # infinite loop of practice
    while True :
        a = genmatrix(rowcol, intmax, dif)
        b = genmatrix(rowcol, intmax, dif)

        # infinite loop until user succeeds 
        while True :
            # if diagcheck, make sure the matrix is diagonalizable
            if t == "diag" :
                while not a.is_diagonalizable :
                    a = genmatrix(rowcol, intmax, dif)
            sp.pprint(a)
            # if return of function is True
            if f(a, b, rowcol, intmax) :
                # take time interval
                toc = time.perf_counter()
                tictoc=toc-tic
                # increment count
                count += 1
                # print success message
                print("Correct! You have solved", count, "problems in %.2f seconds" %tictoc)
                break
            else :
                # print failure message
                print("Try again")
                continue

# take input from user on the type of practice they want to do
t = input("What do you want to practice? (mult, det, inv, eig, diag) ")
practice(t)