#include "matrix.h"
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <fstream>
#include <iomanip>
#include <sstream>


using namespace std;

matrixClass::matrixClass()
{
    data = new mat(0, 0);
    //data->matrix = NULL;
}

matrixClass::~matrixClass() //destructor, deleting
{
    if(--data->numberReferences == 0)
      delete data;
}

matrixClass::matrixClass(int nrows, int ncolumns)  //create matrix
{
    if(nrows > 0 && ncolumns > 0)
    {
    if(!(data = new mat(nrows, ncolumns)))
      throw allocationMemError();
    }
    else
    {
    throw indexLessThanZero();
    }
}

matrixClass::matrixClass(const char* nameFile) //zczytywanie wartosci z pliku
{
    string lineA;
    double x;
    ifstream fileIN;
    int colA = 0;
    int rowA = 0;


    fileIN.open(nameFile);

    if(fileIN.fail())
    {
    throw errorWithOpeningFile();
    //exit(1);
    }

    cout << "\n" << endl;
    //counting of rows and columns
    while(fileIN.good())
    {
    while(getline(fileIN, lineA))
    {
        istringstream streamA(lineA);
        colA = 0;
        while(streamA >> x)
        {
            colA++;
        }
        rowA++;
    }

    cout << "Columns = " << colA << endl << endl;
    cout << "Rows = " << rowA << endl << endl;
    }
    fileIN.close();

    if(!(data = new mat(rowA, colA)))
    throw allocationMemError();

    rowA = 0;
    colA = 0;

    fileIN.open(nameFile);

    if(fileIN.fail())
    {
      throw errorWithOpeningFile();
      //exit(1);
    }

    cout << "\n" << endl;
    while(fileIN.good())
            {
    while(getline(fileIN, lineA))
            {
        istringstream streamA(lineA);
        colA = 0;
        while(streamA >> x)
        {

            data->matrix[rowA][colA] = x;
            colA++;
        }
        rowA++;
        }

    cout << "Columns = " << colA << endl << endl;
    cout << "Rows = " << rowA << endl << endl;
    }
}


matrixClass::matrixClass(matrixClass& temp)
{
    temp.data->numberReferences++;
    data = temp.data;
}

matrixClass& matrixClass::operator=(const matrixClass& x)
{
    x.data->numberReferences++;
    if(--data->numberReferences == 0)
      delete data;
    data = x.data;
    return *this;
}



ostream& operator<<(ostream& pokaz, matrixClass& macierz)
{
    int nrows = macierz.data->rows;
    int ncolumns = macierz.data->columns;
    int i;
    int j;
    for(i = 0; i < nrows; i++)
    {
      for(j = 0; j < ncolumns; j++)
      {
        pokaz << left << setw(10) << macierz.data->matrix[i][j] << "  ";
      }
      pokaz << endl;
    }

    pokaz << endl << endl;
    //pokaz << "Macierz po pierwszym przejsciu" << endl << endl;
    return pokaz;
}

double matrixClass::read(int nrow, int ncol) const
{
    return data->matrix[nrow - 1][ncol - 1];
}

void matrixClass::check(int nrow, int ncol) const
{
    if(((0 < nrow) && (nrow <= data->rows)) && ((0 < ncol) && (ncol <= data->columns))) ;
    else
      throw indexOutOfRange();
}

double matrixClass::operator()(int nrow, int ncol) const
{
      if((nrow > data->rows) || (ncol > data->columns))
      throw indexOutOfRange();

      return read(nrow, ncol);
}

matrixClass::Cref matrixClass::operator()(int nrow, int ncol)
{
      if((nrow > data->rows) || (ncol > data->columns))
      throw indexOutOfRange();

      return Cref(*this, nrow, ncol);
}


matrixClass& matrixClass::operator+=(matrixClass& s)
{
    if((data->rows == s.data->rows) && (data->columns == s.data->columns))
    {
    mat *temp = new mat(data->rows, data->columns);
    for(int i = 0; i < data->rows; i++)
    {
        for(int j = 0; j < data->columns; j++)
        {
        temp->matrix[i][j] = ((data->matrix[i][j]) + (s.data->matrix[i][j]));
        }
    }
    if(--data->numberReferences == 0)
      delete data;
    data = temp;
    }
    else
      throw badRowsColumnsDimensions();

    return *this;
}

matrixClass& matrixClass::operator-=(matrixClass& s)
{
    if((data->rows == s.data->rows) && (data->columns == s.data->columns))
    {
    mat *temp = new mat(data->rows, data->columns);
    for(int i = 0; i < data->rows; i++)
    {
        for(int j = 0; j < data->columns; j++)
        {
        temp->matrix[i][j] = ((data->matrix[i][j]) - (s.data->matrix[i][j]));
        }
    }
    if(--data->numberReferences == 0)
      delete data;
    data = temp;
    }
    else
      throw badRowsColumnsDimensions();

    return *this;
}



