#include <iostream>
#include <fstream>
#include <cstdlib>
#include "macierz.h"

Macierz::Macierz (const char *path){

    fstream FILE;
    FILE.open (path,ios::in);
    if (FILE.good()){
        FILE >> n >> m;
        alokacja(n,m);
        wypelnijMacierz(FILE);
    }
    else {
    cout << "Nie mozna otworzyc ktoregos z plikow.";
    exit(-1);
    }

	FILE.close();
}
Macierz::Macierz (int n,int m) {
    this->n=n;
    this->m=m;
    alokacja(n,m);

}

Macierz::Macierz(const Macierz& A){
    n=A.n;
    m=A.m;
    try{
        tab=new double *[n];
        for(int i=0;i<n; i++) {
            tab[i]=new double [m];
        }
    }
    catch(bad_alloc){
        cout<<"nie udalo sie zaalokowac pamieci"<<endl;
        exit(-1);
    }
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            tab[i][j]=A.tab[i][j];
        }
    }
}

Macierz::~Macierz() {
    cout<<endl<<"Hello ;P"<<endl;

    for (int i = 0;i < n; i++) {
        delete [] tab[i];
    }
    delete [] tab;

}

void Macierz::alokacja(int n, int m){
    try{
        tab = new double*[n];
        for (int i=0;i< n;i++){
            tab[i] = new double [m];
        }

        if (tab == NULL){
            throw bad_alloc();
        }
    }
    catch(bad_alloc){
        cout<<"Nie udalo sie zaalokowac pamieci"<<endl;
        exit(-1);
    }
    for (int i=0;i< n;i++){
        for (int j=0;j< m;j++){
            tab[i][j]=0;
        }
    }
}

void Macierz::wypelnijMacierz(fstream & FILE) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            FILE >> tab[i][j];
        }
    }
}

ostream & operator << (ostream& out, const Macierz &A){
    for (int i = 0; i < A.n; i++){
        for (int j=0; j < A.m; j++){
            out.width(3);
            out << A.tab[i][j];
        }
    out << endl;
    }
    out << endl;
    return out;
}
double & Macierz::operator()(int N, int M) {
    try {
        if(N < 0 || N < 0 || N >= n || M >= m) {
            throw ZlyIndeks();
        }
    }
    catch(ZlyIndeks) {
        cout << "Zly indeks macierzy." << endl;
        exit(1);
    }
    return tab[N][M];
}
Macierz & Macierz::operator=(const Macierz &A){
	for(int i=0;i<this->n;i++) delete []this->tab[i];
                delete []this->tab;
    if( this != &A ) {

        alokacja(A.n, A.m);
        n=A.n;
        m=A.m;
        for(int i=0; i<A.n; i++) {
            for(int j=0; j<A.m; j++) {
                tab[i][j] = A.tab[i][j];
            }
        }
    }
    return *this;
}

Macierz Macierz::operator+(const Macierz &A){
    try {
        if (n != A.n || m !=A.m) {
            throw ZlyRozmiar();
        }
    }
    catch (ZlyRozmiar) {
        cout << "Blad! Macierze maja rozne rozmiary";
        exit(-1);
    }
    Macierz sum(*this);
    sum+=A;
    return sum;
}

Macierz Macierz::operator-(const Macierz &A){
    try {
        if (n != A.n || m !=A.m) {
            throw ZlyRozmiar();
        }
    }
    catch (ZlyRozmiar) {
        cout << "Blad! Macierze maja rozne rozmiary";
        exit(-1);
    }
    Macierz roznica(*this);
    roznica-=A;
    return roznica;
}

Macierz Macierz::operator*(const Macierz &A){
    try {

        if (m != A.n) {
            throw ZlyRozmiar();
        }
    }
    catch (ZlyRozmiar) {
        cout << "Blad! Macierze maja niepoprawne rozmiary";
        exit(-1);
    }
    Macierz iloczyn(n, A.m);
    for (int i=0 ; i< iloczyn.n ; i++){
        for (int j=0 ; j< iloczyn.m ; j++){
            for (int k=0 ; k< A.n ; k++){
                iloczyn.tab[i][j]+=tab[i][k]*A.tab[k][j];
            }
        }
    }
    return iloczyn;
}

Macierz & Macierz::operator+=(const Macierz &A){
    try {
        if (n != A.n || m !=A.m) {
            throw ZlyRozmiar();
        }
    }
    catch (ZlyRozmiar) {
        cout << "Blad! Macierze maja rozne rozmiary";
        exit(-1);
    }
    for (int i=0 ; i< A.n ; i++){
        for (int j=0 ; j< A.m ; j++){
            tab[i][j]+=A.tab[i][j];
        }
    }
    return *this;
}

Macierz & Macierz::operator-=(const Macierz &A){
    try {
        if (n != A.n || m !=A.m) {
            throw ZlyRozmiar();
        }
    }
    catch (ZlyRozmiar) {
        cout << "Blad! Macierze maja rozne rozmiary";
        exit(-1);
    }
    for (int i=0 ; i< A.n ; i++){
        for (int j=0 ; j< A.m ; j++){
            tab[i][j]-=A.tab[i][j];
        }
    }
    return *this;
}

Macierz &Macierz::operator*=(const Macierz &A){
    try {

        if (m != A.n) {
            throw ZlyRozmiar();
        }
    }
    catch (ZlyRozmiar) {
        cout << "Blad! Macierze maja niepoprawne rozmiary";
        exit(-1);
    }
    Macierz iloczyn(n, A.m);
    for (int i=0 ; i< n ; i++){
        for (int j=0 ; j< m ; j++){
            for (int k=0 ; k< A.n ; k++){
                iloczyn.tab[i][j]+=tab[i][k]*A.tab[k][j];
            }
        }
    }
    *this=iloczyn;
    return *this;
}

void Macierz::transponuj() {
    Macierz help(m,n);

    for(int i=0; i<n; i++) {
        for(int j=0; j<m; j++) {
            help.tab[j][i] = tab[i][j];
        }
    }
    alokacja(m,n);
    for(int i=0; i<m; i++) {
        for(int j=0; j<n; j++) {
            tab[i][j] = help.tab[i][j];
        }
    }
    int tmp=m;
    m=this->n;
    n=tmp;

}