#include <stdlib.h>
#include <string.h>
#include "matrix.h"
#include <stdio.h>


// Matrix erzeugen
Matrix createMatrix(unsigned int rows, unsigned int cols)
{
    Matrix matrix;
    matrix.buffer = NULL;
    matrix.rows = 0;
    matrix.cols = 0;

    if (rows == 0 || cols == 0)
        return matrix; // leere Matrix

    matrix.buffer = (MatrixType *)malloc(rows * cols * sizeof(MatrixType));
    if (!matrix.buffer)
        return matrix; // Speicher konnte nicht reserviert werden

    matrix.rows = rows;
    matrix.cols = cols;

    // Initialisiere alle Werte auf UNDEFINED_MATRIX_VALUE
    for (unsigned int i = 0; i < rows * cols; i++)
        matrix.buffer[i] = UNDEFINED_MATRIX_VALUE;

    return matrix;
}

// Matrix Speicher freigeben
void clearMatrix(Matrix *matrix)
{
    if (!matrix) return;

    if (matrix->buffer)
        free(matrix->buffer);

    matrix->buffer = NULL;
    matrix->rows = 0;
    matrix->cols = 0;
}

// Wert setzen
void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
{
    if (!matrix.buffer) return;
    if (rowIdx >= matrix.rows || colIdx >= matrix.cols) return;

    matrix.buffer[rowIdx * matrix.cols + colIdx] = value;
}

// Wert auslesen
MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
{
    if (!matrix.buffer) return UNDEFINED_MATRIX_VALUE;
    if (rowIdx >= matrix.rows || colIdx >= matrix.cols) return UNDEFINED_MATRIX_VALUE;

    return matrix.buffer[rowIdx * matrix.cols + colIdx];
}
// Matrizen addieren
Matrix add(const Matrix m1, const Matrix m2)
{
    if (!m1.buffer || !m2.buffer) return createMatrix(0,0);

    // gleiche Dimension
    if (m1.rows == m2.rows && m1.cols == m2.cols)
    {
        Matrix result = createMatrix(m1.rows, m1.cols);
        if (!result.buffer) return result;

        for (unsigned int r = 0; r < m1.rows; r++)
            for (unsigned int c = 0; c < m1.cols; c++)
                result.buffer[r * result.cols + c] = m1.buffer[r * m1.cols + c] + m2.buffer[r * m2.cols + c];

        return result;
    }

    // Matrix2 ist ein Spaltenvektor
    if (m1.rows == m2.rows && m2.cols == 1)
    {
        Matrix result = createMatrix(m1.rows, m1.cols);
        if (!result.buffer) return result;

        for (unsigned int r = 0; r < m1.rows; r++)
            for (unsigned int c = 0; c < m1.cols; c++)
                result.buffer[r * result.cols + c] = m1.buffer[r * m1.cols + c] + m2.buffer[r];

        return result;
    }

    // Matrix1 ist ein Spaltenvektor
    if (m1.rows == m2.rows && m1.cols == 1)
    {
        Matrix result = createMatrix(m2.rows, m2.cols);
        if (!result.buffer) return result;

        for (unsigned int r = 0; r < m2.rows; r++)
            for (unsigned int c = 0; c < m2.cols; c++)
                result.buffer[r * result.cols + c] = m1.buffer[r] + m2.buffer[r * m2.cols + c];

        return result;
    }

    // passt nicht
    return createMatrix(0,0);
}
// Matrizen multiplizieren
Matrix multiply(const Matrix m1, const Matrix m2)
{
    if (!m1.buffer || !m2.buffer) return createMatrix(0,0);
    if (m1.cols != m2.rows) return createMatrix(0,0);

    Matrix result = createMatrix(m1.rows, m2.cols);
    if (!result.buffer) return result;

    for (unsigned int r = 0; r < m1.rows; r++)
        for (unsigned int c = 0; c < m2.cols; c++)
        {
            MatrixType sum = 0;
            for (unsigned int k = 0; k < m1.cols; k++)
                sum += m1.buffer[r * m1.cols + k] * m2.buffer[k * m2.cols + c];
            result.buffer[r * result.cols + c] = sum;
        }

    return result;
}