matrixClass operator+(matrixClass& a, matrixClass& b)
{
    if(a.data->rows == b.data->rows && a.data->columns == b.data->columns)
    {
    matrixClass temp(a.data->rows, a.data->columns);
    for(int i = 0; i < a.data->rows; i++)
    {
        for(int j = 0; j < a.data->columns; j++)
        temp.data->matrix[i][j] = a.data->matrix[i][j] + b.data->matrix[i][j];
    }
    return temp;
    }
    else
      throw matrixClass::badRowsColumnsDimensions();

}


matrixClass operator-(matrixClass& a, matrixClass& b)
{
    if(a.data->rows == b.data->rows && a.data->columns == b.data->columns)
    {
    matrixClass temp(a.data->rows, a.data->columns);
    for(int i = 0; i < a.data->rows; i++)
    {
        for(int j = 0; j < a.data->columns; j++)
        temp.data->matrix[i][j] = a.data->matrix[i][j] - b.data->matrix[i][j];
    }
    return temp;
    }
    else
    throw matrixClass::badRowsColumnsDimensions();

    //return temp;
}

void matrixClass::write(int nrow, int ncol, double c)
{
    if(((0 < nrow) && (nrow <= data->rows)) && ((0 < ncol) && (ncol <= data->columns)))
    {
    data = data->detach();
    data->matrix[nrow - 1][ncol - 1] = c;
    }
    else
    throw badRowsColumnsDimensions();
}




matrixClass operator*(double number, matrixClass &b)
{
    matrixClass temp(b.data->rows, b.data->columns);
    for(int i = 0; i < b.data->rows; i++)
    {
    for(int j = 0; j < b.data->columns; j++)
    {
        temp.data->matrix[i][j] = number * (b.data->matrix[i][j]);
    }
    }
    return temp;
}

matrixClass operator*(matrixClass &b, double number)
{
    matrixClass temp(b.data->rows, b.data->columns);
    for(int i = 0; i < b.data->rows; i++)
    {
    for(int j = 0; j < b.data->columns; j++)
    {
        temp.data->matrix[i][j] = (number * (b.data->matrix[i][j]));
    }
    }
    return temp;
}

matrixClass operator*(matrixClass &a, matrixClass &b)
{
    int iterator;
    int iterator1;
    int iterator2;
    double sum = 0;
      if(a.data->columns == b.data->rows)
      {
      matrixClass temp(a.data->rows, b.data->columns);
      for(iterator = 0; iterator < a.data->rows; iterator++)
      {
          for(iterator1 = 0; iterator1 < b.data->columns; iterator1++)
          {
          for(iterator2 = 0; iterator2 < a.data->columns; iterator2++)
          {
              sum = sum + (a.data->matrix[iterator][iterator2] * b.data->matrix[iterator2][iterator1]);
          }
          temp.data->matrix[iterator][iterator1] = sum;
          sum = 0;
          }
      }
      return temp;
      }
      else
      throw matrixClass::badRowsColumnsDimensions();
}

matrixClass& matrixClass::operator*=(matrixClass& s)
{
    int iterator;
    int iterator1;
    int iterator2;
    double sum = 0;
      if(data->columns == s.data->rows)
      {
      mat *temp = new mat(data->rows, s.data->columns);
      for(iterator = 0; iterator < data->rows; iterator++)
      {
          for(iterator1 = 0; iterator1 < s.data->columns; iterator1++)
          {
          for(iterator2 = 0; iterator2 < data->columns; iterator2++)
          {
              sum = sum + (data->matrix[iterator][iterator2] * s.data->matrix[iterator2][iterator1]);
          }
          temp->matrix[iterator][iterator1] = sum;
          sum = 0;
          }
      }

    if(--data->numberReferences == 0)
      delete data;
    data = temp;
      }
      return *this;
}

matrixClass& matrixClass::operator*=(double number)
{
    int iterator;
    int iterator1;

    mat *temp = new mat(data->rows, data->columns);

    for(iterator = 0; iterator < data->rows; iterator++)
    {
    for(iterator1 = 0; iterator1 < data->columns; iterator1++)
    {
      temp->matrix[iterator][iterator1] = number * data->matrix[iterator][iterator1];
    }
    }
    if(--data->numberReferences == 0)
      delete data;
    data = temp;
    return *this;
}

int operator==(matrixClass &a, matrixClass &b)
{
    if((a.data->rows != b.data->rows) || (a.data->columns != b.data->columns))
    {
    return 0;
    }
    else if((a.data->rows == b.data->rows) && (a.data->columns == b.data->columns))
    {
    for(int i = 0; i < a.data->rows; i++)
    {
        for(int j = 0; j < a.data->columns; j++)
        {
        if(a.data->matrix[i][j] != b.data->matrix[i][j])
          return 0;
        }
    }
    }
    return 1;
}