import math
from tabulate import tabulate

def matmul(matrix_a: list[list[float | int]], matrix_b: list[list[float | int]]) -> list[list[float | int]]:
    """Multipliziert zwei Matrizen, die als verschachtelte Listen dargestellt sind.

    Args:
        matrix_a: Die erste Matrix als 2D-Liste (Größe m x n).
        matrix_b: Die zweite Matrix als 2D-Liste (Größe n x p).

    Returns:
        Die resultierende Produkt-Matrix als 2D-Liste (Größe m x p).

    Raises:
        ValueError: Wenn die Breite der ersten Matrix (Anzahl der Spalten)
                    nicht der Höhe der zweiten Matrix (Anzahl der Zeilen) entspricht.
    """
    if not matrix_a or not matrix_b or not matrix_a[0] or not matrix_b[0]:
        raise ValueError("Die Matrizen dürfen nicht leer sein.")

    rows_a = len(matrix_a)
    cols_a = len(matrix_a[0])
    rows_b = len(matrix_b)
    cols_b = len(matrix_b[0])

    # Überprüfung, ob die Multiplikation mathematisch möglich ist
    if cols_a != rows_b:
        raise ValueError(
            f"Multiplikation nicht möglich: Breite von matrix_a ({cols_a}) "
            f"stimmt nicht mit der Höhe von matrix_b ({rows_b}) überein."
        )

    # Berechnung des Matrixprodukts über eine List Comprehension
    result = [
        [
            sum(matrix_a[i][k] * matrix_b[k][j] for k in range(cols_a))
            for j in range(cols_b)
        ]
        for i in range(rows_a)
    ]

    return result


def transpose(matrix: list[list[float | int]]) -> list[list[float | int]]:
    """Transponiert eine Matrix (tauscht Zeilen und Spalten).

    Args:
        matrix: Die zu transponierende Matrix als 2D-Liste (m x n).

    Returns:
    Die transponierte Matrix als 2D-Liste (n x m).

    Raises:
        ValueError: Wenn die Matrix leer ist oder ungleichmäßig viele Spalten
                    in den Zeilen besitzt (keine echte Matrix).
    """
    if not matrix or not matrix[0]:
        raise ValueError("Die Matrix darf nicht leer sein.")

    cols = len(matrix[0])

    # Überprüfen, ob alle Zeilen exakt gleich viele Spalten haben
    for row in matrix:
        if len(row) != cols:
            raise ValueError(
                "Ungleichmäßige Matrix: Nicht jede Zeile hat dieselbe Anzahl an Spalten."
            )

    # Transponieren via Zip-Unpacking
    return [list(row) for row in zip(*matrix)]



def rot_2D(theta: float) -> list[list[float]]:
    """Gibt die 2D-Rotationsmatrix für einen gegebenen Winkel theta (in Bogenmaß) zurück.

    Args:
        theta: Der Rotationswinkel in Bogenmaß (Radians).

    Returns:
        Die 2x2-Rotationsmatrix als 2D-Liste:
        [[cos(theta), -sin(theta)],
         [sin(theta),  cos(theta)]]
    """
    cos_theta = math.cos(theta)
    sin_theta = math.sin(theta)

    return [
        [cos_theta, -sin_theta],
        [sin_theta, cos_theta]
    ]


if __name__ == "__main__":

 #matmul prüfung
    matrix_a = [ [ 3, 4, -1, 4 ],
                    [ -2, 2, 5, 1 ]
                ]
    matrix_b = [ [ 1, 3, -2 ],
                [ 2, 5, 1 ],
                [ -1, 4, -4 ],
                [ 2, 3, 6 ]
                ]
    matrix_c = matmul(matrix_a, matrix_b)
    print("Ergebnis C = A * B:")
    for row in matrix_c:
        print(row)

    try:
        matrix_c = [[1,2],[3,4]]
        matrix_d = [[5,6]]
        ergebnis = matmul(matrix_c, matrix_d)
        print("Ergebnis:", ergebnis)

    except ValueError as e:
        print(f"Fehler abgefangen (matmul): {e}")

#Agent Fehler ausgebessert: list[list/[float | int] -> list[list[float | int]
#Gut gelöst -> TypeHints beachtet und verständlichen DocString; Ruff check passed

#transpose prüfung
    matrix = [
        [1, 2, 3],
        [4, 5, 6]
    ]
    print(transpose(matrix))
    # Erwartete Ausgabe:
    # [
    # [1, 4],
    # [2, 5],
    # [3, 6]
    # ]
    matrix_2 = [
        [1, 2, 3],
        [4, 5, 6]
    ]
    print(transpose(matrix_2))

    try:
        un_matrix = [
            [1, 2, 3],
            [4, 5]
        ]

        ergebnis = transpose(un_matrix)
        print("Ergebnis:", ergebnis)

    except ValueError as e:
        print(f"Fehler erfolgreich abgefangen (transpose): {e}")

    #rotation prüfung
    theta = math.pi / 2 #1,57...
    print(f"Winkel: {math.degrees(theta)} Grad (pi / 2)")
    print(rot_2D(theta))
    print(tabulate(rot_2D(1.0)))

print("hallo")