#Was die Aufgabe war:
#opencode verwenden und python code generieren lassen
#den generierten code auf funktionalität und clean code prüfen
#in compute.py sollten wir eine matrixmultiplikation anwenden
#und das modul danach um eine Transposition und 2d rotationmatrix erweitern
#gefordert: type hints, docstrings und fehlerbehandlung mit valueerror

#auf kurz:
#Agent generiert code
#wir prüfen ihn selbst
#pep 8 beachten
#verständlicher name
#type hints
#docstrings
#fehler sinnvoll behandeln
#mindestens einen verbesserungspunkt am Agentencode erkennen


"""Matrix-Operationen ohne externe Bibliotheken (reine Python-Listen)."""

import math
from typing import List #da wir eine aktuelle python version verwenden wäre eingebaute schreibweise mit list[float] beser

Matrix = List[List[float]] #Matrix ist hier ein typ alias für eine verschachtelte liste aus zahlen dadurch werden die type hints lesbarer

#Funktion matmul: zwei matrizen multiplizieren
def matmul(matrix_a: Matrix, matrix_b: Matrix) -> Matrix:
    #jetzt kommt mein docstring hier dokumentiert open code:
    #was macht die funktion?
    #wleche parameter bekommt sie? (args)
    #was gibt sie zurück?(returns)
    #welche fehler können auftreten?(raises)
    """Multipliziere zwei Matrizen ``A * B``.  #

    Args:
        matrix_a: Linke Matrix der Form ``(m, n)``.
        matrix_b: Rechte Matrix der Form ``(n, p)``.

    Returns:
        Die Produktmatrix der Form ``(m, p)``.

    Raises:
        ValueError: Wenn ``matrix_a`` weniger Spalten hat, als ``matrix_b``
            Zeilen hat, oder wenn eine der Matrizen leer ist.
    """
    if not matrix_a or not matrix_b: #sicherheitsprüfung wenn matrix a leer oder matrix b leer ist, breche ab
        raise ValueError("Matrizen dürfen nicht leer sein.") #fehler wird absichtlich ausgeführt

#die größe wird bestimmt
    rows_a = len(matrix_a)
    cols_a = len(matrix_a[0])
    rows_b = len(matrix_b)
    cols_b = len(matrix_b[0])

#Dimensionsprüfung
    #hier ist auch mein zweiter verbesserungspunkt siehe ausführlich unten
    if cols_a != rows_b:
        raise ValueError(
            "Breite der ersten Matrix muss der Höhe der zweiten entsprechen."
        )

    result: Matrix = []
    for i in range(rows_a): #i steht für die zeile von a
        result_row: List[float] = []
        for j in range(cols_b): #j steht für die spalte von b
            total = 0
            for k in range(cols_a): #k läuft durch die einszlnen werte die miteinander multipliziert und addiert werden
                total += matrix_a[i][k] * matrix_b[k][j] #"nimm einen wert aus der aktuellen zeile von a multipliziere ihn mit den passenden wert aus der aktuellen spalte von b und addiere das ergebnis zu total
            result_row.append(total) #fügt die fertige zeile zur ergebnismatrix hinzu
        result.append(result_row)

    return result

#Zeilen und Spalten einer Matrix vertauschen
def transpose(matrix: Matrix) -> Matrix:
    """Transponiere eine Matrix (Zeilen werden zu Spalten).

    Args:
        matrix: Nicht leere, rechteckige Matrix.

    Returns:
        Die transponierte Matrix.

    Raises:
        ValueError: Wenn die Matrix leer ist oder die Zeilen unterschiedlich
            viele Spalten enthalten.
    """
    if not matrix or not matrix[0]:
        raise ValueError("Die Matrix darf nicht leer sein.")

    num_cols = len(matrix[0])
    if any(len(row) != num_cols for row in matrix):
        raise ValueError("Alle Zeilen müssen gleich viele Spalten haben.")

    return [[matrix[row][col] for row in range(len(matrix))]
            for col in range(num_cols)]



#Rotationsmatrix für einen Winkel erzeugen
def rot_2D(theta: float) -> Matrix:
    """Erzeuge die 2D-Rotationsmatrix für einen Winkel ``theta``.

    Args:
        theta: Rotationswinkel im Bogenmaß.

    Returns:
        Die Rotationsmatrix ``[[cos(theta), -sin(theta)],
        [sin(theta), cos(theta)]]``.
    """
    cosine = math.cos(theta)
    sine = math.sin(theta)
    return [[cosine, -sine], [sine, cosine]]


if __name__ == "__main__": #führe den testcode nur aus wenn compute.py direkt gestartet wird
    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)

    matrix = [
        [1, 2, 3],
        [4, 5, 6],
    ]

    print("\nTransponierte Matrix:")
    for row in transpose(matrix):
        print(row)

    print("\nRotationsmatrix für 90 Grad (pi / 2):")
    for row in rot_2D(math.pi / 2):
        print(row)




#Code Beurteilung durch opencode generiert
#1. Der matmul-DocString sagt "weniger Spalten", obwohl der Code allgemein auf != prüft
#Das sollte präziser dokumentiert werden weil zb 4 != 3 ist True aber ValueError
#der Code prüft nicht weniger sondern generell nicht gleich


#2.opencode verwendet noch typing.list obwohl meine python version schon die
#moderne Schreibweise mit list[...] möglich ist und sogar im skript verwendet wird