class Matrix:
    def __init__(self, name, m, n, values):
        self.name = name
        self.m = m
        self.n = n
        self.values = values

    def __str__(self):
        rows = [self.values[i:i+self.n] for i in range(0, len(self.values), self.n)]
        return f'{self.name} = \n' + '\n'.join([' '.join(map(str, row)) for row in rows])

    def __repr__(self):
        return f'Matrix({self.name}, {self.m}, {self.n}, {self.values})'


class MatrixMultiplier:
    def __init__(self, matrices=None):
        self.matrices = [] if matrices is None else matrices

    def create_matrix(self, name):
        m = int(input(f'Introduceți numărul de rânduri pentru matricea {name}: '))
        n = int(input(f'Introduceți numărul de coloane pentru matricea {name}: '))
        values = []
        for i in range(m):
            for j in range(n):
                value = int(input(f'Introduceți valoarea pentru poziție ({i}, {j}) în matricea {name}: '))
                values.append(value)
        matrix = Matrix(name, m, n, values)
        self.matrices.append(matrix)

    def add_matrices(self, name1, name2):

        matrix1 = next(matrix for matrix in self.matrices if matrix.name == name1)
        matrix2 = next(matrix for matrix in self.matrices if matrix.name == name2)
        if matrix1.m != matrix2.m or matrix1.n != matrix2.n:
            raise ValueError('Cele două matrice trebuie să aibă aceleași dimensiuni')
        result = [matrix1.values[i] + matrix2.values[i] for i in range(len(matrix1.values))]
        return Matrix(f'{name1}+{name2}', matrix1.m, matrix1.n, result)

    def multiply_matrices(self, name1, name2):

        matrix1 = next(matrix for matrix in self.matrices if matrix.name == name1)
        matrix2 = next(matrix for matrix in self.matrices if matrix.name == name2)
        if matrix1.n != matrix2.m:
            raise ValueError('Numărul de coloane din prima matrice trebuie să se potrivească cu numărul de rânduri din a doua matrice')
        result = []
        for i in range(matrix1.m):
            for j in range(matrix2.n):
                val = 0
                for k in range(matrix1.n):
                    val += matrix1.values[i * matrix1.n + k] * matrix2.values[k * matrix2.n + j]
                result.append(val)
        return Matrix(f'{name1}{name2}', matrix1.m, matrix2.n, result)

    def scalar_multiply(self, name, scalar):

        matrix = next(matrix for matrix in self.matrices if matrix.name == name)
        result = [scalar * val for val in matrix.values]
        matrix.values = result
        matrix.name = f'{scalar}{name}'
        return Matrix(f'{scalar}{name}', matrix.m, matrix.n, result)

    def flip_matrix(self, name):

        matrix = next(matrix for matrix in self.matrices if matrix.name == name)
        result = []
        for j in range(matrix.n):
            for i in range(matrix.m):
                result.append(matrix.values[i * matrix.n + j])
        matrix.values = result
        matrix.m, matrix.n = matrix.n, matrix.m
        matrix.name = f'{name}^T'
        return matrix

    def subtract_matrices(self, name1, name2):

        matrix1 = next(matrix for matrix in self.matrices if matrix.name == name1)
        matrix2 = next(matrix for matrix in self.matrices if matrix.name == name2)
        if matrix1.m != matrix2.m or matrix1.n != matrix2.n:
            raise ValueError('Cele două matrice trebuie să aibă aceleași dimensiuni')
        result = [matrix1.values[i] - matrix2.values[i] for i in range(len(matrix1.values))]
        return Matrix(f'{name1}-{name2}', matrix1.m, matrix1.n, result)

    def proprocess_transpose(self, ops):

        ops = ops.split()
        remove_idxs = []
        for i in range(len(ops)):

            if ops[i] == 't':
                name = ops[i - 1]
                matrix = self.flip_matrix(name)

                name = name + '^T'

                self.matrices[self.matrices.index(next(m for m in self.matrices if m.name == name))] = matrix
                remove_idxs.append(i)
                ops[i-1] = f'{name}'

        ops = [ops[i] for i in range(len(ops)) if i not in remove_idxs]
        return ' '.join(ops)

    def custom_input(self, ops):

        ops = self.proprocess_transpose(ops)

        ops = ops.split()

        name = ops[0]

        matrix = next(m for m in self.matrices if m.name == name)
        #print(locals())
        for i in range(1, len(ops), 2):
            op = ops[i]
            if op == 's':
                scalar = int(ops[i + 1])
                matrix = self.scalar_multiply(matrix.name, scalar)
                self.matrices[self.matrices.index(next(m for m in self.matrices if m.name == matrix.name))] = matrix
            elif op == '+':
                name2 = ops[i + 1]
                matrix2 = next(matrix for matrix in self.matrices if matrix.name == name2)
                matrix = self.add_matrices(matrix.name, matrix2.name)
                self.matrices.append(matrix)
            elif op == '-':
                name2 = ops[i + 1]
                matrix2 = next(matrix for matrix in self.matrices if matrix.name == name2)
                matrix = self.subtract_matrices(matrix.name, matrix2.name)
                self.matrices.append(matrix)
        return matrix
def print_menu():
    print('1. Creați matrice')
    print('2. Înmulțiți matrice')
    print('3. Înmulțire scalară')
    print('4. Adăugați matrice')
    print('5. Scăderea matricilor')
    print('6. Flip Matrix')
    print('7. Intrare personalizată')
    print('8. Ieșire')
def main():
    matrix_multiplier = MatrixMultiplier()
    while True:
        print_menu()
        choice = input('Introdu alegerea ta: ')
        if choice == '1':
            name = input('Introduceți numele matricei: ')
            matrix_multiplier.create_matrix(name)
        elif choice == '2':
            name1 = input('Introduceți numele primei matrice: ')
            name2 = input('Introduceți numele celei de-a doua matrice: ')
            try:
                result = matrix_multiplier.multiply_matrices(name1, name2)
                print(result)
            except ValueError as e:
                print(e)
        elif choice == '3':
            name = input('Introduceți numele primei matrice: ')
            scalar = int(input('Introduceți scalarul: '))
            result = matrix_multiplier.scalar_multiply(name, scalar)
            print(result)
        elif choice == '4':
            name1 = input('Introduceți numele primei matrice: ')
            name2 = input('Introduceți numele celei de-a doua matrice: ')
            try:
                result = matrix_multiplier.add_matrices(name1, name2)
                print(result)
            except ValueError as e:
                print(e)
        elif choice == '5':
            name1 = input('Introduceți numele primei matrice: ')
            name2 = input('Introduceți numele celei de-a doua matrice: ')
            try:
                result = matrix_multiplier.subtract_matrices(name1, name2)
                print(result)
            except ValueError as e:
                print(e)
        elif choice == '6':
            name = input('Introduceți numele matrice: ')
            result = matrix_multiplier.flip_matrix(name)
            print(result)
        elif choice == '7':
            update_con = input('Vrei sa salvezi noile valori?: ')
            if update_con in ['yes', 'da', 'y']:
                update_con = 1
            operations = input('Introduceți succesiunea operațiilor cu matrice: ')
            try:
                result = matrix_multiplier.custom_input(operations)
                print(result)
            except (ValueError, IndexError) as e:
                print(e)
        else:
            print('Alegere nevalidă')
if __name__ == "__main__":
    main()