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

//Erstellt eine mit Nullen gefuellte Matrix, wenn genug Speicherplatz vorhanden ist und ein out-of-bounds-error durch unpassende Spalten oder Zeilen verhindert werden kann.
//Gibt die erstellte Matrix als Matrix-Objekt zurueck, also als eine Kopie der erstellten Matrix.
//@Param: rows gibt die Anzahl der Zeilen der neuen Matrix an, cols gibt die Anzahl der Spalten an
Matrix createMatrix(unsigned int rows, unsigned int cols)
{
    if(rows && cols){
    Matrix matrix;
    matrix.rows = rows;
    matrix.cols = cols;
    matrix.buffer = malloc(rows * cols * sizeof(MatrixType));

    matrix.buffer = malloc(rows * cols * sizeof(MatrixType));
    if (!matrix.buffer) {
    matrix.rows = 0;
    matrix.cols = 0;
    return matrix; // malloc ist fehlgeschlagen
    }


    for (int i = 0; i < (rows * cols); i++)
        matrix.buffer[i] = 0;

    return matrix;
    }
    Matrix matrix;
    matrix.rows = 0;
    matrix.cols = 0;
    matrix.buffer = 0;
    return matrix;
}

//Loescht die uebergebene Matrix vollstaendig aus dem Speicher.
//@Param: *matrix Gibt den Zeiger auf die zu loeschende Matrix wieder. Dadurch wird nicht nur eine Kopie geloescht, sondern tatsaechlich die Matrix.
void clearMatrix(Matrix *matrix)
{
  free(matrix->buffer);
  matrix->buffer = NULL;
  matrix->rows = 0;
  matrix->cols = 0;
}

//Setzt den Wert einer Matrix an einer bestimmten Stelle im Array.
//@Param: value gibt den einzufuegenden Wert an, matrix die Matrix, deren Wert geandert oder gesetzt werden soll,
// rowIdx die Anzahl der Zeilen, die im Speicher uebersprungen werden soll, um in die gewunschte Zeile zu kommen,
// collIdx die Nummer der Spalte, die geandert werden soll
void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
{
    matrix.buffer[rowIdx * matrix.cols + colIdx] = value;
}

//Gibt den Wert einer Matrix an einer bestimmten Stelle im Array zurueck.
//@Param: value gibt den einzufuegenden Wert an, matrix die Matrix, deren Wert geandert oder gesetzt werden soll,
//rowIdx die Anzahl der Zeilen, die im Speicher uebersprungen werden soll, um in die gewunschte Zeile zu kommen,
// collIdx die Nummer der Spalte, die gelesen werden soll
MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int colIdx)
{
  if(rowIdx >= matrix.rows || colIdx >= matrix.cols){
    return UNDEFINED_MATRIX_VALUE;
  }
  return matrix.buffer[rowIdx * matrix.cols + colIdx];
}

//Addiert zwei Matrizen miteinander oder broadcastet die eine Matrix mit einem Vektor.
//Ueberpueft, ob broadcasting moeglich ist. Wenn nicht, werden die Matrizen addiert. Prueft zusaetzlich, ob Matrizenaddition moeglich ist.
//Ist Broadcasting moeglich, wird die broadcasting-Methode aufgerufen.
//Gibt addierte Matrix zurueck, nachdem diese in der Funktion erstellt wurde.
//@param: matrix1 und matrix2 sind die Matrizen, deren Spalten und Zeilen ueberprueft werden und von denen moeglicherweise einer ein Vektor ist fuer das Broadcasting.
Matrix add(const Matrix matrix1, const Matrix matrix2)
{
    int rows1 = rows(matrix1);
    int rows2 = rows(matrix2);
    int cols1 = cols(matrix1);
    int cols2 = cols(matrix2);
    if((cols1 == 1 || cols2 == 1) && rows1 == rows2) //Broadcasting
    {
        if(cols1 == 1)      //Wenn die erste Matrix der Vektor ist
          {
            return broadcasting(matrix1, matrix2);
          }
        else
          {
            return broadcasting(matrix2, matrix1);
          }
    }
    else if(rows1 == rows2 && cols1 == cols2) //Addition nur moeglich, wenn beide Matrizen gleiche ANzahl an Zeilen und Spalten haben
    {
      Matrix addition = createMatrix(rows1, cols2); //Matrix erstellt, in die die addierten Werte geschrieben werden
      MatrixType wert1;
      MatrixType wert2;
      for(int i = 0; i < rows1; i++){ //soll fuer jedes Element durchlaufen, sodass alle Werte von beiden Matrizen aufaddiert werden.
        for(int j = 0; j < cols1; j++){
        wert1 = getMatrixAt(matrix1, i, j);
        wert2 = getMatrixAt(matrix2, i, j);
        MatrixType addierterWert = wert1 + wert2;
        setMatrixAt(addierterWert, addition, i, j);
        }
      }
      return addition;
    }
    else{
      return createMatrix(0,0);
    }
}

//Gibt die Matrix zurueck, die nach dem Broadcasting entstanden ist.
//Addiert einen Vektor zu einer Matrix, sodass jede Zelle der Matrix mit der Koordinate des Vektors addiert wird.
//@param: vektor ist die einspaltige Matrix, deren Koordinaten auf die Matrix addiert werden, matrix ist die Matrix, zu der der Vektor addiert wird.
Matrix broadcasting(const Matrix vektor, const Matrix matrix)
  {
      int rowsM = rows(matrix);
      int colsM = cols(matrix);
      Matrix result = createMatrix(rowsM, colsM);
      MatrixType wert;
      MatrixType koordinate;
      for(int i = 0; i < rowsM; i++)
        {
        for(int j = 0; j < colsM; j++){
          wert = getMatrixAt(matrix, i, j);
          koordinate = getMatrixAt(vektor, i, 0);
          setMatrixAt((koordinate + wert), result, i, j);
          }
        }
      return result;
  }

//Prueft, ob Multiplikation zweier Matrizen moeglich ist und gibt fuer den Fall, dass es moeglich ist, eine neue Matrix mit den Ergebnissen zurueck.
//@param: matrix1 und matrix2 geben die Matrizen an, die miteinander multipliziert werden sollen
Matrix multiply(const Matrix matrix1, const Matrix matrix2)
{
     int rows1 = rows(matrix1);
     int cols1 = cols(matrix1);
     int rows2 = rows(matrix2);
     int cols2 = cols(matrix2);
     if(cols1 == rows2) //Bedingung fuer Multiplikation: Spalten der ersten Matrix gleich Zeilen 2. Matrix
     {
         Matrix result = createMatrix(rows1, cols2);
         MatrixType wert1;
         MatrixType wert2;
         MatrixType mul;
         MatrixType add = 0;
         for(int i = 0; i < rows1; i++)
         {
           for(int k = 0; k < cols2; k++)
           {
            for(int j = 0; j < cols1; j++)
            {
              wert1 = getMatrixAt(matrix1, i, j);
              wert2 = getMatrixAt(matrix2, j, k);
              mul = wert1 * wert2;
              add += mul;
            }
            setMatrixAt(add, result, i, k);
            add = 0;
           }
         }
         return result;
     }
     return createMatrix(0,0);
}

//Gibt die Strukturvariable rows einer Matrix zurueck
//@param: matrix gibt an, von welcher Matrix die Strukturvariable uebergeben werden soll
int rows(const Matrix matrix)
{
   return matrix.rows;
}

//Gibt die Strukturvariable cols einer Matrix zurueck
//@param: matrix gibt an, von welcher Matrix die Strukturvariable uebergeben werden soll
int cols(const Matrix matrix)
{
  return matrix.cols;
}