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

// TODO Matrix-Funktionen implementieren

Matrix createMatrix(unsigned int rows, unsigned int cols)
{
    Matrix m;
    if(rows == 0 || cols == 0){
        m.rows = 0;
        m.cols = 0;
        m.buffer = NULL;
        return m;
    }
    m.rows = rows;
    m.cols = cols;
    m.buffer = calloc(rows * cols, sizeof(MatrixType)); // matrix flach angelegt a11 a12 a13 a21 a22...
    if(m.buffer == NULL){ // speicherreservierung fehlgeschlagen
        m.rows = 0;
        m.cols = 0;
    }
    return m;
}

void clearMatrix(Matrix *matrix)
{
    matrix->rows = 0;
    matrix->cols = 0;
    
    free(matrix->buffer);
    

    matrix->buffer = NULL;
}

void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
{
    // genau einen wert in der matrix setzen
    int idx = rowIdx * matrix.cols + colIdx; // flache matrix betrachten
    matrix.buffer[idx] = value;
}

MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
{
    // einen wert in der matrix returnen
    if(rowIdx >= matrix.rows || colIdx >= matrix.cols || matrix.buffer == NULL){
        return(MatrixType)0;
    }
    int idx = rowIdx * matrix.cols + colIdx; 
    return matrix.buffer[idx];
}

Matrix add(const Matrix matrix1, const Matrix matrix2)
{
    // elementweise addition (beide matrizen selbe größe)
    if(matrix1.rows == matrix2.rows && matrix1.cols == matrix2.cols){
        Matrix resultmatrix = createMatrix(matrix1.rows, matrix1.cols);
        for(int i = 0; i < (matrix1.rows * matrix1.cols); i++){
            resultmatrix.buffer[i] = matrix1.buffer[i] + matrix2.buffer[i];
        }
        return resultmatrix;
    }
    // broadcasting
    // A Matrix B Vektor
    if(matrix1.rows == matrix2.rows && matrix2.cols == 1){
        Matrix resultmatrix = createMatrix(matrix1.rows, matrix1.cols);
        // TODO
        for(int rows = 0; rows < matrix1.rows; rows++){
            for(int cols = 0; cols < matrix1.cols; cols++){
                MatrixType wertm1 = getMatrixAt(matrix1, rows, cols);
                MatrixType wertm2 = getMatrixAt(matrix2, rows, 0);
                setMatrixAt(wertm1 + wertm2, resultmatrix, rows, cols);
            }
        }
        return resultmatrix;
    }

    // A Vektor B Matrix
    if(matrix1.rows == matrix2.rows && matrix1.cols == 1){
        Matrix resultmatrix = createMatrix(matrix1.rows, matrix2.cols);
        // TODO
        for(int rows = 0; rows < matrix1.rows; rows++){
            for(int cols = 0; cols < matrix2.cols; cols++){
                MatrixType wertm1 = getMatrixAt(matrix1, rows, 0);
                MatrixType wertm2 = getMatrixAt(matrix2, rows, cols);
                setMatrixAt(wertm1 + wertm2, resultmatrix, rows, cols);
            }
        }
        return resultmatrix;
    }

    Matrix undef; 
    undef.rows = 0;
    undef.cols = 0;
    undef.buffer = NULL;
    return undef;
}

Matrix multiply(const Matrix matrix1, const Matrix matrix2)
{
    // bedingung für A*B: A.cols = B.rows
    if(matrix1.cols == matrix2.rows){
        Matrix resultmatrix = createMatrix(matrix1.rows, matrix2.cols);
        for(int i = 0; i < matrix1.rows; i++){
            for(int j = 0; j < matrix2.cols; j++){
                MatrixType summe = 0;

                for(int l = 0; l <matrix1.cols; l++){
                    summe += getMatrixAt(matrix1, i, l) * getMatrixAt(matrix2, l, j);
                }
                setMatrixAt(summe, resultmatrix, i, j);
            }
        }
        return resultmatrix;
    }
    Matrix undef; 
    undef.rows = 0;
    undef.cols = 0;
    undef.buffer = NULL;
    return undef;
}