import math

from tabulate import tabulate


def matmul(matrix_a:list[list[float]], matrix_b: list[list[float]]) -> list[list[float]]:
    """
    Add two numbers together.
    :param matrix_a: The first Matrix
    :type matrix_a: list[list[float]]
    :param matrix_b: The second Matrix
    :type matrix_b: list[list[float]]
    :return: The Matrix Multiplication of matrix_a and matrix_b
    :rtype: list[list[float]]
    """
    try:
        if len(matrix_a[0]) != len(matrix_b):
            raise ValueError("Differing Matrix Size")
        target_height = len(matrix_a)
        target_width = len(matrix_b[0])

        end_matrix : list[list[float]]= []


        for height in range(target_height):
            end_matrix.append([])
            for width in range(target_width):
                row = matrix_a[height]
                column_ = []
                for b in matrix_b:
                    column_.append(b[width])
                result_quarter = 0
                for i in range(len(row)):
                    result_quarter += row[i] * column_[i]
                end_matrix[height].append(float(result_quarter))

        return end_matrix
    except ValueError:
        print("An Error has occurred")
    except IndexError:
        print("Tried to call non-existing Index")
    except TypeError:
        print("Tried to insert not a Number")



def transpose(matrix:list[list[float]]) -> list[list[float]]:
    """
    Transposes a matrix.
    :param matrix: The Matrix, that will be transposed
    :type matrix: list[list[float]]
    :return: The transposed matrix
    :rtype: list[list[float]]
    """

    transposed_matrix = []
    for x in range(len(matrix[0])):
        column = []
        for b in matrix:
            column.append(b[x])
        transposed_matrix.append(column)

    return transposed_matrix

def rot_2d(angle:float) -> list[list[float]]:
    """
    Creates a Rotation Matrix out of the given angle
    :param angle: The rotation in radians
    :type angle: float
    :return: The Rotation Matrix
    :rtype: list[list[float]]
    """
    sin = round(math.sin(angle), 4)
    cos = round(math.cos(angle), 4)
    return [[cos, -sin],
            [sin, cos]]

def rot_3d(angle: float, axis: str) -> list[list[float]]:
    """
    Creates a 3D Rotation Matrix out of the given angle and axis
    :param angle: The rotation in radians
    :type angle: float
    :param axis: The Axis on which it rotates; only "x", "y" or "z"
    :type axis: str
    :return: The 3D Rotation Matrix
    :rtype: list[list[float]]
    """
    axis = axis.lower()
    sin = round(math.sin(angle), 4)
    cos = round(math.cos(angle), 4)
    if axis == "x":
        return[[1, 0, 0],
                [0, cos, -sin],
                [0, sin, cos]]
    if axis == "y":
        return[[cos, 0, sin],
                [0, 1, 0],
                [-sin, 0, cos]]
    if axis == "z":
        return [[cos, -sin, 0],
                [sin, cos, 0],
                     [0, 0, 1]]

    raise ValueError

# For Both below add the Doc String!
def project_ortho(point: tuple[float, float, float], scale: float = 1) -> tuple[float, float]:
    """
    Projects a 3D Position into an orthogonal 2D View
    :param point: The 3D Point
    :type point: tuple[float, float, float]
    :param scale: The scale by which the point gets scaled; regular is 1.0
    :type scale: float
    :return: The 3D Point on a 2D plane
    :rtype: tuple[float, float]
    """
    return (point[0] * scale,
            point[1] * scale)

def project_perspective(point: tuple[float, float, float], focal_length: float = 1.0,
                        scale: float = 1.0, camera_distance: float = 4.0) -> tuple[float, float]:
    """
    Projects a 3D Position into a perspective 2D View
    :param point: The 3D Point
    :type point: tuple[float, float, float]
    :param focal_length: strength of perspective; regular is 1.0
    :type focal_length: float
    :param scale: The scale by which the point gets scaled; regular is 1.0
    :type scale: float
    :param camera_distance: How far the Camera is away from the point; regular is 4.0
    :return: The 3D Point on a 2D plane
    :rtype: tuple[float, float]
    """
    return (point[0] * focal_length * scale / (point[2] + camera_distance),
            point[1] * focal_length * scale / (point[2] + camera_distance), )


def print_matrix(matrix:list[list[float]]) -> None:
    for row in matrix:
        print(row)

if __name__ == "__main__":
    matrix_bsp_a = [[1, 2, 3], [4, 5, 6]]
    matrix_bsp_b = [[1, 2], [3, 4], [5, 6]]
    matrix_bsp_c = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    matrix_bsp_d = [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

    if False:
        matrix_bsp_result = matmul(matrix_bsp_c, matrix_bsp_d)
        print_matrix(matrix_bsp_result)

    if False:
        matrix_bsp_result = transpose(matrix_bsp_d)
        #print_matrix(matrix_bsp_c)
        print_matrix(matrix_bsp_result)

    if True:
        #print_matrix(rot_2d(math.pi*.25))
        print(tabulate(rot_2d(1.33)))


    # Test Kommenter

    print("Done")