"""Einfache Matrixoperationen:
Multiplikation, Transponieren und Drehung um 90° im Uhrzeigersinn.
"""

from __future__ import annotations
from typing import List

# Eine Matrix ist hier eine Liste von Zeilen mit Zahlen.
Matrix = List[List[float]]


def matmul(A: Matrix, B: Matrix) -> Matrix:
    """Multipliziert zwei Matrizen A und B."""

    # Leere Matrizen sind nicht erlaubt.
    if not A or not B:
        raise ValueError("Matrizen dürfen nicht leer sein")

    # Prüfen, ob alle Zeilen von A gleich lang sind.
    spalten_A = len(A[0])
    if any(len(zeile) != spalten_A for zeile in A):
        raise ValueError("Matrix A ist nicht rechteckig")

    # Prüfen, ob alle Zeilen von B gleich lang sind.
    spalten_B = len(B[0])
    if any(len(zeile) != spalten_B for zeile in B):
        raise ValueError("Matrix B ist nicht rechteckig")

    # Für A × B muss die Spaltenzahl von A
    # der Zeilenzahl von B entsprechen.
    if spalten_A != len(B):
        raise ValueError(
            f"Multiplikation nicht möglich: A hat {spalten_A} Spalten, "
            f"B hat {len(B)} Zeilen"
        )

    ergebnis: Matrix = []

    # Jede Zeile von A mit jeder Spalte von B kombinieren.
    for i in range(len(A)):
        ergebnis_zeile: List[float] = []

        for j in range(spalten_B):
            # Produkte der passenden Elemente bilden und addieren.
            wert = sum(A[i][k] * B[k][j] for k in range(spalten_A))
            ergebnis_zeile.append(wert)

        ergebnis.append(ergebnis_zeile)

    return ergebnis


def transpose(M: Matrix) -> Matrix:
    """Vertauscht Zeilen und Spalten einer Matrix."""

    if not M:
        raise ValueError("Matrix darf nicht leer sein")

    # Eine rechteckige Matrix muss gleich lange Zeilen haben.
    spalten = len(M[0])
    if any(len(zeile) != spalten for zeile in M):
        raise ValueError("Matrix ist nicht rechteckig")

    # Die Elemente jeder Spalte werden zu einer neuen Zeile.
    return [[M[i][j] for i in range(len(M))] for j in range(spalten)]


def rotate90_clockwise(M: Matrix) -> Matrix:
    """Dreht eine Matrix um 90° im Uhrzeigersinn."""

    if not M:
        raise ValueError("Matrix darf nicht leer sein")

    spalten = len(M[0])
    if any(len(zeile) != spalten for zeile in M):
        raise ValueError("Matrix ist nicht rechteckig")

    # Erst transponieren, dann jede neue Zeile umkehren.
    transponiert = [
        [M[i][j] for i in range(len(M))]
        for j in range(spalten)
    ]
    return [zeile[::-1] for zeile in transponiert]


if __name__ == "__main__":
    # Beispiel: Eine 2×3-Matrix mal eine 3×2-Matrix.
    A = [[1, 2, 3], [4, 5, 6]]
    B = [[7, 8], [9, 10], [11, 12]]
    print("A × B:")
    print(matmul(A, B))  # [[58, 64], [139, 154]]

    # Eine Einheitsmatrix verändert eine Matrix bei der Multiplikation nicht.
    C = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
    D = [[2, 3, 4], [5, 6, 7], [8, 9, 10]]
    print("D × C:")
    print(matmul(D, C))  # ergibt wieder D

    # Zeilen und Spalten tauschen.
    E = [[1, 2, 3], [4, 5, 6]]
    print("Transponierte Matrix:")
    print(transpose(E))  # [[1, 4], [2, 5], [3, 6]]

    # Erst transponieren, dann die Zeilen umkehren.
    F = [[1, 2, 3], [4, 5, 6]]
    print("90° im Uhrzeigersinn gedreht:")
    print(rotate90_clockwise(F))  # [[4, 1], [5, 2], [6, 3]]

def rot_2D(theta: float):
    """Return a 2x2 rotation matrix for angle theta in radians."""
    import math
    c = math.cos(theta)
    s = math.sin(theta)
    return [[c, -s], [s, c]]
# Katzen-Test